From f53887dbf4454df3690067a83af73b99beccaee6 Mon Sep 17 00:00:00 2001 From: Claudius Date: Wed, 18 Nov 2026 16:44:55 +0000 Subject: [PATCH] ios27/a64e: translate libcorecrypto and reseal its FIPS seal; census and log/verify/restore for a64e-rewrite The S9's hottest A64E traps on 24B156 (~100k RETAB traps per 10 s while iconservicesagent re-renders icons after a dark-mode switch, thousands at idle) are all in /usr/lib/system/libcorecrypto.dylib, which the cache pipeline skipped because its FIPS self-test MACs its own __text. That MAC is HMAC-SHA256 with an all-zero key over __TEXT,__text, stored in __TEXT,__fips_hmacs (apple/corecrypto fipspost_get_hmac.c), so it can be recomputed for the rewritten code. - a64e/fips-seal.py check|reseal|restore: recompute the seal only where it was true in the reference (stock) cache and the stored value is still the reference one; logged, restorable. Pure Python. - a64e/fips-seal-test.py (CI): made-up Mach-O files; sealed, broken, reseal, restore, refusals. - a64e-rewrite.py: cache --log (ADDR OLD NEW), verify/restore from the log, and census: per image the words the rewrite would still change, nothing skipped; exit 1 unless allowed. - cache-pipeline.sh: steps 1/2/4 skip only the unloaded libcorecrypto_noasm/_trace; 5b reseal + check; 9 census. - docs/ios27/CORECRYPTO.md; INSTALL-S9.md and SPEED.md updated. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/check.yml | 2 + docs/ios27/CORECRYPTO.md | 59 ++++ docs/ios27/INSTALL-S9.md | 7 + docs/ios27/SPEED.md | 1 + tools/ios27/a64e/a64e-rewrite.py | 128 ++++++++- tools/ios27/a64e/fips-seal-test.py | 106 ++++++++ tools/ios27/a64e/fips-seal.py | 253 ++++++++++++++++++ .../ios27/fullroot/pipeline/cache-pipeline.sh | 18 +- 8 files changed, 562 insertions(+), 12 deletions(-) create mode 100644 docs/ios27/CORECRYPTO.md create mode 100755 tools/ios27/a64e/fips-seal-test.py create mode 100755 tools/ios27/a64e/fips-seal.py diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index d42c6a8c1..e787f7c5c 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -56,6 +56,8 @@ jobs: run: python3 tools/ios27/builds/builds-test.py - name: sbca's QuartzCore tables per iOS build (tables, headers, checker) run: python3 tools/ios27/ca-gpu/sbca_table_test.py + - name: corecrypto's FIPS seal is recomputed only where it was true, and restored exactly (fips-seal.py, made-up Mach-O files) + run: python3 tools/ios27/a64e/fips-seal-test.py - name: shared-cache header facts for the AOT rewrite run: python3 tools/ios27/fullroot/pipeline/cache/aot/dsc_header_test.py - name: The S9's firmware in the iOS 27 root build is complete and checked or the build stops, and the root says what it has (made-up files) diff --git a/docs/ios27/CORECRYPTO.md b/docs/ios27/CORECRYPTO.md new file mode 100644 index 000000000..ebed2f9fb --- /dev/null +++ b/docs/ios27/CORECRYPTO.md @@ -0,0 +1,59 @@ +# libcorecrypto on the S9: the hottest arm64e traps, and its FIPS seal (18 November 2026) + +## What the phone was trapping on + +On phone 1 (iOS 27.2.1, 24B156, the `o272` boot image, root v9) the kernel's `STARLTE A64E hot` line (the ten sites that trapped most in +the last ten seconds) read, at idle, a pair of `RETAB` words at about 2,000-15,000 traps each per ten seconds, and during the re-render of +the home screen's icons after a switch to dark mode (`iconservicesagent` at ~150 % CPU for two minutes) **106,512 and 104,880** traps in one +ten-second interval at those two words, with a dozen more sites at 2,000-17,000 (`RETAB` `d65f0fff`, `BLRAAZ x8` `d63f091f`, +`BLRAA x16, x17` `d73f0a11`, `BRAAZ x5` `d61f08bf`). `STARLTE LSE hot` had one more site next to them. + +The addresses in those lines are **slid**: the same sites read `0x1da0a3c5c` in a boot whose `CRASH` lines say `slide 0x63a8000` and +`0x1d919fc5c` in one with `slide 0x54a4000`; both are `0x1d3cfbc5c` unslid. Every hot site, unslid, is in +`/usr/lib/system/libcorecrypto.dylib`'s `__TEXT,__text`: the hottest pair is the return of `ccder_blob_decode_range` (`0x1d3cfbbe0`) and of +the local function right after it (`0x1d3cfbc5c`), then `ccder_sizeof` and local functions whose names are not in the cache (DER decoding, +most likely of signatures and certificates). The LSE site is the library's one `SWP` (`0x1d3cfa77c`). + +## Why they were left + +Not an encoding the rewrite misses, not a section it does not scan: `a64e-rewrite.py` handles all of them. The cache pipeline passed it +`--skip libcorecrypto` (and `lse-rewrite.py`, `a64e-rewrite2.py`, `rewrite-grow.py` skip it by default), because corecrypto's FIPS +power-on self-test checks a MAC of its own code, and a rewritten library fails it. So the whole library, 3,538 words (1,500 `RETA*`, 67 +`BRA*`, 1,312 `BLRA*`, 659 `PAC*`/`AUT*` register forms), stayed arm64e and went through the kernel's emulation on every call. + +`a64e-rewrite.py census` (new) shows it at once: on the v9 root's cache it prints exactly three images with words left, the three +corecrypto images, and nothing else in 4,759. + +## The seal, and why it can simply be recomputed + +corecrypto's integrity test (`fipspost_post_integrity`, run in user space by `/usr/libexec/cc_fips_test`; apple/corecrypto +`cc_fips/src/fipspost_get_hmac.c`) is HMAC-SHA256 with a key of 32 zero bytes over the image's first `__TEXT,__text` section, compared with +the 32 bytes of its `__TEXT,__fips_hmacs` section. There is no secret and nothing outside the image: on the 24B156 cache the stored value +of `libcorecrypto.dylib` is exactly that HMAC of its `__text` as it sits in the cache. `tools/ios27/a64e/fips-seal.py` recomputes it after +the rewrite and writes it into `__fips_hmacs`, **only for an image whose seal was true in the reference** (the stock cache, or the cache +before the step) and whose stored value is still the reference one. The test is as strong as before: any change after the reseal fails it +again. The `_noasm` and `_trace` variants are not loaded by anything and their seals are already false in the stock cache; they stay +untranslated and untouched. + +So the stand-in for `cc_fips_test` that the project's roots carry (`docs/ios27/SPEED.md`, "Not published") is no longer needed for this: +the real test's integrity check passes on a resealed cache (the stand-in is still on the roots; the real helper has not been run on a phone). + +## The tools + +- `a64e-rewrite.py cache ... --log FILE` writes `ADDR OLD NEW` for every changed word; `verify --log` checks every word holds its new value, + `restore --log` puts the originals back (round trip, as `lse-rewrite.py verify/restore`). +- `a64e-rewrite.py census CACHE [--allow SUBSTR ...]`: per image, the words the rewrite would still change, nothing skipped; exit 1 for an image + not allowed. The pipeline runs it last (step 9) with only the two unloaded variants allowed. +- `fips-seal.py check|reseal|restore` (pure Python; `fips-seal-test.py` exercises it on made-up Mach-O files, in CI). +- `pipeline/cache-pipeline.sh`: steps 1, 2 and 4 now skip only `libcorecrypto_noasm` and `libcorecrypto_trace`; step 5b reseals and checks + (before the `PRE` reference of the grow step, which skips corecrypto); step 9 is the census. + +The LSE pass over corecrypto must run with the text-data skip map (`TEXTDATA_SKIP`, `docs/ios27/TEXT-DATA.md`), as it does in the pipeline: +two words of corecrypto's SHA-256 constant table (`0x78a5636f`) have the bit pattern of `LDUMAXAH` and would otherwise become branches. + +## On the v9 root (off the phone) + +As one root step on a clone of root v9 (the step script and its undo are private, on the mini): 3,538 words rewritten and verified, the +one `SWP` given a thunk (the two table words left alone), the seal recomputed and checked; 3,560 words of one subcache file and 4 of +another differ from v9, nothing else. `textdata-guard.py scan --pac` against v9 flags six of the changed words by rule D; all six are +ordinary code (epilogues, `BLRAAZ` calls, `PACIZA x16` before a store). The census then shows only the two unloaded variants. diff --git a/docs/ios27/INSTALL-S9.md b/docs/ios27/INSTALL-S9.md index 9a593450e..eaf73a75e 100644 --- a/docs/ios27/INSTALL-S9.md +++ b/docs/ios27/INSTALL-S9.md @@ -216,6 +216,13 @@ have not been booted together.** `prepare-root-inputs.sh` makes the build's private directory (`tools/ios27/fullroot/private/`, never in git): instruction tables from your cache, the checked patch list, and one script of wardevsa's fetched from his public repository at a fixed commit. +Since 18 November 2026 the pipeline rewrites `libcorecrypto` like every other library and then recomputes its FIPS integrity seal +(`tools/ios27/a64e/fips-seal.py`, step 5b): the self-test is HMAC-SHA256 with an all-zero key over the library's `__text`, so the +seal of the rewritten code is made the same way, and only where the stock seal was true (`docs/ios27/CORECRYPTO.md`). Before that the +library was skipped and its 3,538 pointer-authentication words trapped into the kernel's emulation: on 24B156 they were the +phone's hottest traps (about 100,000 in ten seconds while the icons re-render after a switch to dark mode). Its two unloaded variants +(`_noasm`, `_trace`) are still left exactly as Apple built them. The paragraph below describes the builds before that change. + One library is left exactly as Apple built it: `libcorecrypto` (and its two variants). It checks a hash of its own code when it starts, so rewriting it makes its self-test fail; the project's own phones run a rewritten copy with a local stand-in for the self-test's helper, and neither the stand-in nor a way to make one is published (`docs/ios27/SPEED.md`, "Not published"). Your root diff --git a/docs/ios27/SPEED.md b/docs/ios27/SPEED.md index 22816d5fc..49b5dca9e 100644 --- a/docs/ios27/SPEED.md +++ b/docs/ios27/SPEED.md @@ -62,6 +62,7 @@ configd's InterfaceNamer never reports IOKit quiet on this kernel. SystemConfigu `pacibsp` (unslid address `0x1ab5bc514` in the iOS 27.0.1 cache the work used); changing that word to `ret` ends the wait. The real fix is the IOService that keeps IOKit busy; it was not found. +**Superseded on 18 November 2026** by `tools/ios27/a64e/fips-seal.py`, which recomputes the self-test's seal for the rewritten code (`docs/ios27/CORECRYPTO.md`). **Not published.** An earlier step rewrote libcorecrypto too, which makes its FIPS self-test fail, and the work ran for a while with a locally made stand-in for the test's helper. That is a local, optional step the builder took on their own root: this repository has no stand-in, no way to make one and no tool that needs one (`a64e-rewrite2.py` skips libcorecrypto unless told not to), and `docs/ios27/EIGHT-CORES.md`'s rewrite skips it too. Root images, the originals of diff --git a/tools/ios27/a64e/a64e-rewrite.py b/tools/ios27/a64e/a64e-rewrite.py index decb900e0..55700a54a 100755 --- a/tools/ios27/a64e/a64e-rewrite.py +++ b/tools/ios27/a64e/a64e-rewrite.py @@ -11,9 +11,18 @@ Left for the kernel (sweet_a64e.c) to emulate on trap: PACGA, FJCVTZS, FCADD, LDRA* with writeback or out-of-range offsets. - a64e-rewrite.py cache DIR/dyld_shared_cache_arm64e [--only SUBSTR ...] [--dry-run] + a64e-rewrite.py cache DIR/dyld_shared_cache_arm64e [--only SUBSTR ...] [--skip SUBSTR ...] [--dry-run] [--log FILE] a64e-rewrite.py macho FILE ... [--dry-run] (thin or fat; arm64e slices) -Files are modified in place (clone them first: cp -c). + a64e-rewrite.py census CACHE_MAIN [--allow SUBSTR ...] per image, the words this rewrite would still change (no image + skipped): exit 1 if an image not named by --allow has any + a64e-rewrite.py verify CACHE_MAIN --log FILE every logged word holds its new value + a64e-rewrite.py restore CACHE_MAIN --log FILE every logged word gets its original value back +Files are modified in place (clone them first: cp -c). --log writes "ADDR OLD NEW" per changed word ("# image PATH" before +each image), so a cache rewrite can be verified and undone word for word. + +libcorecrypto: its FIPS self-test (cc_fips_test) MACs its own __text. Rewrite it and then reseal it with fips-seal.py (the +seal is recomputed only where it was true before; docs/ios27/CORECRYPTO.md). Skipping it, as the pipeline did until +18 November 2026, leaves its RETAB/BLRAA/BRAA words to the kernel's emulation: the hottest traps of the S9. Data inside the code: the words of an LC_DATA_IN_CODE range are never touched (macho mode); a LDRAx / LDAPR candidate with an undecodable word within 8 words before and after it is left alone too (macho mode; A64E_NO_RULE_C=1 turns @@ -124,7 +133,8 @@ def text_sections(lc, ncmds): off += csz -def do_cache(main, only, dry, skip=()): +def do_cache(main, only, dry, skip=(), log=None, per=None): + """log: a file to write "ADDR OLD NEW" lines to. per: a list that gets (path, counts) per image (census).""" maps = [] files = {} for p in sorted(glob.glob(main + '*')): @@ -173,17 +183,31 @@ def read(addr, n): continue ncmds, sz = struct.unpack_from(' 256 << 20: # write back as it goes: a slow (USB) image would pile up dirty pages for mm in files.values(): @@ -245,9 +269,86 @@ def do_macho(path, dry, left=None): return len(slices), tot +def check_log(main, logp, restore=False, dry=False): + """verify (restore=False): every logged word holds NEW. restore: every logged word that holds NEW gets OLD back. + Returns (ok, bad).""" + maps, files = [], {} + for p in sorted(glob.glob(main + '*')): + if p.endswith(('.map', '.atlas', '.symbols')): + continue + with open(p, 'rb') as f: + h = f.read(0x200) + if not h.startswith(b'dyld_v1'): + continue + mo, mc = struct.unpack_from(' {new:08x}') + if restore and not dry: + for mm in files.values(): + mm.flush() + return ok, bad + + +def census(main, allow): + """the words a64e-rewrite would still change, per image, with nothing skipped; exit status 1 if an image not in allow + has any. A skipped image (libcorecrypto until 18 November 2026) shows up here instead of in the kernel's trap counts.""" + per = [] + _, tot = do_cache(main, (), True, (), per=per) + keys = ('ret', 'br', 'blr', 'pac', 'ldra', 'ldapr') + bad = 0 + rows = sorted(((c.get('changed', 0), p, c) for p, c in per), reverse=True) + for n, p, c in rows: + if not n: + break + allowed = any(x in p for x in allow) + bad += not allowed + print(f'{"allowed" if allowed else "LEFT":8s} {n:7d} {p} ' + ' '.join(f'{k} {c.get(k, 0)}' for k in keys if c.get(k))) + left = {k: v for k, v in tot.items() if k.endswith('_left') and v} + print(f'census: {len(per)} images, {sum(1 for n, _, _ in rows if n)} with words to rewrite, {bad} not allowed; ' + f'left for the kernel by design: {left}') + return bad + + def main(): ap = argparse.ArgumentParser() - ap.add_argument('kind', choices=['cache', 'macho']) + ap.add_argument('kind', choices=['cache', 'macho', 'census', 'verify', 'restore']) + ap.add_argument('--log', help='cache: write ADDR OLD NEW per changed word; verify/restore: the log of a cache run') + ap.add_argument('--allow', nargs='*', default=[], help='census: images allowed to keep words to rewrite') ap.add_argument('paths', nargs='+') ap.add_argument('--only', nargs='*', default=[]) ap.add_argument('--dry-run', action='store_true') @@ -255,8 +356,19 @@ def main(): help='leave images whose path contains one of these untranslated ' '(libcorecrypto: its FIPS self-test MACs its own code)') a = ap.parse_args() + if a.kind == 'census': + sys.exit(1 if census(a.paths[0], a.allow) else 0) + if a.kind in ('verify', 'restore'): + if not a.log: + ap.error(f'{a.kind} needs --log') + ok, bad = check_log(a.paths[0], a.log, a.kind == 'restore', a.dry_run) + print(f'{a.kind}: {ok} ok, {bad} bad') + sys.exit(1 if bad else 0) if a.kind == 'cache': - n, tot = do_cache(a.paths[0], a.only, a.dry_run, a.skip) + log = open(a.log, 'w') if a.log else None + n, tot = do_cache(a.paths[0], a.only, a.dry_run, a.skip, log=log) + if log: + log.close() print(f'{n} images', tot) if os.environ.get('TEXTDATA_SKIP'): print(f'textdata: {tot.get("data_left", 0)} words left alone') diff --git a/tools/ios27/a64e/fips-seal-test.py b/tools/ios27/a64e/fips-seal-test.py new file mode 100755 index 000000000..cbeb07437 --- /dev/null +++ b/tools/ios27/a64e/fips-seal-test.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python3 +"""fips-seal-test.py - fips-seal.py on made-up Mach-O files (no Apple bytes): a true seal is reported sealed; changing one +instruction of __text makes it BROKEN; reseal against the reference makes it true again and logs the old value; restore puts +the old value back; a seal that is false in the reference is never written; a reseal without a reference is refused. +Pure Python; run from anywhere: python3 tools/ios27/a64e/fips-seal-test.py""" +import hashlib, hmac, os, shutil, struct, subprocess, sys, tempfile + +HERE = os.path.dirname(os.path.abspath(__file__)) +TOOL = os.path.join(HERE, 'fips-seal.py') +BASE, TEXT_OFF, SEAL_OFF, SIZE = 0x100000, 0x200, 0x800, 0x1000 +RETAB, RET, BLRAA_X16_X17, BLR_X16 = 0xD65F0FFF, 0xD65F03C0, 0xD73F0A11, 0xD63F0200 + + +def macho(words, seal=None, extra_seg=True): + text = struct.pack(f'<{len(words)}I', *words) + mac = hmac.new(bytes(32), text, hashlib.sha256).digest() if seal is None else seal + nsect = 2 + cmdsize = 72 + 80 * nsect + lcs = struct.pack(' S9 (Exynos M3, ARMv8.0 + A55) ready cache, in the owner-build order: -# 1 a64e-rewrite arm64e -> arm64 in place (RETA*/BRA*/BLRA*/PAC*/AUT*/XPAC* -> RET/BR/BLR/NOP, LDRAx, LDAPR->LDAR), libcorecrypto skipped (FIPS MAC) +# 1 a64e-rewrite arm64e -> arm64 in place (RETA*/BRA*/BLRA*/PAC*/AUT*/XPAC* -> RET/BR/BLR/NOP, LDRAx, LDAPR->LDAR), libcorecrypto included +# (its FIPS seal is recomputed in 5b; only the unloaded _noasm/_trace variants, $CC_SKIP, are left) # 1b stubscan --fix the same rewrite for the stub islands (BRAA x16,x17 / RETAA outside image __TEXT; 175 words in subcache .24 alone) # 2 lse-rewrite LSE atomics -> LL/SC thunks in the zero padding of each image's __TEXT (hot images) # 4 a64e-rewrite2 PACGA -> AND and LDRAx writeback -> LDR over the whole cache (needs a kernel whose pacga_hash = a & 0xffffffff00000000) +# 5b fips-seal libcorecrypto's FIPS integrity seal (HMAC-SHA256 of __text in __TEXT,__fips_hmacs) recomputed for the rewritten code, +# only where it was true in the stock cache; then checked (docs/ios27/CORECRYPTO.md) # 5 cachepatch Settings (SystemConfiguration IOKit-quiesce block -> ret), kbd (SafariCore app-data-container -> ret), # QuartzCore 0.1 s update clamp off, PosterBoard Fix A (PFPosterPath resource-values count 2 -> 1) # 6 rewrite-grow full AOT rewrite of every remaining non-ARMv8.0 instruction (LSE cold images, FP16, FCMA, DotProd, RDM, @@ -18,6 +21,7 @@ set -euo pipefail SRC=$1; OUT=$2 PIPE=$(cd "$(dirname "$0")" && pwd); HERE=$PIPE/cache; TOOLS=${IOS27_TOOLS:-$PIPE/../..} # TOOLS = scion-kernel tools/ios27 PY=${PY:-python3} +CC_SKIP=(libcorecrypto_noasm libcorecrypto_trace) # unloaded variants; their seals are false in the stock 24B156 cache already mkdir -p "$OUT"; cd "$OUT" C=$OUT/c; PRE=$OUT/pre echo "== 0 copy stock cache $(date -u +%T)"; rm -rf "$C" "$PRE" lse.log rewrite.log; mkdir "$C"; for f in "$SRC"/dyld_shared_cache_arm64e*; do case $f in *.symbols) ;; *) cp "$f" "$C"/;; esac; done # the 1.2 GB .symbols stays out @@ -32,15 +36,19 @@ if [[ -f $TD/undef.txt ]]; then else echo "no $TD/undef.txt: no skip map" fi -echo "== 1 a64e $(date -u +%T)"; nice -n 10 $PY -I $TOOLS/a64e/a64e-rewrite.py cache $M --skip libcorecrypto +echo "== 1 a64e $(date -u +%T)"; nice -n 10 $PY -I $TOOLS/a64e/a64e-rewrite.py cache $M --skip "${CC_SKIP[@]}" --log "$OUT/a64e.log" +$PY -I $TOOLS/a64e/a64e-rewrite.py verify $M --log "$OUT/a64e.log" echo "== 1b stub islands $(date -u +%T)"; nice -n 10 $PY -I $HERE/stubscan.py $M --fix # BRAA*/RETA* in the small stub subcaches (outside any image __TEXT) -echo "== 2 lse $(date -u +%T)"; nice -n 10 $PY -I $TOOLS/lse/lse-rewrite.py cache $M --log "$OUT/lse.log" +echo "== 2 lse $(date -u +%T)"; nice -n 10 $PY -I $TOOLS/lse/lse-rewrite.py cache $M --skip "${CC_SKIP[@]}" --log "$OUT/lse.log" $PY -I $TOOLS/lse/lse-rewrite.py verify $M --log "$OUT/lse.log" -echo "== 4 a64e-rewrite2 (PACGA/LDRA wb) $(date -u +%T)"; nice -n 10 $PY -I $TOOLS/speed/a64e-rewrite2.py cache $M +echo "== 4 a64e-rewrite2 (PACGA/LDRA wb) $(date -u +%T)"; nice -n 10 $PY -I $TOOLS/speed/a64e-rewrite2.py cache $M --skip "${CC_SKIP[@]}" echo "== 5 cachepatch $(date -u +%T)" CP="$PY -I $TOOLS/speed/cachepatch.py $C" PATCHES=${IOS27_PRIVATE:-$PIPE/../private}/patches.txt # "VA EXPECT NEW note" per line: the builder's own findings (not in the repo) if [[ -f $PATCHES ]]; then while read -r va exp new rest; do [[ $va == \#* || -z $va ]] && continue; $CP $va $exp $new; done < "$PATCHES"; else echo "no $PATCHES: no cache word patches"; fi +echo "== 5b fips-seal $(date -u +%T)" # after every pass that changes libcorecrypto's __text (6 skips it), before the PRE reference +$PY -I $TOOLS/a64e/fips-seal.py reseal $M --ref "$SRC/dyld_shared_cache_arm64e" --log "$OUT/seal.log" | tail -4 +$PY -I $TOOLS/a64e/fips-seal.py check $M --ref "$SRC/dyld_shared_cache_arm64e" | tail -4 cp -c -R "$C" "$PRE" # APFS clone = pre-grow reference for fix-cs / grow-check echo "== 6 rewrite-grow $(date -u +%T)"; nice -n 10 $PY $HERE/aot/rewrite-grow.py cache $M --log "$OUT/rewrite.log" | tee "$OUT/rewrite.out" | tail -3 $PY $HERE/aot/fix-cs.py $M $PRE/dyld_shared_cache_arm64e | tee "$OUT/fixcs.out" | tail -2 @@ -58,4 +66,6 @@ elif [[ ${ALLOW_UNCHECKED_TEXTDATA:-0} == 1 ]]; then else echo "no $TD/undef.txt: no skip map and no check; run textdata-guard.py scan, review, write the list (docs/ios27/TEXT-DATA.md); ALLOW_UNCHECKED_TEXTDATA=1 skips" >&2; exit 1 fi +echo "== 9 a64e census $(date -u +%T)" # no image may keep words a64e-rewrite would change, except the unloaded variants +$PY -I $TOOLS/a64e/a64e-rewrite.py census $M --allow "${CC_SKIP[@]}" | tail -5 echo "CACHE-PIPELINE-DONE $(date -u +%T)"