kit

regen.sh (5393B)

---

 #!/usr/bin/env bash
 # test/asm/regen.sh — regenerate the smoke goldens from the host
 # `as` / `objdump` (via clang as the cross driver). Maintainer aid: NOT
 # run by CI. Commit the refreshed goldens alongside the case changes.
 #
 # Usage:
 #   ./regen.sh                   regenerate every case
 #   ./regen.sh <name>            regenerate just one case (substring match)
 #
 # Requires:
 #   clang  --target=aarch64-linux-gnu or --target=x86_64-linux-gnu
 #   llvm-objdump or a target objdump
 #   xxd                                  (for hex dumps)
 
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 TEST_DIR="$ROOT/test/asm"
 FILTER="${1:-}"
 KIT_TEST_ARCH="${KIT_TEST_ARCH:-aa64}"
 ASM_RUNNER="$ROOT/build/test/asm-runner"
 
 case "$KIT_TEST_ARCH" in
     aa64|aarch64|arm64)
         TEST_ARCH=aa64
         CLANG_TARGET="--target=aarch64-linux-gnu"
         OBJDUMP_MACHINE="aarch64"
         TARGET_OBJDUMP="aarch64-linux-gnu-objdump"
         ;;
     x64|x86_64|amd64)
         TEST_ARCH=x64
         CLANG_TARGET="--target=x86_64-linux-gnu"
         OBJDUMP_MACHINE="i386:x86-64"
         TARGET_OBJDUMP="x86_64-linux-gnu-objdump"
         ;;
     *)
         printf 'regen.sh: unknown KIT_TEST_ARCH=%s (want aa64|x64)\n' "$KIT_TEST_ARCH" >&2
         exit 2
         ;;
 esac
 
 OBJDUMP="$(command -v llvm-objdump 2>/dev/null || command -v "$TARGET_OBJDUMP" 2>/dev/null || true)"
 if [ -z "$OBJDUMP" ]; then
     printf 'regen.sh: no llvm-objdump / %s on PATH\n' "$TARGET_OBJDUMP" >&2
     exit 1
 fi
 
 tmp="$(mktemp -d)"
 trap 'rm -rf "$tmp"' EXIT
 
 case_applies() {
     local dir="$1" name="$2" targets tuple
     targets="$dir/$name.targets"
     [ -f "$targets" ] || return 0
     for tuple in $(cat "$targets"); do
         case "$tuple:$TEST_ARCH" in
             aa64:aa64|aarch64:aa64|arm64:aa64) return 0 ;;
             x64:x64|x86_64:x64|amd64:x64) return 0 ;;
         esac
     done
     return 1
 }
 
 regen_encode() {
     local src="$1" name out_obj out_hex
     name="$(basename "$src" .s)"
     [ -n "$FILTER" ] && [[ "$name" != *"$FILTER"* ]] && return 0
     case_applies "$TEST_DIR/encode" "$name" || return 0
     out_obj="$tmp/$name.o"
     out_hex="$TEST_DIR/encode/$name.expected.hex"
     clang $CLANG_TARGET -c "$src" -o "$out_obj"
     # Dump every executable section (smoke only inspects .text; this is
     # tight enough for now). For multi-section cases we'll pivot to a
     # per-section dump alongside phase 3.
     "$OBJDUMP" -h -j .text "$out_obj" >/dev/null 2>&1
     "$OBJDUMP" --full-contents -j .text "$out_obj" \
         | awk '/^Contents of section/ {next} /^$/ {next}
                { for (i=2; i<=5; i++) if ($i ~ /^[0-9a-f]+$/) printf "%s", $i; printf "\n" }' \
         | tr -d '\n' \
         | { cat; printf '\n'; } >"$out_hex"
     printf '  regen encode/%s\n' "$name"
 }
 
 regen_decode() {
     local hexfile="$1" name out_txt
     name="$(basename "$hexfile" .hex)"
     [ -n "$FILTER" ] && [[ "$name" != *"$FILTER"* ]] && return 0
     case_applies "$TEST_DIR/decode" "$name" || return 0
     out_txt="$TEST_DIR/decode/$name.expected.txt"
     # Mirror asm-runner --decode output exactly: vaddr:\tmnemonic\toperands.
     # objdump's listing format differs (it interleaves addresses + raw hex);
     # rebuild a minimal line per insn via awk so the goldens match the
     # runner's exact-match expectation.
     local raw="$tmp/$name.bin" bytes_s="$tmp/$name.bytes.s" bytes_o="$tmp/$name.bytes.o"
     xxd -r -p "$hexfile" "$raw"
     {
         printf '.text\n'
         od -An -tx1 -v "$raw" \
             | awk '{ for (i=1; i<=NF; i++) printf ".byte 0x%s\n", $i }'
     } >"$bytes_s"
     clang $CLANG_TARGET -c "$bytes_s" -o "$bytes_o"
     "$OBJDUMP" -d --no-show-raw-insn "$bytes_o" \
         | awk '/^[ ]*[0-9a-f]+:/ {
                sub(/:/, "", $1);
                addr = $1;
                # fields: addr  mnemonic  operands...
                mnem = $2;
                ops = "";
                for (i=3; i<=NF; i++) ops = (ops=="" ? $i : ops " " $i);
                if (mnem == "lock") {
                    lock_addr = addr;
                    pending_lock = 1;
                    next;
                }
                if (pending_lock) {
                    addr = lock_addr;
                    mnem = "lock " mnem;
                    pending_lock = 0;
                }
                if (ops == "")
                    printf "%s:\t%s\n", addr, mnem;
                else
                    printf "%s:\t%s\t%s\n", addr, mnem, ops;
            }' >"$out_txt"
     printf '  regen decode/%s\n' "$name"
 }
 
 regen_listing() {
     local bin="$1" name out_lst
     name="$(basename "$bin" .in.bin)"
     [ -n "$FILTER" ] && [[ "$name" != *"$FILTER"* ]] && return 0
     case_applies "$TEST_DIR/listing" "$name" || return 0
     out_lst="$TEST_DIR/listing/$name.expected.lst"
     if [ -x "$ASM_RUNNER" ]; then
         KIT_TEST_ARCH="$TEST_ARCH" "$ASM_RUNNER" --listing "$bin" "$out_lst"
     else
         "$OBJDUMP" -d "$bin" \
             | awk '/^Disassembly of section/ || /^[0-9a-f]+ </ || /^[ ]+[0-9a-f]+:/ || /^$/' \
             >"$out_lst"
     fi
     printf '  regen listing/%s\n' "$name"
 }
 
 printf 'Regenerating goldens...\n'
 for src in "$TEST_DIR"/encode/*.s;      do [ -e "$src" ] && regen_encode  "$src"; done
 for src in "$TEST_DIR"/decode/*.hex;    do [ -e "$src" ] && regen_decode  "$src"; done
 for src in "$TEST_DIR"/listing/*.in.bin; do [ -e "$src" ] && regen_listing "$src"; done
 printf 'Done.\n'