v3: selective backend compilation (45% speed up)

Author: medvednikov

vlib/v3/gen/c/cleanc.v

@@ -1925,7 +1925,16 @@ fn (mut g FlatGen) gen_expr(id flat.NodeId) {
 				} else {
 					mod
 				}
-				g.write(c_name('${short_mod}.${node.value}'))
+				// A module-level const is stored under the importing module's full path
+				// (e.g. `v3.gen.wasm`), matching its function naming. Reference it by that
+				// exact storage name rather than the short alias, otherwise we'd emit an
+				// undeclared `wasm__x` for a const defined as `v3__gen__wasm__x`.
+				full_qname := g.const_storage_name(mod, node.value)
+				if full_qname in g.const_vals {
+					g.write(c_name(full_qname))
+				} else {
+					g.write(c_name('${short_mod}.${node.value}'))
+				}
 			} else if base.kind == .selector && base.children_count > 0
 				&& g.is_module_qualified_enum(base) {
 				inner_base := g.a.child_node(&base, 0)

vlib/v3/v3.v

@@ -134,6 +134,8 @@ fn main() {
 	mut no_parallel := false
 	mut parallel_transform := false
 	mut building_v := false
+	mut all_backends := false
+	mut compile_backends := []string{}
 	mut user_defines := []string{}
 	mut i := 0
 	for i < args.len {
@@ -163,6 +165,12 @@ fn main() {
 		} else if args[i] == '-parallel-transform' || args[i] == '--parallel-transform' {
 			parallel_transform = true
 			i++
+		} else if args[i] == '-all-backends' || args[i] == '--all-backends' {
+			all_backends = true
+			i++
+		} else if args[i] in ['-compile-backend', '--compile-backend'] && i + 1 < args.len {
+			compile_backends << args[i + 1]
+			i += 2
 		} else if args[i] == '-d' && i + 1 < args.len {
 			user_defines << args[i + 1]
 			i += 2
@@ -209,6 +217,47 @@ fn main() {
 		output_file = bin_file + '.c'
 	}
 
+	// Decide which backend modules to compile into the output. By default only the C
+	// backend is built; the arm64/wasm/eval backends (and the whole SSA pipeline that the
+	// arm64 backend pulls in: v3.ssa + v3.ssa.optimize) are skipped entirely. When compiling
+	// the V compiler itself this avoids parsing/checking/transforming/cgen-ing ~30k lines of
+	// unused backend code, which measurably speeds up the self-host build. The `skip_*`
+	// defines drive two things in lock-step: `$if !skip_* ?` gates in main() make the parser
+	// drop the dispatch blocks (so the backend symbols are never referenced), and
+	// resolve_imports skips parsing the corresponding module directories.
+	// `-all-backends` keeps everything; `-compile-backend <name>` opts a specific backend back
+	// in; the active `-b` target backend is always force-included.
+	mut include_arm64 := all_backends
+	mut include_wasm := all_backends
+	mut include_eval := all_backends
+	for cb in compile_backends {
+		for name in cb.split(',') {
+			match name.trim_space() {
+				'arm64', 'aarch64' { include_arm64 = true }
+				'wasm', 'wasm32' { include_wasm = true }
+				'eval' { include_eval = true }
+				// 'c' is always built; there is no native amd64 backend in v3 yet.
+				else {}
+			}
+		}
+	}
+	match backend {
+		'arm64' { include_arm64 = true }
+		'wasm' { include_wasm = true }
+		'eval' { include_eval = true }
+		else {}
+	}
+
+	if !include_arm64 {
+		user_defines << 'skip_arm64'
+	}
+	if !include_wasm {
+		user_defines << 'skip_wasm'
+	}
+	if !include_eval {
+		user_defines << 'skip_eval'
+	}
+
 	mut b := bench.new()
 	println('=== v3 benchmark ===')
 
@@ -273,14 +322,16 @@ fn main() {
 	b.step('check')
 
 	if backend == 'eval' {
-		mut runner := eval.new(prefs)
-		runner.run_files(a) or {
-			eprintln('error: ${err.msg()}')
-			exit(1)
+		$if !skip_eval ? {
+			mut runner := eval.new(prefs)
+			runner.run_files(a) or {
+				eprintln('error: ${err.msg()}')
+				exit(1)
+			}
+			b.step('eval')
+			b.print_report()
+			return
 		}
-		b.step('eval')
-		b.print_report()
-		return
 	}
 
 	// Mark used functions (dead-code elimination). This is done before transform
@@ -306,21 +357,23 @@ fn main() {
 	b.step('annotate types')
 
 	if backend == 'wasm' {
-		// Direct flat-AST-to-WASM native backend. Runs before monomorphize (which
-		// targets generics, not yet supported here). output_file is the exact path
-		// requested via -o (or the <name>.wasm default).
-		mut g := wasm.Gen.new(a, pre_tc, used_fns)
-		g.gen()
-		g.write(output_file) or {
-			eprintln('error writing ${output_file}')
-			exit(1)
-		}
-		for w in g.warnings_list() {
-			eprintln('wasm: ${w}')
+		$if !skip_wasm ? {
+			// Direct flat-AST-to-WASM native backend. Runs before monomorphize (which
+			// targets generics, not yet supported here). output_file is the exact path
+			// requested via -o (or the <name>.wasm default).
+			mut g := wasm.Gen.new(a, pre_tc, used_fns)
+			g.gen()
+			g.write(output_file) or {
+				eprintln('error writing ${output_file}')
+				exit(1)
+			}
+			for w in g.warnings_list() {
+				eprintln('wasm: ${w}')
+			}
+			b.step('wasm gen')
+			b.print_report()
+			return
 		}
-		b.step('wasm gen')
-		b.print_report()
-		return
 	}
 
 	// Monomorphization only adds specialized generic instantiations to `used_fns`. The V
@@ -332,21 +385,23 @@ fn main() {
 	b.step('monomorphize')
 
 	if backend == 'arm64' {
-		// SSA + ARM64 native backend
-		mut m := ssa.build_with_used(a, used_fns, pre_tc)
-		b.step('ssa build')
-
-		if is_prod {
-			optimize.optimize(mut m)
-			b.step('optimize')
-		}
+		$if !skip_arm64 ? {
+			// SSA + ARM64 native backend
+			mut m := ssa.build_with_used(a, used_fns, pre_tc)
+			b.step('ssa build')
+
+			if is_prod {
+				optimize.optimize(mut m)
+				b.step('optimize')
+			}
 
-		mut g := arm64.Gen.new(m)
-		g.gen()
-		b.step('arm64 gen')
+			mut g := arm64.Gen.new(m)
+			g.gen()
+			b.step('arm64 gen')
 
-		g.write_and_link(bin_file)
-		b.step('link')
+			g.write_and_link(bin_file)
+			b.step('link')
+		}
 	} else {
 		// C backend (default)
 		mut g := cgen.FlatGen.new()
@@ -566,12 +621,42 @@ fn path_is_in_dir(path string, dir string) bool {
 	return real_path == real_dir || real_path.starts_with(real_dir + os.path_separator)
 }
 
+// skipped_backend_modules lists the importable backend module names that the current
+// configuration excludes (driven by the same `skip_*` defines that gate the dispatch in
+// main()). The arm64 backend is the only consumer of the SSA pipeline, so skipping it also
+// skips v3.ssa and v3.ssa.optimize.
+fn skipped_backend_modules(prefs &pref.Preferences) []string {
+	mut skipped := []string{}
+	if 'skip_arm64' in prefs.user_defines {
+		skipped << 'v3.gen.arm64'
+		skipped << 'v3.ssa'
+		skipped << 'v3.ssa.optimize'
+	}
+	if 'skip_wasm' in prefs.user_defines {
+		skipped << 'v3.gen.wasm'
+	}
+	if 'skip_eval' in prefs.user_defines {
+		skipped << 'v3.eval'
+	}
+	return skipped
+}
+
 // resolve_imports resolves resolve imports information for v3 entry point.
 fn resolve_imports(mut a flat.FlatAst, mut p parser.Parser, prefs &pref.Preferences, initial_files []string) {
 	mut parsed_modules := map[string]bool{}
 	parsed_modules['builtin'] = true
 	parsed_modules['main'] = true
 
+	// Backend modules excluded by the active configuration are never parsed: their
+	// dispatch in main() is gated out by the matching `$if !skip_* ?`, so nothing
+	// references their symbols. Pre-seeding parsed_modules makes the loop below treat
+	// them as already handled, so neither v3.v's top-level imports nor any transitive
+	// import pulls them in. Skipping the arm64 group (v3.gen.arm64 + the v3.ssa SSA
+	// pipeline) and the wasm/eval backends avoids ~30k lines of work when self-hosting.
+	for skipped in skipped_backend_modules(prefs) {
+		parsed_modules[skipped] = true
+	}
+
 	mut first_file := ''
 	if initial_files.len > 0 {
 		first_file = initial_files[0]