v2: dead-strip unused functions in arm64 linker, reduce binary from 9.4MB to 5.85MB

- Add linker-level dead function stripping: BFS reachability from roots
  (_main, __v_init_consts_*), compact text section, fix up relocations
  and symbol addresses
- Add should_skip_store optimization: skip redundant store-then-load when
  value is consumed by the immediately next instruction (arithmetic, cmp,
  store, load, GEP, trunc, zext), with operand[1] forwarding via x10
- SP-relative addressing during sp_adjusted periods (sp_adjust_amt tracking)
- Merge fn_starts/fn_ends/fn_names/fn_sym_ids and stats in parallel workers
- should_skip_store: skip store-to-stack when value is consumed by the
  next instruction (arith, cmp, store, load, GEP, trunc, zext); includes
  operand[1] forwarding to x10 for binary ops. Eliminates 57K/211K stores
- Remove redundant canonicalize_narrow_int_result after cache hits (value
  already canonicalized before store). Saves ~58K SXTW/AND instructions
- Non-invalidating last_store cache: value stays in register after
  consumption, enabling multi-use of same cached value
- SP-relative addressing during sp_adjusted periods via sp_adjust_amt
  tracking, avoiding 2-3 instruction FP-relative fallback

Author: medvednikov

vlib/v2/builder/builder.v

@@ -837,7 +837,7 @@ fn (mut b Builder) gen_cleanc_source_with_cache_init_calls(modules []string, cac
 
 fn (mut b Builder) gen_cleanc_source_with_options(modules []string, export_const_symbols bool, cache_bundle_name string, cached_init_calls []string, use_markused bool) string {
 	mut gen_files := b.files.clone()
-	if cached_init_calls.len > 0 && b.can_use_cached_core_headers() {
+	if cached_init_calls.len > 0 && b.can_use_cached_core_headers_for_parse() {
 		mut p := parser.Parser.new(b.pref)
 		header_files := p.parse_files(b.core_cached_parse_paths(), mut b.file_set)
 		gen_files << header_files

vlib/v2/builder/cache_headers.v

@@ -238,6 +238,36 @@ fn (b &Builder) header_stamp_for_modules(modules []string) string {
 	return lines.join('\n')
 }
 
+// can_use_cached_core_headers_for_parse checks whether .vh header files
+// exist, are non-empty, and their stamp matches the current source/compiler
+// file timestamps.  The .o stamp validation is skipped (the gen phase
+// rebuilds stale .o files via ensure_cached_module_object), but the .vh
+// stamp IS validated so that stale headers trigger a full parse — otherwise
+// the gen phase would regenerate .o from incomplete .vh ASTs.
+fn (b &Builder) can_use_cached_core_headers_for_parse() bool {
+	if b.pref.no_cache || b.pref.skip_builtin {
+		return false
+	}
+	if !b.ensure_core_cache_dir() {
+		return false
+	}
+	// Validate .vh header stamp (no cc/cc_flags — only source + compiler timestamps).
+	expected_header_stamp := b.header_stamp_for_modules(core_cached_module_paths)
+	current_header_stamp := os.read_file(b.core_headers_stamp_path()) or { return false }
+	if current_header_stamp != expected_header_stamp {
+		return false
+	}
+	for header_path in b.core_header_paths() {
+		if !os.exists(header_path) {
+			return false
+		}
+		if os.file_size(header_path) == 0 {
+			return false
+		}
+	}
+	return true
+}
+
 fn (b &Builder) can_use_cached_core_headers() bool {
 	if b.pref.no_cache || b.pref.skip_builtin {
 		return false

vlib/v2/builder/parse.v

@@ -13,12 +13,9 @@ fn (mut b Builder) parse_files(files []string) []ast.File {
 	skip_builtin := b.pref.skip_builtin
 	mut use_core_headers := false
 	if !skip_builtin {
-		use_core_headers = false
-		// SSA/C and native backends need full core module bodies (not .vh summaries),
-		// otherwise runtime helpers can be lowered to stubs.
-		if b.pref.backend in [.c, .cleanc, .x64, .arm64] {
-			use_core_headers = false
-		}
+		// -prod builds with a valid header cache can use lightweight .vh
+		// summaries instead of fully parsing every core module source file.
+		use_core_headers = b.pref.is_prod && b.can_use_cached_core_headers_for_parse()
 		if use_core_headers {
 			core_files := b.core_cached_parse_paths()
 			parsed_core_files := parser_reused.parse_files(core_files, mut b.file_set)

vlib/v2/builder/parse_d_parallel.v

@@ -65,14 +65,9 @@ fn (mut b Builder) parse_files_parallel(files []string) []ast.File {
 	}
 	skip_builtin := b.pref.skip_builtin
 	if !skip_builtin {
-		use_core_headers := false
-		// SSA/C and native backends need full core module bodies (not .vh summaries),
-		// otherwise runtime helpers can be lowered to stubs.
-		use_core_headers2 := if b.pref.backend in [.c, .cleanc, .x64, .arm64] {
-			false
-		} else {
-			use_core_headers
-		}
+		// -prod builds with a valid header cache can use lightweight .vh
+		// summaries instead of fully parsing every core module source file.
+		use_core_headers2 := b.pref.is_prod && b.can_use_cached_core_headers_for_parse()
 		// Parse builtin and its dependencies
 		// Mark them as parsed first to prevent re-parsing via imports
 		for module_path in core_cached_module_paths {