kit

o1_inline_cap.sh (5686B)

---

 #!/usr/bin/env bash
 # Inline-pressure cap (O1.md W4).
 #
 # At -O1 there is no SSA post-inline cleanup, so the whole-program inliner
 # (opt_inline) backs off when the estimated post-inline live-set
 # (caller pregs + callee pregs) would sit past INLINE_PRESSURE_CAP (512). The cap
 # is set far above any target's register file, so it only fires on callers that
 # are already spilling heavily; a small, low-pressure caller still inlines the
 # exact same callee. This is one target-independent decision, so the structural
 # checks run identically for aarch64, x86_64, and riscv64.
 #
 # Green:
 #   1. A non-tiny callee (cost above the streaming tiny cap, so only the
 #      whole-program inliner handles it) fuses into a SMALL caller — no call
 #      left, proving the cap does not over-fire on ordinary code.
 #   2. The SAME callee called from a HUGE / high-pressure caller is NOT fused —
 #      the call survives, proving the cap backs off past its threshold.
 #   3. An always_inline callee fuses even into the huge caller (ALWAYS bypasses
 #      the cap, matching the cost/growth gates).
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 KIT="${KIT:-$ROOT/build/kit}"
 WORK="$ROOT/build/test/opt/o1_inline_cap"
 mkdir -p "$WORK"
 
 call_mnemonics='\b(bl|blr|callq?|jalr?)\b'
 
 # Count calls inside one function body. The disassembly has no blank separators,
 # so walk from the function's `<name>:` header to the next symbol header.
 calls_in() { # $1=disfile $2=funcname
   awk -v f="<$2>:" '$0 ~ f {g = 1; next} /<[A-Za-z_].*>:/ {g = 0} g' "$1" \
     | grep -cE "$call_mnemonics" || true
 }
 
 # A callee whose cost sits above the streaming tiny-inline cap (8) but below the
 # DEFAULT whole-program cap (20): only the whole-program inliner can fuse it, so
 # this isolates the W4 cap on opt_inline.
 HELPER='static int helper(int x){ int a=x*3; int b=a+7; int c=b^a;'\
 ' int d=c*x; int e=d-b; return a+b+c+d+e+x; }'
 # always_inline twin: must fuse regardless of pressure.
 AHELPER='__attribute__((always_inline)) static int ahelper(int x){'\
 ' int a=x*3; int b=a+7; int c=b^a; int d=c*x; int e=d-b;'\
 ' return a+b+c+d+e+x; }'
 
 # Emit a caller that holds ~N*2 temporaries live across the helper call, pushing
 # the inline-time pregs estimate well past the 512 cap. N=300 -> ~600 pregs.
 emit_huge_caller() { # $1=name $2=callee $3=N
   printf 'int %s(int *p){\n  int s = %s(p[0])' "$1" "$2"
   local i
   for ((i = 0; i < $3; i++)); do printf ' + (p[%d]*%d ^ p[%d])' "$i" "$((i + 1))" "$((i + 2))"; done
   printf ';\n  return s;\n}\n'
 }
 
 build_src() { # writes the test TU to $1
   {
     printf '%s\n' "$HELPER"
     printf '%s\n' "$AHELPER"
     # Small, low-pressure caller of the plain helper: must fuse.
     printf 'int small(int *p){ return helper(p[0]) + p[1]; }\n'
     # Huge, high-pressure caller of the plain helper: must NOT fuse.
     emit_huge_caller huge helper 300
     # Huge caller of the always_inline helper: must fuse despite pressure.
     emit_huge_caller huge_always ahelper 300
   } > "$1"
 }
 
 check_arch() {
   local triple=$1 tag=$2
   local src="$WORK/$tag.c" obj="$WORK/$tag.o" dis="$WORK/$tag.dis"
   build_src "$src"
   "$KIT" cc -target "$triple" -O1 -ffreestanding -std=c11 -c "$src" -o "$obj" \
     > "$WORK/$tag.cc.out" 2>&1
   "$KIT" objdump -d "$obj" > "$dis" 2>&1
 
   local cs ch ca
   cs=$(calls_in "$dis" small)
   ch=$(calls_in "$dis" huge)
   ca=$(calls_in "$dis" huge_always)
 
   if [ "$cs" -ne 0 ]; then
     printf 'o1-inline-cap FAILED: %s small caller did NOT inline helper (%s call[s]) — cap over-fired\n' \
       "$tag" "$cs" >&2
     awk '/<small>:/{g=1;next} /<[A-Za-z_].*>:/{g=0} g' "$dis" | sed 's/^/  | /' >&2
     exit 1
   fi
   if [ "$ch" -eq 0 ]; then
     printf 'o1-inline-cap FAILED: %s huge/high-pressure caller inlined helper anyway — pressure cap did not back off\n' \
       "$tag" >&2
     exit 1
   fi
   if [ "$ca" -ne 0 ]; then
     printf 'o1-inline-cap FAILED: %s always_inline callee NOT fused into huge caller — cap ignored ALWAYS policy\n' \
       "$tag" >&2
     exit 1
   fi
   printf 'o1-inline-cap %-8s small fused, huge backed off, always_inline fused\n' "$tag"
 }
 
 check_arch aarch64-linux-gnu aa64
 check_arch x86_64-linux-gnu  x64
 check_arch riscv64-linux-gnu rv64
 
 # Metric corroboration: the whole-program inliner must report a growth/pressure
 # refusal at -O1 for the huge caller (the cap is folded into refuse_growth), and
 # must still inline the small caller — i.e. the cap fires selectively, not
 # blanket. Run via `kit run` so KIT_METRICS surfaces the finalize-sweep counters.
 read -r -d '' RUN_SRC <<'EOF' || true
 __attribute__((noinline)) static int sink(int x){ return x; }
 EOF
 build_src "$WORK/metric.c"
 printf 'int main(void){ int p[512]; for(int i=0;i<512;i++) p[i]=i;'\
 ' return (small(p) | huge(p) | huge_always(p)) ? 0 : 0; }\n' >> "$WORK/metric.c"
 if ! KIT_METRICS=1 "$KIT" run -O1 "$WORK/metric.c" >"$WORK/metric.out" 2>"$WORK/metric.err"; then
   printf 'o1-inline-cap FAILED: `kit run -O1` on the metric TU did not exit 0\n' >&2
   sed 's/^/  | /' "$WORK/metric.err" >&2
   exit 1
 fi
 # Some inlining happened (the small caller), and some was refused (the huge one,
 # via the growth/pressure bucket).
 if ! grep -q 'opt.inline.inlined' "$WORK/metric.err"; then
   printf 'o1-inline-cap FAILED: opt.inline.inlined metric absent at -O1\n' >&2
   sed -n '1,80p' "$WORK/metric.err" >&2
   exit 1
 fi
 if ! grep -q 'opt.inline.refuse_growth' "$WORK/metric.err"; then
   printf 'o1-inline-cap FAILED: no growth/pressure refusal recorded (cap never fired)\n' >&2
   sed -n '1,80p' "$WORK/metric.err" >&2
   exit 1
 fi
 printf 'o1-inline-cap run      inlined some, refused the over-pressure caller, exit 0\n'
 
 printf 'o1-inline-cap: ok\n'