kit

run.sh (12704B)

---

 #!/bin/sh
 # Driver-level checks for the kit-native build verbs `build-exe` / `build-lib` /
 # `build-obj` (the trio that replaced `compile`). Self-checking (no golden
 # files): we assert exit status, output existence, symbol/text markers, ld -r
 # parity, and — for build-exe — native execution of the produced binary.
 #
 # Coverage:
 #   build-obj : per-language compile (C / toy / wasm), --emit=obj|asm|c|ir,
 #               -fsyntax-only, default output naming, -o - to stdout, the
 #               -X<lang> frontend-flag router, target features, the multi-source
 #               relocatable combine (with ld -r parity), and the negative paths.
 #   build-lib : static .a from mixed sources, then link against it.
 #   build-exe : polyglot relocatable combine, native link+exec, --group scoping
 #               (verified through the produced exit code), and -L/-l.
 
 set -u
 
 script_dir=$(cd "$(dirname "$0")" && pwd)
 repo_root=$(cd "$script_dir/../.." && pwd)
 
 KIT="${KIT:-$repo_root/build/kit}"
 
 if [ ! -x "$KIT" ]; then
     echo "build: kit binary not found at $KIT" >&2
     exit 2
 fi
 
 work=$(mktemp -d "${TMPDIR:-/tmp}/kit-build-test.XXXXXX")
 trap 'rm -rf "$work"' EXIT
 
 KIT_KIT_DIR="$repo_root/test/lib"
 . "$repo_root/test/lib/kit_sh_kit.sh"
 kit_report_init
 
 # ---- fixtures (all local to $work so default-name tests are isolated) -------
 mkdir -p "$work/inc"
 printf '#define ZERO 0\n' > "$work/inc/h.h"
 printf '#include "h.h"\nint helper(void);\nint main(void){return ZERO+helper();}\n' > "$work/hello.c"
 printf 'int helper(void){return 0;}\n' > "$work/helper.c"
 printf '#include <stdint.h>\nint32_t f(void){return 1;}\n' > "$work/std.c"
 cp "$(ls "$repo_root"/test/toy/cases/*.toy | head -1)" "$work/prog.toy"
 cp "$repo_root/test/wasm/cases/if_return.wat" "$work/prog.wat"
 printf 'int wasm_add(int a, int b);\nint wasm_main(void){return wasm_add(1,2)==3?0:1;}\n' > "$work/wasm_main.c"
 printf 'int wasm_add(int a, int b){return a+b;}\n' > "$work/wasm_helper.c"
 printf 'int wexe_add(int a, int b);\nint test_main(void){return wexe_add(2,3)==5?0:1;}\n' > "$work/wexe_main.c"
 printf 'int wexe_add(int a, int b){return a+b;}\nint dead_fn(void){return 99;}\n' > "$work/wexe_add.c"
 
 cd "$work"
 
 # ===========================================================================
 # build-obj — the compile replacement
 # ===========================================================================
 
 # ---- C: preprocessor flags + object output ---------------------------------
 run_ok bo-c-obj "$KIT" build-obj -c -Iinc -DUNUSED=1 hello.c -o hello.o
 assert_file_exists bo-c-obj-exists hello.o
 "$KIT" nm hello.o > nm.out 2>/dev/null
 contains bo-c-obj-has-main nm.out main
 
 # C freestanding system header (<stdint.h>) resolves via the rt include set.
 run_ok bo-c-freestanding-header "$KIT" build-obj -c std.c -o std.o
 
 # Default output name: <basename>.o next to cwd when -o is omitted.
 run_ok bo-c-default-name "$KIT" build-obj -c -Iinc hello.c
 assert_file_exists bo-c-default-name-file hello.o
 
 # ---- toy + wasm: non-C frontends through the generic driver -----------------
 run_ok bo-toy "$KIT" build-obj -c prog.toy -o prog_toy.o
 assert_file_exists bo-toy-exists prog_toy.o
 run_ok bo-wasm "$KIT" build-obj -c prog.wat -o prog_wat.o
 assert_file_exists bo-wasm-exists prog_wat.o
 
 # Target-owned option: the driver lowers feature flags into KitTargetOptions.
 run_ok bo-wasm-target-feature "$KIT" build-obj -target wasm32-none -c \
     -mattr=-tail-calls prog.wat -o prog_wat2.o
 
 # Per-language frontend flag via -X<lang> (routed to the wasm frontend parser).
 run_ok bo-Xwasm "$KIT" build-obj -target wasm32-none -c \
     -Xwasm -mno-feature=tail-calls prog.wat -o prog_wat3.o
 
 # ---- emit modes ------------------------------------------------------------
 run_ok bo-emit-asm "$KIT" build-obj -S -Iinc hello.c -o hello.s
 contains bo-emit-asm-text hello.s .text
 run_ok bo-emit-asm-long "$KIT" build-obj --emit=asm -Iinc hello.c -o hello2.s
 run_ok bo-emit-c "$KIT" build-obj --emit=c prog.toy -o prog.c
 assert_file_exists bo-emit-c-file prog.c
 run_ok bo-emit-ir "$KIT" build-obj --emit=ir -O1 prog.toy -o prog.ir
 assert_file_exists bo-emit-ir-file prog.ir
 
 # -o - sends the emit to stdout (reusing the cc stdout writer).
 "$KIT" build-obj --emit=ir -O1 prog.toy -o - > ir.stdout 2>/dev/null
 if [ -s ir.stdout ]; then ok bo-emit-ir-stdout; else not_ok bo-emit-ir-stdout; fi
 
 # ---- check-only writes no object -------------------------------------------
 rm -f hello.o
 run_ok bo-check-only "$KIT" build-obj -fsyntax-only -Iinc hello.c helper.c
 if [ ! -f hello.o ]; then ok bo-check-no-output; else not_ok bo-check-no-output; fi
 
 # ---- multi-source relocatable combine (ld -r) ------------------------------
 run_ok bo-reloc-combine "$KIT" build-obj -Iinc hello.c helper.c -o combined.o
 assert_file_exists bo-reloc-combine-file combined.o
 "$KIT" nm combined.o > combined.nm 2>/dev/null
 contains bo-reloc-has-helper combined.nm helper
 contains bo-reloc-has-main combined.nm main
 
 # ld -r parity: the in-memory combine matches a separate compile + `ld -r`.
 "$KIT" build-obj -c -Iinc hello.c -o sep_hello.o 2>/dev/null
 "$KIT" build-obj -c helper.c -o sep_helper.o 2>/dev/null
 "$KIT" ld -r sep_hello.o sep_helper.o -o ldr.o 2>/dev/null
 "$KIT" nm combined.o | sort > combine.sorted 2>/dev/null
 "$KIT" nm ldr.o | sort > ldr.sorted 2>/dev/null
 same_file bo-reloc-ld-r-parity ldr.sorted combine.sorted
 
 # Polyglot combine: C + toy in one relocatable object.
 run_ok bo-polyglot-combine "$KIT" build-obj -Iinc helper.c prog.toy -o poly.o
 
 # ---- wasm multi-source combine (CG-merge path) -----------------------------
 # Two C files merged into one .wasm module (magic \0asm + non-empty content).
 run_ok bo-wasm-multi "$KIT" build-obj -target wasm32-none \
     wasm_main.c wasm_helper.c -o multi.wasm
 assert_file_exists bo-wasm-multi-file multi.wasm
 # Wasm magic (\0asm = 00 61 73 6d): check first 4 bytes via od (avoids null-byte
 # issues with cmp on BSD).
 _wasm_hdr=$(od -A n -t x1 -N 4 multi.wasm | tr -d ' \t\n')
 [ "$_wasm_hdr" = "0061736d" ] \
     && ok bo-wasm-multi-magic || not_ok bo-wasm-multi-magic
 # Non-trivial module: size must exceed the 8-byte magic+version stub.
 _wasm_size=$(wc -c < multi.wasm | tr -d ' ')
 [ "$_wasm_size" -gt 8 ] \
     && ok bo-wasm-multi-nontrivial || not_ok bo-wasm-multi-nontrivial
 
 # Polyglot wasm: C + toy in one .wasm module.
 run_ok bo-wasm-polyglot "$KIT" build-obj -target wasm32-none \
     wasm_helper.c prog.toy -o poly.wasm
 assert_file_exists bo-wasm-polyglot-file poly.wasm
 _poly_hdr=$(od -A n -t x1 -N 4 poly.wasm | tr -d ' \t\n')
 [ "$_poly_hdr" = "0061736d" ] \
     && ok bo-wasm-polyglot-magic || not_ok bo-wasm-polyglot-magic
 
 # Negative: duplicate strong symbol definition must be rejected (at -O1 the
 # optimizer runs opt_resolve_duplicate_funcs which fires the ODR check).
 printf 'int wasm_add(int a, int b){return a-b;}\n' > wasm_dup.c
 run_fail bo-wasm-dup "$KIT" build-obj -O1 -target wasm32-none \
     wasm_helper.c wasm_dup.c -o dup.wasm
 contains bo-wasm-dup-diag "$work/bo-wasm-dup.err" "duplicate definition"
 
 # ---- negative paths --------------------------------------------------------
 # A frontend with an unknown -X flag is rejected by that frontend's parser.
 run_fail bo-neg-bad-Xflag "$KIT" build-obj -c -Xtoy --bogus prog.toy -o x.o
 # The target parser rejects an unknown feature name.
 run_fail bo-neg-bad-feature "$KIT" build-obj -target wasm32-none \
     -mattr=+nope -c prog.wat -o x.o
 # build-obj never links: object/archive inputs are refused.
 run_fail bo-neg-link-input "$KIT" build-obj hello.o
 # --emit=c needs an explicit destination.
 run_fail bo-neg-emit-c-needs-o "$KIT" build-obj --emit=c prog.toy
 # IR is only available with the optimizer on.
 run_fail bo-neg-ir-needs-opt "$KIT" build-obj --emit=ir prog.toy -o x.ir
 # -o cannot fan out across multiple sources in a per-source emit.
 run_fail bo-neg-o-multi-asm "$KIT" build-obj -S -Iinc hello.c std.c -o both.s
 # A per-output flag is not allowed inside a --group.
 run_fail bo-neg-global-in-group "$KIT" build-obj -Iinc --group -O2 -- hello.c
 # A missing -x argument before a --group source separator should not treat `--`
 # as a language name.
 run_fail bo-neg-group-x-missing-arg "$KIT" build-obj --group -x -- hello.c
 contains bo-neg-group-x-missing-arg-diag "$work/bo-neg-group-x-missing-arg.err" \
     "requires an argument"
 # -dynamic is a build-lib concept.
 run_fail bo-neg-dynamic "$KIT" build-obj -dynamic prog.toy
 # unknown flag.
 run_fail bo-neg-unknown-flag "$KIT" build-obj --nope -c prog.toy -o x.o
 
 # ===========================================================================
 # build-lib — static archive
 # ===========================================================================
 
 run_ok bl-static "$KIT" build-lib -Iinc -o libmix.a helper.c std.c prog.toy
 assert_file_exists bl-static-file libmix.a
 "$KIT" nm libmix.a > libmix.nm 2>/dev/null
 contains bl-static-has-helper libmix.nm helper
 # -o is required (no obvious base name across N sources).
 run_fail bl-neg-needs-o "$KIT" build-lib helper.c std.c
 # build-lib takes only sources.
 run_fail bl-neg-link-input "$KIT" build-lib -o x.a helper.o
 # Dynamic/shared libraries are not yet supported.
 run_fail bl-neg-dynamic "$KIT" build-lib -dynamic -o x.a helper.c
 
 # ===========================================================================
 # build-exe — native link + exec (the headline path)
 # ===========================================================================
 
 # A hosted executable (-lc) that returns 0; build, then run it.
 run_ok be-link "$KIT" build-exe -lc -Iinc hello.c helper.c -o app
 is_executable be-link-exec app
 run_ok be-run ./app
 
 # build-exe should reject the shared-library spelling instead of ignoring it.
 run_fail be-neg-shared "$KIT" build-exe -shared -lc -Iinc hello.c helper.c \
     -o shared-nope
 contains be-neg-shared-diag "$work/be-neg-shared.err" "shared"
 
 # Default output name a.out when -o is omitted.
 run_ok be-default-name "$KIT" build-exe -lc -Iinc hello.c helper.c
 assert_file_exists be-default-name-file a.out
 
 # -no-pie must cancel an earlier -pie for build-exe's link state.
 printf 'void _start(void) { for (;;) {} }\n' > no_pie_start.c
 run_ok be-no-pie "$KIT" build-exe -target x86_64-linux -nostdlib \
     -pie -no-pie no_pie_start.c -o no-pie-exe
 e_type=$(od -An -tx1 -j 16 -N 2 no-pie-exe | tr -d ' \n')
 if [ "$e_type" = "0200" ]; then ok be-no-pie-et-exec; else
     printf 'e_type bytes=%s want=0200\n' "$e_type" \
         > "$work/be-no-pie-et-exec.diag"
     not_ok be-no-pie-et-exec "$work/be-no-pie-et-exec.diag"
 fi
 
 # --group scoping is observable through the program's exit code: the bare TU
 # sees -DRET=0 (global), the grouped TU overrides it to a non-zero value.
 printf '#ifndef RET\n#define RET 7\n#endif\nint ret_val(void){return RET;}\n' > rv.c
 printf 'int ret_val(void);\nint main(void){return ret_val();}\n' > rmain.c
 run_ok be-group-link "$KIT" build-exe -lc -DRET=0 rmain.c \
     --group -DRET=3 -- rv.c -o appg
 if ./appg; then code=0; else code=$?; fi
 if [ "$code" -eq 3 ]; then ok be-group-scope; else
     echo "expected exit 3 from grouped -DRET, got $code" > "$work/be-group-scope.diag"
     not_ok be-group-scope "$work/be-group-scope.diag"
 fi
 
 # Link against the static library built above via -L/-l, then run.
 printf 'int helper(void);\nint main(void){return helper();}\n' > usemix.c
 run_ok be-link-archive "$KIT" build-exe -lc usemix.c -L. -lmix -o app2
 run_ok be-run-archive ./app2
 
 # ===========================================================================
 # build-exe — wasm target
 # ===========================================================================
 
 # Multi-source: produces a .wasm with DCE/internalization, runnable via kit run.
 run_ok be-wasm-exe "$KIT" build-exe -target wasm32-none \
     wexe_main.c wexe_add.c -e test_main -o wexe.wasm
 assert_file_exists be-wasm-exe-file wexe.wasm
 _wexe_hdr=$(od -A n -t x1 -N 4 wexe.wasm | tr -d ' \t\n')
 [ "$_wexe_hdr" = "0061736d" ] && ok be-wasm-exe-magic || not_ok be-wasm-exe-magic
 run_ok be-wasm-exe-run "$KIT" run -e test_main wexe.wasm
 
 # Default output name a.wasm when -o is omitted.
 run_ok be-wasm-exe-default-name "$KIT" build-exe -target wasm32-none \
     wexe_main.c wexe_add.c -e test_main
 assert_file_exists be-wasm-exe-default-name-file a.wasm
 
 # kit run without -e reads the kit-entry custom section from the module.
 run_ok be-wasm-exe-autoentry "$KIT" run wexe.wasm
 
 # Unknown entry symbol is rejected with a clear diagnostic.
 run_fail be-wasm-exe-bad-entry "$KIT" build-exe -target wasm32-none \
     wexe_main.c wexe_add.c -e no_such_fn -o bad_entry.wasm
 contains be-wasm-exe-bad-entry-diag "$work/be-wasm-exe-bad-entry.err" \
     "entry symbol"
 
 kit_summary build-driver
 kit_exit