v2: fix self host with paralell + regalloc; symlink without sudo

Author: medvednikov

cmd/tools/vsymlink/vsymlink_nix.c.v

@@ -11,7 +11,33 @@ fn setup_symlink() {
 	}
 	os.rm(link_path) or {}
 	os.symlink(vexe, link_path) or {
-		eprintln('Failed to create symlink "${link_path}". Try again with sudo.')
-		exit(1)
+		// Try ~/.local/bin as a fallback when /usr/local/bin is not writable.
+		home := os.home_dir()
+		if home == '' {
+			eprintln('Failed to create symlink "${link_path}": ${err}')
+			eprintln('Try again with sudo.')
+			exit(1)
+		}
+		local_bin := os.join_path(home, '.local', 'bin')
+		if !os.exists(local_bin) {
+			os.mkdir_all(local_bin) or {
+				eprintln('Failed to create symlink "${link_path}": ${err}')
+				eprintln('Try again with sudo.')
+				exit(1)
+			}
+		}
+		link_path = os.join_path(local_bin, 'v')
+		os.rm(link_path) or {}
+		os.symlink(vexe, link_path) or {
+			eprintln('Failed to create symlink "${link_path}": ${err}')
+			eprintln('Try again with sudo.')
+			exit(1)
+		}
+		eprintln('Note: Symlink created in "${local_bin}" instead of "/usr/local/bin".')
+		if path := os.getenv_opt('PATH') {
+			if !path.contains(local_bin) {
+				eprintln('Make sure "${local_bin}" is in your PATH.')
+			}
+		}
 	}
 }

cmd/v2/test_all.sh

@@ -3,83 +3,73 @@ set -euo pipefail
 
 cd "$(dirname "$0")"
 
-# Files that V1 may clobber during rebuild — backup and restore around v builds.
-# Use unique suffixes to avoid name collisions (e.g. two types.v files).
+# V1's formatter may clobber v2 source files during rebuild.
+# Back up the entire v2 tree and restore after each V1 build.
+V2_SRC="../../vlib/v2"
+V2_BAK="/tmp/v2_src_bak_test_all"
+
 backup_v2_src() {
-  cp ../../vlib/v2/gen/cleanc/consts_and_globals.v /tmp/bak_ta_cleanc_consts.v
-  cp ../../vlib/v2/gen/cleanc/assign.v             /tmp/bak_ta_cleanc_assign.v
-  cp ../../vlib/v2/ssa/module.v                    /tmp/bak_ta_ssa_module.v
-  cp ../../vlib/v2/ssa/optimize/mem2reg.v          /tmp/bak_ta_ssa_mem2reg.v
-  cp ../../vlib/v2/transformer/struct.v            /tmp/bak_ta_tr_struct.v
-  cp ../../vlib/v2/transformer/transformer.v       /tmp/bak_ta_tr_transformer.v
-  cp ../../vlib/v2/transformer/types.v             /tmp/bak_ta_tr_types.v
+  rm -rf "$V2_BAK"
+  cp -R "$V2_SRC" "$V2_BAK"
 }
 
 restore_v2_src() {
-  cp /tmp/bak_ta_cleanc_consts.v    ../../vlib/v2/gen/cleanc/consts_and_globals.v
-  cp /tmp/bak_ta_cleanc_assign.v    ../../vlib/v2/gen/cleanc/assign.v
-  cp /tmp/bak_ta_ssa_module.v       ../../vlib/v2/ssa/module.v
-  cp /tmp/bak_ta_ssa_mem2reg.v      ../../vlib/v2/ssa/optimize/mem2reg.v
-  cp /tmp/bak_ta_tr_struct.v        ../../vlib/v2/transformer/struct.v
-  cp /tmp/bak_ta_tr_transformer.v   ../../vlib/v2/transformer/transformer.v
-  cp /tmp/bak_ta_tr_types.v         ../../vlib/v2/transformer/types.v
+  rsync -a --delete "$V2_BAK/" "$V2_SRC/"
 }
 
 KNOWN_FAILURES=0
 
-echo "=== 1/13: ARM64 self-host hello world ==="
-if v -o v2 v2.v && ./v2 -backend arm64 -nocache -o v3 v2.v && ./v3 -o hello_arm hello.v && ./hello_arm; then
-  echo "[PASS]"
-else
-  echo "[KNOWN FAILURE] ARM64 self-host — skipping"
-  KNOWN_FAILURES=$((KNOWN_FAILURES + 1))
-fi
+echo "=== 1/14: ARM64 self-host hello world ==="
+backup_v2_src
+v -skip-unused -cc cc -o v2 v2.v
+restore_v2_src
+./v2 -backend arm64 -nocache -o v3 v2.v && ./v3 -o hello_arm hello.v && ./hello_arm
 
 echo ""
-echo "=== 2/13: Self-host test ==="
-if bash test_v2_self.sh; then
-  echo "[PASS]"
+echo "=== 2/14: ARM64 self-host chain (v2->v3->v4->v5, parallel) ==="
+echo "  Building v3 from v2..."
+./v2 -nocache -backend arm64 -o v3_chain v2.v
+echo "  Building v4 from v3..."
+./v3_chain -nocache -gc none -backend arm64 -o v4_chain v2.v
+echo "  Building v5 from v4..."
+./v4_chain -nocache -gc none -backend arm64 -o v5_chain v2.v
+V4_SIZE=$(wc -c < v4_chain)
+V5_SIZE=$(wc -c < v5_chain)
+if [ "$V4_SIZE" -eq "$V5_SIZE" ]; then
+  echo "  v4=v5 ($V4_SIZE bytes) — chain converged"
 else
-  echo "[KNOWN FAILURE] Self-host test — skipping"
-  KNOWN_FAILURES=$((KNOWN_FAILURES + 1))
+  echo "  FAIL: v4 ($V4_SIZE) != v5 ($V5_SIZE)"
+  exit 1
 fi
+rm -f v3_chain v4_chain v5_chain
+
+echo ""
+echo "=== 3/14: Self-host test ==="
+bash test_v2_self.sh
 
 echo ""
-echo "=== 3/13: Rebuild v2 and run builtin test files ==="
+echo "=== 4/14: Builtin test files (cleanc) ==="
 rm -rf /tmp/v2_cleanc_obj_cache
-backup_v2_src
-v self && v -skip-unused -cc cc -o v2 v2.v
-restore_v2_src
 ./v2 ../../vlib/builtin/array_test.v
 ./v2 ../../vlib/builtin/string_test.v
 ./v2 ../../vlib/builtin/map_test.v
 
 echo ""
-echo "=== 4/13: Builtin test files (arm64) ==="
-if ./v2 -backend arm64 ../../vlib/builtin/array_test.v \
-  && ./v2 -backend arm64 ../../vlib/builtin/string_test.v \
-  && ./v2 -backend arm64 ../../vlib/builtin/map_test.v; then
-  echo "[PASS]"
-else
-  echo "[KNOWN FAILURE] ARM64 builtin tests — skipping"
-  KNOWN_FAILURES=$((KNOWN_FAILURES + 1))
-fi
+echo "=== 5/14: Builtin test files (arm64) ==="
+./v2 -backend arm64 ../../vlib/builtin/array_test.v
+./v2 -backend arm64 ../../vlib/builtin/string_test.v
+./v2 -backend arm64 ../../vlib/builtin/map_test.v
 
 echo ""
-echo "=== 5/13: Math test ==="
+echo "=== 6/14: Math test ==="
 ./v2 ../../vlib/math/math_test.v
 
 echo ""
-echo "=== 6/13: Math test (arm64) ==="
-if ./v2 -backend arm64 ../../vlib/math/math_test.v; then
-  echo "[PASS]"
-else
-  echo "[KNOWN FAILURE] ARM64 math test — skipping"
-  KNOWN_FAILURES=$((KNOWN_FAILURES + 1))
-fi
+echo "=== 7/14: Math test (arm64) ==="
+./v2 -backend arm64 ../../vlib/math/math_test.v
 
 echo ""
-echo "=== 7/13: Sumtype tests ==="
+echo "=== 8/14: Sumtype tests ==="
 ./v2 test_sumtype.v
 ./v2 test_sumtype2.v
 ./v2 test_sumtype3.v
@@ -92,7 +82,7 @@ echo "=== 7/13: Sumtype tests ==="
 ./v2 test_sumtype_global.v
 
 echo ""
-echo "=== 8/13: Sumtype tests (arm64) ==="
+echo "=== 9/14: Sumtype tests (arm64) ==="
 ./v2 -backend arm64 test_sumtype.v
 ./v2 -backend arm64 test_sumtype2.v
 ./v2 -backend arm64 test_sumtype3.v
@@ -105,28 +95,23 @@ echo "=== 8/13: Sumtype tests (arm64) ==="
 ./v2 -backend arm64 test_sumtype_global.v
 
 echo ""
-echo "=== 9/13: SSA backends test (arm64) ==="
+echo "=== 10/14: SSA backends test (arm64) ==="
 v -gc none run test_ssa_backends.v arm64
 
 echo ""
-echo "=== 10/13: SSA backends test (cleanc) ==="
+echo "=== 11/14: SSA backends test (cleanc) ==="
 v -gc none run test_ssa_backends.v cleanc
 
 echo ""
-echo "=== 11/13: Transformer unit tests ==="
-if v ../../vlib/v2/transformer/transformer_test.v; then
-  echo "[PASS]"
-else
-  echo "[KNOWN FAILURE] Transformer unit tests — skipping"
-  KNOWN_FAILURES=$((KNOWN_FAILURES + 1))
-fi
+echo "=== 12/14: Transformer unit tests ==="
+v ../../vlib/v2/transformer/transformer_test.v
 
 echo ""
-echo "=== 12/13: Transformer integration test ==="
+echo "=== 13/14: Transformer integration test ==="
 v ../../vlib/v2/transformer/transformer_v2_darwin_test.v
 
 echo ""
-echo "=== 13/13: Cleanc runtime tests ==="
+echo "=== 14/14: Cleanc runtime tests ==="
 v -gc none run ../../vlib/v2/gen/cleanc/tests/run_tests.v
 
 echo ""

cmd/v2/test_v2_self.sh

@@ -23,9 +23,21 @@ if [[ ! -x "${v1_compiler}" ]]; then
     exit 1
 fi
 
+# V1's formatter may clobber v2 source files — backup and restore.
+v2_src="${repo_root}/vlib/v2"
+v2_bak="/tmp/v2_src_bak_self_test"
+rm -rf "${v2_bak}"
+cp -R "${v2_src}" "${v2_bak}"
+
 # Build v2 with v1.
 rm -f "${v2_bin}" "${v3_bin}" "${v3_bin}.c" "${v4_bin}" "${v4_bin}.c" "${v5_bin}" "${v5_bin}.c"
-"${v1_compiler}" -gc none -o "${v2_bin}" "${v2_source}"
+"${v1_compiler}" -skip-unused -cc cc -o "${v2_bin}" "${v2_source}"
+
+# Restore v2 sources after V1 build.
+rsync -a --delete "${v2_bak}/" "${v2_src}/"
+
+# Use clang instead of TCC for v2-compiled C code.
+export V2CC="${V2CC:-cc}"
 
 # Use v2 to compile itself to v3 (using defined backend).
 "${v2_bin}" -gc none -o "${v3_bin}" -backend "${backend}" "${v2_source}"

vlib/v/help/installation/symlink.txt

@@ -3,7 +3,7 @@ This command adds a symlink for the V compiler executable.
 Usage:
   v symlink [OPTIONS]
 
-Note that on Unix systems this command requires write permissions to
-/usr/local/bin to work.
+On Unix systems this command creates a symlink in /usr/local/bin. If that
+is not writable, it falls back to ~/.local/bin without requiring sudo.
 
 For GitHub Actions, the option -githubci needs to be specified.

vlib/v2/builder/gen_arm64_parallel.v

@@ -5,27 +5,27 @@ module builder
 
 import runtime
 import v2.gen.arm64
+import v2.mir
 
 struct GenARM64ChunkArgs {
-	gen       voidptr // &arm64.Gen (main gen, used as template for cloning)
+	worker    voidptr // &arm64.Gen — pre-cloned worker (created on main thread)
+	mod_ptr   voidptr // &mir.Module — shared MIR module
 	start_idx int
 	end_idx   int
-	worker    voidptr // &voidptr — output slot for worker Gen pointer
 }
 
 fn C.pthread_create(thread voidptr, attr voidptr, start_routine fn (voidptr) voidptr, arg voidptr) int
-
 fn C.pthread_join(thread voidptr, retval voidptr) int
+fn C.pthread_attr_init(attr voidptr) int
+fn C.pthread_attr_setstacksize(attr voidptr, stacksize usize) int
+fn C.pthread_attr_destroy(attr voidptr) int
 
 fn gen_arm64_chunk_thread(arg voidptr) voidptr {
 	a := unsafe { &GenARM64ChunkArgs(arg) }
-	g := unsafe { &arm64.Gen(a.gen) }
-	mut w := g.new_worker_clone()
+	mut w := unsafe { &arm64.Gen(a.worker) }
+	m := unsafe { &mir.Module(a.mod_ptr) }
 	for fi := a.start_idx; fi < a.end_idx; fi++ {
-		w.gen_func(g.mod.funcs[fi])
-	}
-	unsafe {
-		*(&voidptr(a.worker)) = voidptr(w)
+		w.gen_func(m.funcs[fi])
 	}
 	return unsafe { nil }
 }
@@ -45,35 +45,50 @@ fn (mut b Builder) gen_arm64_parallel(mut gen arm64.Gen) {
 		return
 	}
 
-	// Split functions into chunks and spawn workers via pthreads
+	// Split functions into chunks
 	chunk_size := (n_funcs + n_jobs - 1) / n_jobs
-	mut worker_ptrs := []voidptr{len: n_jobs, init: unsafe { nil }}
 	mut thread_ids := []voidptr{len: n_jobs, init: unsafe { nil }}
 	mut args := []GenARM64ChunkArgs{cap: n_jobs}
+
+	// Pre-create all workers on the main thread to avoid concurrent .clone() races.
+	// Each worker gets its own deep copy of maps/arrays.
+	mut workers := []voidptr{cap: n_jobs}
+
 	mut chunk_idx := 0
 	mut i := 0
 	for i < n_funcs {
 		end := if i + chunk_size < n_funcs { i + chunk_size } else { n_funcs }
+		w := gen.new_worker_clone()
+		workers << voidptr(w)
 		args << GenARM64ChunkArgs{
-			gen:       unsafe { voidptr(&gen) }
+			worker:    voidptr(w)
+			mod_ptr:   unsafe { voidptr(gen.mod) }
 			start_idx: i
 			end_idx:   end
-			worker:    unsafe { voidptr(&worker_ptrs[chunk_idx]) }
 		}
-		C.pthread_create(unsafe { voidptr(&thread_ids[chunk_idx]) }, unsafe { nil },
-			gen_arm64_chunk_thread, unsafe { voidptr(&args[chunk_idx]) })
 		i = end
 		chunk_idx++
 	}
 
+	attr_buf := [64]u8{}
+	attr := unsafe { voidptr(&attr_buf[0]) }
+	C.pthread_attr_init(attr)
+	C.pthread_attr_setstacksize(attr, 64 * 1024 * 1024)
+
+	for ci := 0; ci < chunk_idx; ci++ {
+		C.pthread_create(unsafe { voidptr(&thread_ids[ci]) }, attr, gen_arm64_chunk_thread,
+			unsafe { voidptr(&args[ci]) })
+	}
+	C.pthread_attr_destroy(attr)
+
 	// Wait for all workers
 	for ci := 0; ci < chunk_idx; ci++ {
 		C.pthread_join(thread_ids[ci], unsafe { nil })
 	}
 
 	// Merge worker results in order
 	for ci := 0; ci < chunk_idx; ci++ {
-		w := unsafe { &arm64.Gen(worker_ptrs[ci]) }
+		w := unsafe { &arm64.Gen(workers[ci]) }
 		gen.merge_worker(w)
 	}