@amritk/nish-x86_64-linux 0.17.0 → 0.20.0

package/scripts/build.sh

@@ -3,12 +3,15 @@
 #
 #   scripts/build.sh <module.ll> [more .ll/.c files...] -o <out> [--profile debug|speed|size|wasm|wasi|napi]
 #
-# The C runtime is five translation units and is named as one: an input
+# The C runtime is eight translation units and is named as one: an input
 # <dir>/runtime.c also compiles <dir>/runtime-os.c, the half that wraps the
 # system calls (files, directories, subprocesses, the environment, the clock),
 # <dir>/runtime-parallel.c, the half that divides a range of work across
-# threads, <dir>/runtime-host.c, the wall clock, entropy, file times and
-# signals, and <dir>/runtime-net.c, the sockets of `nish:net`. Each of those
+# threads, <dir>/runtime-cross.c, the copies that carry a string or an array
+# from one thread's arena to another's, <dir>/runtime-host.c, the wall clock, entropy, file times and
+# signals, <dir>/runtime-net.c, the sockets of `nish:net`,
+# <dir>/runtime-simd.c, the byte searches that read a vector at a time, and
+# <dir>/runtime-aes.c, AES-GCM on the CPU's AES instructions. Each of those
 # files says why they are compiled and measured apart.
 #
 # Profiles:
@@ -56,6 +59,29 @@
 # put in the .ll (line table, variables) reaches the binary. `nish
 # --link -g` passes it through automatically.
 #
+# CPU level (WP38 S2): `--cpu x86-64-v3` compiles and links every input --
+# the module, the runtime and any other C -- with -march=x86-64-v3
+# -ffp-contract=off, so the code generator may use AVX2, BMI2 and the other
+# v3 instructions and still forms no fused multiply-add the IR did not write.
+# It is the one level taken; any other value is refused with exit 2, and so are
+# the wasm and wasi profiles, which are not x86-64. A binary built with it
+# stops with SIGILL on a CPU without AVX2. `nish --link --cpu x86-64-v3`
+# passes it through.
+#
+# The runtime compiled once (the debug, speed and size profiles only; `nish
+# --link` and `nish run` use these through their runtime cache, src/compile.ts):
+#   --runtime-objects <dir>  compile the runtime.c input and its seven siblings,
+#                            one $CC -c each and all at once, into
+#                            <dir>/<unit>.o with the profile's compile flags,
+#                            and link nothing. speed and size store LTO bitcode,
+#                            so the link can still inline the runtime into the
+#                            program. No -o; prints nothing on success.
+#   --runtime-from <dir>     link against <dir>/<unit>.o in place of a
+#                            runtime.c input, after compiling every other input
+#                            with its own $CC -c, all at once. The link line is
+#                            the one the profile always uses.
+# Both refuse the wasm, wasi and napi profiles and --pgo-*, with exit 2.
+#
 # Works on Linux (clang + lld preferred, GNU ld tolerated) and macOS (Apple ld64
 # or Homebrew llvm). Set CC to pick a compiler (default: clang on PATH).
 set -euo pipefail
@@ -66,38 +92,88 @@ inputs=()
 pgo=()                                 # -fprofile-generate / -fprofile-use=<file>
 debug=0                                # -g: keep DWARF (nish -g emits it in the IR; runtime.c gets it here)
 threads=0                              # --threads: -DNISH_THREADS, the thread-local arena (WP20 T0)
+objects_to=""                          # --runtime-objects <dir>: compile the runtime alone, into <dir>
+objects_from=""                        # --runtime-from <dir>: link against the runtime compiled there
+cpu=""                                 # --cpu x86-64-v3: the one CPU level above the baseline (WP38 S2)
 while [ $# -gt 0 ]; do
   case "$1" in
     -o) out="$2"; shift 2 ;;
     --profile) profile="$2"; shift 2 ;;
     -g) debug=1; shift ;;
     --threads) threads=1; shift ;;
+    --cpu)
+      [ -n "${2-}" ] || { echo "error: --cpu needs a level; the one taken is x86-64-v3" >&2; exit 2; }
+      cpu="$2"; shift 2 ;;
+    --runtime-objects) objects_to="$2"; shift 2 ;;
+    --runtime-from) objects_from="$2"; shift 2 ;;
     --pgo-generate) pgo=(-fprofile-generate); shift ;;
     --pgo-use)
       [ -f "$2" ] || { echo "error: --pgo-use: profile '$2' not found (run the instrumented binary, then llvm-profdata merge)" >&2; exit 2; }
       pgo=("-fprofile-use=$2"); shift 2 ;;
-    -h|--help) sed -n '2,41p' "$0"; exit 0 ;;
+    -h|--help) sed -n '2,85p' "$0"; exit 0 ;;
     *) inputs+=("$1"); shift ;;
   esac
 done
 [ ${#inputs[@]} -gt 0 ] || { echo "error: no input files" >&2; exit 2; }
-[ -n "$out" ] || { echo "error: -o <out> is required" >&2; exit 2; }
+if [ -n "$cpu" ]; then
+  [ "$cpu" = x86-64-v3 ] || { echo "error: --cpu takes x86-64-v3, not '$cpu'" >&2; exit 2; }
+  case "$profile" in
+    wasm|wasi) echo "error: --cpu x86-64-v3 is an x86-64 level, so the $profile profile does not take it" >&2; exit 2 ;;
+  esac
+fi
+# wasm-ld exports a wasm module's linear memory as `memory`, so under the wasm
+# profile's `--export-all` a function of that name makes a module Node refuses
+# to compile ("Duplicate export name 'memory'", #643). The wasi module exports
+# only `memory` and `_start`, but the name is reserved there too, so a program
+# that links for wasi also links for wasm. The compiler refuses one (NL3038)
+# when it knows the build is wasm, but IR compiled for the host with `-o` alone
+# reaches these profiles without telling it, so the IR is read here too.
+case "$profile" in
+  wasm|wasi)
+    for i in ${inputs[@]+"${inputs[@]}"}; do
+      case "$i" in
+        *.ll)
+          # An `internal` or `private` definition is not exported, so it is left alone.
+          if grep -E '^define [^@]*@memory\(' "$i" | grep -Evq '^define (internal|private) '; then
+            echo "error: $i defines a function named \`memory\`, the name the $profile profile's module exports its linear memory under; rename the function" >&2
+            exit 2
+          fi ;;
+      esac
+    done ;;
+esac
+if [ -n "$objects_to" ] || [ -n "$objects_from" ]; then
+  # A cached runtime is the profile's ordinary compile, so it exists only for
+  # the profiles that compile the runtime with nothing but these flags.
+  case "$profile" in
+    debug|speed|size) ;;
+    *) echo "error: --runtime-objects and --runtime-from take the debug, speed and size profiles, not '$profile'" >&2; exit 2 ;;
+  esac
+  [ ${#pgo[@]} -eq 0 ] || { echo "error: --runtime-objects and --runtime-from do not take --pgo-*" >&2; exit 2; }
+  [ -z "$objects_to" ] || [ -z "$objects_from" ] || { echo "error: --runtime-objects and --runtime-from are two different builds" >&2; exit 2; }
+fi
+[ -n "$out" ] || [ -n "$objects_to" ] || { echo "error: -o <out> is required" >&2; exit 2; }
 
-# The runtime is five translation units, and a caller names one: whoever passes
+# The runtime is eight translation units, and a caller names one: whoever passes
 # <dir>/runtime.c gets <dir>/runtime-os.c, <dir>/runtime-parallel.c,
-# <dir>/runtime-host.c and <dir>/runtime-net.c compiled beside it. They were one file until the operating-system half was split out
-# for its own size budget, and the parallel half followed for the same reason
-# (each file's header comment says why), and a link line is where those splits
+# <dir>/runtime-cross.c, <dir>/runtime-host.c, <dir>/runtime-net.c, <dir>/runtime-simd.c and
+# <dir>/runtime-aes.c compiled beside it, on every profile, wasi included:
+# runtime-simd.c takes its scalar path there unless the build adds -msimd128,
+# and runtime-aes.c compiles to an answer of 0 and stubs that nothing calls,
+# because the compiler emits no call to its kernels for wasm32. They were one file until the
+# operating-system half was split out for its own size budget, and the parallel
+# half followed for the same reason (each file's header comment says why), and
+# a link line is where those splits
 # would otherwise leak: `nish --link` builds its command line in
 # src/compile.ts, the published package's recipe in every document and
 # README names runtime.c, and a user's own clang line does too. Pairing them
 # here keeps every one of those correct, and keeps "the runtime" one thing to
 # name from the outside. A caller that names one itself is left alone, because
 # naming one object twice is a duplicate-symbol error.
+halves="runtime-os.c runtime-parallel.c runtime-cross.c runtime-host.c runtime-net.c runtime-simd.c runtime-aes.c"
 for i in ${inputs[@]+"${inputs[@]}"}; do
   case "$i" in
     */runtime.c|runtime.c)
-      for half in runtime-os.c runtime-parallel.c runtime-host.c runtime-net.c; do
+      for half in $halves; do
         side="${i%runtime.c}$half"
         have=0
         for j in "${inputs[@]}"; do
@@ -173,12 +249,130 @@ if [ "$debug" = 1 ]; then common+=(-g); strip_flag=(); fi
 # command lines, which have no threads to link against, and where
 # runtime-parallel.c compiles to its sequential fallback because it tests
 # __wasi__ and __wasm__ as well as the macro.
+# --cpu: every unit at the one level, so the module, the runtime and the link
+# (LTO generates code there) agree. -ffp-contract=off keeps the meaning fixed:
+# v3 has FMA, and contracting a*b+c into one rounding would print a different
+# float than the baseline build (docs/LANGUAGE.md, "The CPU level").
+if [ -n "$cpu" ]; then common+=(-march=x86-64-v3 -ffp-contract=off); fi
+
 tls=()
 if [ "$threads" = 1 ]; then
   common+=(-DNISH_THREADS=1 -ftls-model=initial-exec -pthread)
   tls=(-DNISH_THREADS=1 -ftls-model=initial-exec)
 fi
 
+# What the speed and size profiles compile every input with, beside `common`.
+# One list per profile, because the runtime cache below compiles with exactly
+# what the one-command link does, and two copies of a flag set drift.
+optimise=()
+case "$profile" in
+  speed)
+    optimise=(-O3 -flto -DNDEBUG ${pgo[@]+"${pgo[@]}"}
+      -ffunction-sections -fdata-sections -fomit-frame-pointer
+      -fno-asynchronous-unwind-tables -fno-unwind-tables ${elf[@]+"${elf[@]}"}) ;;
+  size)
+    optimise=(-Oz -flto -DNDEBUG ${pgo[@]+"${pgo[@]}"}
+      -ffunction-sections -fdata-sections -fomit-frame-pointer
+      -fno-asynchronous-unwind-tables -fno-unwind-tables ${elf[@]+"${elf[@]}"}
+      -fno-stack-protector -fvisibility=hidden) ;;
+esac
+
+# --runtime-objects and --runtime-from: the one-command link split in two, with
+# every compile it held run at once. A `$CC -c` takes `common` and `optimise`,
+# which is what the one command compiles each input with -- less
+# -fuse-ld=lld, which only names the linker -- so a runtime unit compiles to the
+# same object either way: native code for debug, -flto bitcode for speed and
+# size, which the link still optimises together with the program. The link
+# takes the same line the profile always uses, with objects for sources.
+if [ -n "$objects_to" ] || [ -n "$objects_from" ]; then
+  compile=()
+  for flag in "${common[@]}"; do
+    case "$flag" in -fuse-ld=*) ;; *) compile+=("$flag") ;; esac
+  done
+  compile+=(${optimise[@]+"${optimise[@]}"})
+  # Waits for every job, not just the last, and fails when any of them did.
+  # bash 3.2 has no `wait -n`, so the jobs are waited for in order.
+  pids=()
+  join_jobs() {
+    local failed=0 pid
+    for pid in ${pids[@]+"${pids[@]}"}; do
+      wait "$pid" || failed=1
+    done
+    pids=()
+    return "$failed"
+  }
+  # The compiles are this script's children, so a signal that stops it stops
+  # them too, before anything they write into is removed. A finished script
+  # has waited for every one of them, so there is nothing left to stop.
+  stop_jobs() {
+    if [ ${#pids[@]} -gt 0 ]; then
+      kill "${pids[@]}" 2>/dev/null || true
+      wait "${pids[@]}" 2>/dev/null || true
+      pids=()
+    fi
+  }
+  work=""
+  trap 'stop_jobs; [ -z "$work" ] || rm -rf -- "$work"' EXIT
+  trap 'exit 130' INT
+  trap 'exit 143' TERM
+fi
+
+if [ -n "$objects_to" ]; then
+  runtime=""
+  for i in "${inputs[@]}"; do
+    case "$i" in
+      */runtime.c|runtime.c) runtime="$i" ;;
+      */runtime-*.c|runtime-*.c) ;;     # its siblings, added above
+      *) echo "error: --runtime-objects compiles the runtime alone, not $i" >&2; exit 2 ;;
+    esac
+  done
+  [ -n "$runtime" ] || { echo "error: --runtime-objects needs runtime/runtime.c" >&2; exit 2; }
+  mkdir -p -- "$objects_to"
+  objects_to=$(cd -- "$objects_to" && pwd)
+  # Each unit is compiled from inside its own directory, by its bare name, so
+  # an object holds no trace of where the compile was started: -g's DWARF names
+  # the file `runtime.c` in the runtime's own directory, whichever directory
+  # the first link that compiled it was run in.
+  runtime_dir=$(dirname -- "$runtime")
+  # A CC named by a relative path is named from here, not from there.
+  case "$CC" in /*) ;; */*) CC="$(pwd)/$CC" ;; esac
+  for unit in runtime.c $halves; do
+    (cd -- "$runtime_dir" && exec "$CC" "${compile[@]}" -c "$unit" -o "$objects_to/${unit%.c}.o") &
+    pids+=("$!")
+  done
+  join_jobs || { echo "error: the runtime did not compile" >&2; exit 1; }
+  exit 0
+fi
+
+if [ -n "$objects_from" ]; then
+  for unit in runtime.c $halves; do
+    [ -f "$objects_from/${unit%.c}.o" ] || { echo "error: --runtime-from: $objects_from/${unit%.c}.o is missing" >&2; exit 2; }
+  done
+  # The program's own objects are this link's alone, so they go in a private
+  # directory of its own and go with it.
+  work=$(mktemp -d "${TMPDIR:-/tmp}/nish-link.XXXXXX")
+  objects=()
+  n=0
+  for i in "${inputs[@]}"; do
+    case "$i" in */runtime.c|runtime.c) echo "error: --runtime-from links the runtime in $objects_from, so $i is not an input" >&2; exit 2 ;; esac
+    n=$((n + 1))
+    "$CC" "${compile[@]}" -c "$i" -o "$work/$n.o" &
+    pids+=("$!")
+    objects+=("$work/$n.o")
+  done
+  join_jobs || { echo "error: a module did not compile" >&2; exit 1; }
+  # In the order the one-command link names them: the inputs, then runtime.c
+  # and its siblings.
+  for unit in runtime.c $halves; do
+    objects+=("$objects_from/${unit%.c}.o")
+  done
+  inputs=("${objects[@]}")
+  # clang runs dsymutil itself when one command compiles and links with -g on
+  # macOS; a link of objects does not, so it is run here, while the program's
+  # objects the debug map points at are still there.
+  if [ "$debug" = 1 ] && [ "$(uname -s)" = Darwin ]; then dsym=1; else dsym=0; fi
+fi
+
 # The ${arr[@]+"${arr[@]}"} spelling below is not a style tic: macOS ships bash
 # 3.2 (Apple will not ship GPLv3), where expanding an empty array as "${arr[@]}"
 # under `set -u` is a fatal "unbound variable" -- bash 4.4 made it legal, which is
@@ -187,16 +381,8 @@ fi
 case "$profile" in
   debug)
     "$CC" "${common[@]}" "${inputs[@]}" -lm -o "$out" ;;
-  speed)
-    "$CC" "${common[@]}" -O3 -flto -DNDEBUG ${pgo[@]+"${pgo[@]}"} \
-      -ffunction-sections -fdata-sections -fomit-frame-pointer \
-      -fno-asynchronous-unwind-tables -fno-unwind-tables ${elf[@]+"${elf[@]}"} \
-      "${gc[@]}" ${strip_flag[@]+"${strip_flag[@]}"} "${inputs[@]}" -lm -o "$out" ;;
-  size)
-    "$CC" "${common[@]}" -Oz -flto -DNDEBUG ${pgo[@]+"${pgo[@]}"} \
-      -ffunction-sections -fdata-sections -fomit-frame-pointer \
-      -fno-asynchronous-unwind-tables -fno-unwind-tables ${elf[@]+"${elf[@]}"} \
-      -fno-stack-protector -fvisibility=hidden \
+  speed|size)
+    "$CC" "${common[@]}" "${optimise[@]}" \
       "${gc[@]}" ${strip_flag[@]+"${strip_flag[@]}"} "${inputs[@]}" -lm -o "$out" ;;
   wasm)
     # clang resolves wasm-ld next to its own binary first, then on PATH; ask it
@@ -206,6 +392,23 @@ case "$profile" in
       echo "error: the wasm profile needs wasm-ld (install lld; on macOS: brew install llvm@18)" >&2
       exit 2
     fi
+    # IR compiled for the host rather than with `--target wasm32` calls std/crypto/aes.ts's
+    # AES kernels behind `nish_aes_hw` (src/kernels.ts). runtime-aes.c's wasm32 build
+    # answers 0 there, so the bitsliced code runs, and it is added only for such IR:
+    # every other module links the bytes it always did.
+    # A caller that names runtime-aes.c itself is left alone, as `halves` leaves it:
+    # one object named twice is a duplicate-symbol error.
+    aes_named=0
+    aes_wanted=0
+    for i in ${inputs[@]+"${inputs[@]}"}; do
+      case "$i" in
+        */runtime-aes.c|runtime-aes.c) aes_named=1 ;;
+        *.ll) if grep -q '@nish_aes_hw(' "$i"; then aes_wanted=1; fi ;;
+      esac
+    done
+    if [ "$aes_wanted" = 1 ] && [ "$aes_named" = 0 ]; then
+      inputs+=("$(cd "$(dirname "$0")/../runtime" && pwd)/runtime-aes.c")
+    fi
     # -mbulk-memory lowers llvm.memset/memcpy (`new Array<T>(n)`, `push` growth) to the
     # memory.fill/memory.copy instructions instead of libc calls the freestanding link lacks.
     "$CC" -Wno-override-module --target=wasm32-unknown-unknown -Oz -nostdlib -mbulk-memory \
@@ -280,5 +483,7 @@ case "$profile" in
   *) echo "error: unknown profile '$profile'" >&2; exit 2 ;;
 esac
 
+if [ "${dsym:-0}" = 1 ]; then "$("$CC" -print-prog-name=dsymutil)" "$out"; fi
+
 # `wc -c` pads with spaces on macOS; strip them so the number is clean.
 printf '%s: %s bytes (%s)\n' "$out" "$(wc -c < "$out" | tr -d ' ')" "$profile"