v3: fix CI reachability and arm64 lowering

Author: medvednikov

vlib/v3/driver/driver.v

@@ -8304,7 +8304,9 @@ pub fn run(args []string) {
 		pre_tc.reject_unsupported_generics = is_selfhost
 		mut ckpre_sw := time.new_stopwatch()
 		set_diagnostic_files(mut pre_tc, user_files)
-		trivial_literal_output = test_files.len == 0 && !is_checker_fixture
+		// The C generator has a dedicated literal-output path. The SSA/native backend
+		// still builds ordinary builtin bodies, so it needs their full dependency set.
+		trivial_literal_output = backend != 'arm64' && test_files.len == 0 && !is_checker_fixture
 			&& markused.is_trivial_literal_output_program(a, pre_tc.diagnostic_files)
 		if verbose {
 			eprintln('  [ttime]   ck trivial gate  ${f64(ckpre_sw.elapsed().microseconds()) / 1000.0:7.2f} ms')

vlib/v3/gen/arm64/gen.v

@@ -223,6 +223,9 @@ fn arm64_max_int(a int, b int) int {
 fn (mut g Gen) gen_pre_pass() {
 	mut data_offset := u64(0)
 	for gi in 0 .. g.m.globals.len {
+		if g.m.globals[gi].linkage == .external {
+			continue
+		}
 		data_offset = (data_offset + 7) & ~u64(7)
 		g.macho.add_symbol('_' + g.m.globals[gi].name, data_offset, true, 3)
 		size := g.m.type_size(g.m.globals[gi].typ)
@@ -233,6 +236,9 @@ fn (mut g Gen) gen_pre_pass() {
 // gen_post_pass emits post pass output for arm64.
 fn (mut g Gen) gen_post_pass() {
 	for gi in 0 .. g.m.globals.len {
+		if g.m.globals[gi].linkage == .external {
+			continue
+		}
 		for g.macho.data_data.len % 8 != 0 {
 			g.macho.data_data << 0
 		}
@@ -479,7 +485,7 @@ fn (mut g Gen) emit_zero_aggregate(ptr_reg int, typ_id ssa.TypeID, max_size int)
 	}
 	n_words := (size + 7) / 8
 	for wi in 0 .. n_words {
-		g.emit32(asm_str_imm(xzr, Reg(ptr_reg), u32(wi)))
+		g.emit_store_reg_offset(xzr, Reg(ptr_reg), wi * 8)
 	}
 }
 
@@ -650,29 +656,27 @@ fn (mut g Gen) gen_instr(val_id int) {
 				g.emit32(asm_str(Reg(8), Reg(ptr_reg)))
 				g.emit32(asm_str_imm(Reg(10), Reg(ptr_reg), 1))
 			} else {
+				ptr_reg := g.load_val(ptr_id, 9)
+				dest_type := g.ptr_elem_type(ptr_id)
+				if g.is_zero_const(src_id) && g.is_aggregate_type(dest_type) {
+					g.emit_zero_aggregate(ptr_reg, dest_type, g.aggregate_store_size(ptr_id,
+						dest_type))
+					return
+				}
 				src_size := g.m.type_size(src_val.typ)
 				if src_size > 8 && g.is_value_aggregate_type(src_val.typ) {
 					if src_off := g.stack_slot(src_id) {
-						ptr_reg := g.load_val(ptr_id, 9)
 						copy_size := g.aggregate_store_size(ptr_id, src_val.typ)
 						n_words := (copy_size + 7) / 8
 						for wi in 0 .. n_words {
 							g.emit_load_fp(8, src_off + wi * 8)
-							g.emit32(asm_str_imm(Reg(8), Reg(ptr_reg), u32(wi)))
+							g.emit_store_reg_offset(Reg(8), Reg(ptr_reg), wi * 8)
 						}
 					} else {
 						src_reg := g.load_val(src_id, 8)
-						ptr_reg := g.load_val(ptr_id, 9)
 						g.emit32(asm_str(Reg(src_reg), Reg(ptr_reg)))
 					}
 				} else {
-					ptr_reg := g.load_val(ptr_id, 9)
-					dest_type := g.ptr_elem_type(ptr_id)
-					if g.is_zero_const(src_id) && g.is_aggregate_type(dest_type) {
-						g.emit_zero_aggregate(ptr_reg, dest_type, g.aggregate_store_size(ptr_id,
-							dest_type))
-						return
-					}
 					src_reg := g.load_val(src_id, 8)
 					store_typ := if int(dest_type) > 0 { dest_type } else { src_val.typ }
 					g.emit_store_typed(src_reg, ptr_reg, store_typ)
@@ -723,7 +727,7 @@ fn (mut g Gen) gen_instr(val_id int) {
 								copy_words := (copy_size + 7) / 8
 								total_words := (result_size + 7) / 8
 								for wi in 0 .. copy_words {
-									g.emit32(asm_ldr_imm(Reg(8), Reg(ptr_reg), u32(wi)))
+									g.emit_load_reg_offset(Reg(8), Reg(ptr_reg), wi * 8)
 									g.emit_store_fp(8, off + wi * 8)
 								}
 								if copy_words < total_words {
@@ -992,18 +996,18 @@ fn (mut g Gen) gen_instr(val_id int) {
 					if off := g.stack_slot(ret_id) {
 						for wi in 0 .. n_words {
 							g.emit_load_fp(8, off + wi * 8)
-							g.emit32(asm_str_imm(Reg(8), Reg(9), u32(wi)))
+							g.emit_store_reg_offset(Reg(8), Reg(9), wi * 8)
 						}
 					} else {
 						g.emit_mov_imm(8, 0)
 						for wi in 0 .. n_words {
-							g.emit32(asm_str_imm(Reg(8), Reg(9), u32(wi)))
+							g.emit_store_reg_offset(Reg(8), Reg(9), wi * 8)
 						}
 					}
 				} else {
 					g.emit_mov_imm(8, 0)
 					for wi in 0 .. n_words {
-						g.emit32(asm_str_imm(Reg(8), Reg(9), u32(wi)))
+						g.emit_store_reg_offset(Reg(8), Reg(9), wi * 8)
 					}
 				}
 				if g.stack_size > 0 {
@@ -1434,7 +1438,7 @@ fn (mut g Gen) emit_copy_ptr_to_fp(src_ptr_reg int, dst_off int, size int) {
 	n_words := (size + 7) / 8
 	tmp_reg := if src_ptr_reg == 8 { 10 } else { 8 }
 	for wi in 0 .. n_words {
-		g.emit32(asm_ldr_imm(Reg(tmp_reg), Reg(src_ptr_reg), u32(wi)))
+		g.emit_load_reg_offset(Reg(tmp_reg), Reg(src_ptr_reg), wi * 8)
 		g.emit_store_fp(tmp_reg, dst_off + wi * 8)
 	}
 }
@@ -1564,12 +1568,28 @@ fn (mut g Gen) emit_global_addr(reg int, name string) {
 	} else {
 		sym_idx = g.macho.add_undefined(sym_name)
 	}
+	if g.is_external_global(name) {
+		g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_got_load_page21, true)
+		g.emit32(asm_adrp(Reg(reg)))
+		g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_got_load_pageoff12, false)
+		g.emit32(asm_ldr_pageoff(Reg(reg)))
+		return
+	}
 	g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_page21, true)
 	g.emit32(asm_adrp(Reg(reg)))
 	g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_pageoff12, false)
 	g.emit32(asm_add_pageoff(Reg(reg)))
 }
 
+fn (g &Gen) is_external_global(name string) bool {
+	for global in g.m.globals {
+		if global.name == name {
+			return global.linkage == .external
+		}
+	}
+	return false
+}
+
 // find_global_idx_by_name resolves find global idx by name information for arm64.
 fn (g &Gen) find_global_idx_by_name(name string) int {
 	for i, global in g.m.globals {
@@ -1760,19 +1780,13 @@ fn (mut g Gen) emit_store_fp(reg int, offset int) {
 		g.emit32(asm_add_reg(Reg(11), fp, Reg(11)))
 		g.emit32(asm_str(Reg(reg), Reg(11)))
 	} else {
-		g.emit32(asm_str_imm(Reg(reg), fp, u32(offset / 8)))
+		g.emit_store_reg_offset(Reg(reg), fp, offset)
 	}
 }
 
 // emit_store_sp emits emit store sp output for arm64.
 fn (mut g Gen) emit_store_sp(reg int, offset int) {
-	if offset >= 0 && offset < 32768 && offset % 8 == 0 {
-		g.emit32(asm_str_imm(Reg(reg), sp, u32(offset / 8)))
-	} else {
-		g.emit_mov_imm(11, i64(offset))
-		g.emit32(asm_add_reg(Reg(11), sp, Reg(11)))
-		g.emit32(asm_str(Reg(reg), Reg(11)))
-	}
+	g.emit_store_reg_offset(Reg(reg), sp, offset)
 }
 
 // emit_load_fp emits emit load fp output for arm64.
@@ -1784,8 +1798,42 @@ fn (mut g Gen) emit_load_fp(reg int, offset int) {
 		g.emit32(asm_add_reg(Reg(11), fp, Reg(11)))
 		g.emit32(asm_ldr(Reg(reg), Reg(11)))
 	} else {
-		g.emit32(asm_ldr_imm(Reg(reg), fp, u32(offset / 8)))
+		g.emit_load_reg_offset(Reg(reg), fp, offset)
+	}
+}
+
+fn (mut g Gen) emit_store_reg_offset(src Reg, base Reg, offset int) {
+	if offset >= 0 && offset < 32768 && offset % 8 == 0 {
+		g.emit32(asm_str_imm(src, base, u32(offset / 8)))
+		return
+	}
+	scratch := if int(src) != 11 && int(base) != 11 {
+		Reg(11)
+	} else if int(src) != 12 && int(base) != 12 {
+		Reg(12)
+	} else {
+		Reg(13)
+	}
+	g.emit_mov_imm(int(scratch), i64(offset))
+	g.emit32(asm_add_reg(scratch, base, scratch))
+	g.emit32(asm_str(src, scratch))
+}
+
+fn (mut g Gen) emit_load_reg_offset(dst Reg, base Reg, offset int) {
+	if offset >= 0 && offset < 32768 && offset % 8 == 0 {
+		g.emit32(asm_ldr_imm(dst, base, u32(offset / 8)))
+		return
+	}
+	scratch := if int(dst) != 11 && int(base) != 11 {
+		Reg(11)
+	} else if int(dst) != 12 && int(base) != 12 {
+		Reg(12)
+	} else {
+		Reg(13)
 	}
+	g.emit_mov_imm(int(scratch), i64(offset))
+	g.emit32(asm_add_reg(scratch, base, scratch))
+	g.emit32(asm_ldr(dst, scratch))
 }
 
 // emit_lea_fp emits emit lea fp output for arm64.

vlib/v3/gen/arm64/gen_test.v

@@ -35,3 +35,26 @@ fn test_sparse_codegen_slots_only_store_current_function_ids() {
 	assert g.alloca_byte_size(6) == none
 	assert g.block_offset(0) == none
 }
+
+fn test_zero_aggregate_uses_address_fallback_past_immediate_range() {
+	mut m := ssa.Module.new()
+	i64_type := m.type_store.get_int(64)
+	large_array := m.type_store.get_array(i64_type, 4097)
+	mut g := Gen.new(m)
+	g.emit_zero_aggregate(9, large_array, 0)
+	assert g.macho.text_data.len == (4096 + 3) * 4
+	last := g.macho.text_data.len - 4
+	assert read_u32_le(g.macho.text_data, last) == asm_str(xzr, Reg(11))
+}
+
+fn test_external_global_address_uses_got_load_relocations() {
+	mut m := ssa.Module.new()
+	i8_type := m.type_store.get_int(8)
+	m.add_external_global('environ', m.type_store.get_ptr(m.type_store.get_ptr(i8_type)))
+	mut g := Gen.new(m)
+	g.emit_global_addr(8, 'environ')
+	assert g.macho.relocs.len == 2
+	assert g.macho.relocs[0].type_ == arm64_reloc_got_load_page21
+	assert g.macho.relocs[1].type_ == arm64_reloc_got_load_pageoff12
+	assert read_u32_le(g.macho.text_data, 4) == asm_ldr_pageoff(Reg(8))
+}

vlib/v3/markused/markused.v

@@ -618,7 +618,7 @@ fn mark_used_with_test_files(a &flat.FlatAst, tc &types.TypeChecker, test_files
 		}
 		generic_type_bases:               generic_type_bases
 		detect_generics:                  detect_reachable_generics
-		body_checker_edges_authoritative: !detect_reachable_generics
+		body_checker_edges_authoritative: use_prepared && !detect_reachable_generics
 	}
 	// Precollect every body's call/initializer-ref lists up front (across
 	// threads when available): the BFS below then only does the cheap

vlib/v3/ssa/builder.v

@@ -6624,9 +6624,12 @@ fn (mut b Builder) build_assign(node flat.Node) {
 					b.emit2(.store, b.void_type, result, addr)
 				}
 			}
-		} else if lhs.kind == .selector || lhs.kind == .index {
+		} else if lhs.kind == .selector || lhs.kind == .index
+			|| (lhs.kind == .prefix && lhs.op == .mul) {
 			addr := if lhs.kind == .selector {
 				b.build_selector_addr(lhs)
+			} else if lhs.kind == .prefix && lhs.children_count > 0 {
+				b.build_expr(b.a.child(&lhs, 0))
 			} else {
 				b.build_lvalue_addr(lhs_id)
 			}
@@ -10926,6 +10929,12 @@ fn (mut b Builder) build_selector(node flat.Node) ValueID {
 
 	if base.kind == .ident && base.value == 'C' {
 		match field_name {
+			'environ' {
+				ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
+				environ_type := b.m.type_store.get_ptr(ptr_i8)
+				environ_addr := b.m.add_external_global('environ', environ_type)
+				return b.emit1(.load, environ_type, environ_addr)
+			}
 			'SEEK_SET' {
 				return b.m.get_or_add_const(b.i64_type, '0')
 			}

vlib/v3/tests/ssa_builder_parity_test.v

@@ -383,6 +383,59 @@ fn get_bytes(d &Digest) [32]u8 {
 	assert typ.len == 32
 }
 
+// test_c_environ_loads_external_global validates this v3 regression case.
+fn test_c_environ_loads_external_global() {
+	m := build_source('c_environ_external_global', '
+fn read_environ() voidptr {
+	return voidptr(C.environ)
+}
+')
+	mut found := false
+	for global in m.globals {
+		if global.name == 'environ' {
+			assert global.linkage == .external
+			found = true
+		}
+	}
+	assert found
+}
+
+// test_dereference_struct_assignment_emits_store validates this v3 regression case.
+fn test_dereference_struct_assignment_emits_store() {
+	m := build_source('dereference_struct_assignment', '
+struct Big {
+	a int
+	b int
+	c int
+}
+
+fn copy_into(dst &Big, value Big) {
+	unsafe {
+		*dst = value
+	}
+}
+')
+	f := find_func(m, 'copy_into')
+	mut struct_stores := 0
+	for block_id in f.blocks {
+		for value_id in m.blocks[block_id].instrs {
+			value := m.values[value_id]
+			if value.kind != .instruction {
+				continue
+			}
+			instr := m.instrs[value.index]
+			if instr.op != .store || instr.operands.len < 2 {
+				continue
+			}
+			src_type := m.values[instr.operands[0]].typ
+			if src_type > 0 && m.type_store.types[src_type].kind == .struct_t {
+				struct_stores++
+			}
+		}
+	}
+	assert struct_stores >= 2
+}
+
 // test_label_and_goto_lower_to_jump_blocks validates this v3 regression case.
 fn test_label_and_goto_lower_to_jump_blocks() {
 	m := build_source('label_goto', '

vlib/v3/tests/ssa_production_native_test.v

@@ -34,10 +34,27 @@ fn loop_sum(n int) int {
 	return total
 }
 
+struct Index {
+mut:
+	files map[string]int
+}
+
+struct State {
+mut:
+	index Index
+}
+
+fn add_file(mut index Index) {
+	index.files["main.v"] = 7
+}
+
 fn main() {
 	println(int_str(choose(true)))
 	println(int_str(choose(false)))
 	println(int_str(loop_sum(10)))
+	mut state := State{}
+	add_file(mut state.index)
+	println(int_str(state.index.files["main.v"]))
 }
 ') or {
 			panic(err)
@@ -47,7 +64,7 @@ fn main() {
 		assert compile.exit_code == 0, compile.output
 		run := cmdexec.run(output, [])
 		assert run.exit_code == 0, run.output
-		assert run.output.trim_space() == '10\n20\n-5'
+		assert run.output.trim_space() == '10\n20\n-5\n7'
 	} $else {
 		assert true
 	}