kit

redundant_frame_sub.sh (3224B)

---

 #!/usr/bin/env bash
 # Structural check for the -O1 local frame-address `sub`-CSE (O1.md W1a).
 #
 # An `IR_ADDR_OF` of a frame-local materializes a frame-slot address into a
 # register; under the W1.1 x29-at-bottom layout aarch64 builds it as a positive
 # `add xN, x29, #k` off the frame base. Two back-to-back addr-of's of the *same*
 # local recompute the identical `add xN, x29, #k`. The W1a peephole in
 # src/opt/pass_combine.c (mir_combine) tracks the still-live earlier producer and
 # rewrites the recompute into a register move (`mov xN, xM`), so the second
 # address build vanishes. (Before W1.1 the build was a negative `sub xN,x29,#k`;
 # W1.1 made frame addressing positive, but the W1a CSE still applies to the add.)
 #
 # This pins the resulting disassembly on aarch64 (the reference backend), where
 # the pattern has a stable mnemonic. Each local is addressed twice as adjacent
 # call arguments; with the peephole only ONE `add xN, x29, #k` survives per
 # distinct constant K, and the duplicate becomes a `mov`.
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 KIT="${KIT:-$ROOT/build/kit}"
 WORK="$ROOT/build/test/opt/redundant_frame_sub"
 mkdir -p "$WORK"
 
 SRC="$WORK/case.c"
 cat > "$SRC" <<'EOF'
 extern void sink4(char *, char *, char *, char *);
 /* Two distinct locals at frame offsets past stur's -256 range; each is passed
  * twice as adjacent arguments, so the frontend records two IR_ADDR_OF of the
  * same slot back-to-back. Without W1a each lowers to its own `sub xN,x29,#k`. */
 void g(void) {
   char a[600], b[600];
   sink4(a, a, b, b);
 }
 EOF
 
 OBJ="$WORK/case.o"
 "$KIT" cc -target aarch64-linux-gnu -O1 -std=c11 -c "$SRC" \
   -o "$OBJ" > "$WORK/cc.out" 2>&1
 "$KIT" objdump -d "$OBJ" > "$WORK/dis.out" 2>&1
 
 fn_body() { # $1 = symbol name -> stdout body
   awk -v want="$1" '
     $0 ~ ("^[0-9a-f]+ <" want ">:") { in_fn = 1; next }
     /^[0-9a-f]+ </ { in_fn = 0 }
     in_fn { print }
   ' "$WORK/dis.out"
 }
 
 fail() {
   printf 'redundant_frame_sub FAILED: %s\n' "$1" >&2
   printf '  --- disassembly ---\n' >&2
   sed 's/^/  | /' "$WORK/dis.out" >&2
   exit 1
 }
 
 B="$(fn_body _g)"
 [ -n "$B" ] || B="$(fn_body g)"
 [ -n "$B" ] || fail "g not found in disassembly"
 
 # For each distinct constant K appearing in `add xN, x29, #K`, the address is
 # built exactly once; a back-to-back recompute of the same K must NOT survive.
 # Collect the K constants and assert no duplicates.
 KS="$(printf '%s\n' "$B" | grep -oE 'add[[:space:]]+x[0-9]+, x29, #[0-9]+' \
        | grep -oE '#[0-9]+$' | sort)"
 [ -n "$KS" ] || fail "expected at least one 'add xN, x29, #k' frame-address build"
 
 DUP="$(printf '%s\n' "$KS" | uniq -d || true)"
 if [ -n "$DUP" ]; then
   fail "duplicate frame-address build survived (add xN, x29, #k recomputed for: $DUP)"
 fi
 
 # Sanity: the de-duplicated address must be reused via a register move, so the
 # body should contain at least one `mov xN, xM` (the CSE'd copy) — confirms the
 # peephole rewrote the recompute rather than the case simply not arising.
 if ! printf '%s\n' "$B" | grep -Eq 'mov[[:space:]]+x[0-9]+, x[0-9]+'; then
   fail "expected a 'mov xN, xM' reusing the CSE'd frame address"
 fi
 
 printf 'redundant_frame_sub: OK (no duplicate add xN,x29,#k; address reused via mov)\n'