v3: fix native selfhost regressions

Author: medvednikov

vlib/v3/driver/driver.v

@@ -8564,7 +8564,7 @@ pub fn run(args []string) {
 		} else if is_checker_fixture {
 			used_fns, uses_generics = markused.mark_used_with_generic_usage_full_runtime(a,
 				markused_tc)
-		} else if building_v && current_parallel_transform {
+		} else if building_v {
 			if prepare_markused_overlap {
 				used_fns = markused.mark_used_without_generic_detection_prepared(a, markused_tc, mut
 					prepared_markused)

vlib/v3/gen/arm64/gen.v

@@ -434,8 +434,7 @@ fn (mut g Gen) reserve_value_stack_slot(val_id int, current_offset int) int {
 	}
 	val := g.m.values[val_id]
 	result_size := g.m.type_size(val.typ)
-	alloc_size := if result_size > 8 && val.typ > 0 && val.typ < g.m.type_store.types.len
-		&& g.m.type_store.types[val.typ].kind == .struct_t {
+	alloc_size := if result_size > 8 && g.is_value_aggregate_type(val.typ) {
 		(result_size + 7) & ~7
 	} else {
 		8
@@ -445,22 +444,22 @@ fn (mut g Gen) reserve_value_stack_slot(val_id int, current_offset int) int {
 	return new_offset
 }
 
-// is_large_struct_type reports whether is large struct type applies in arm64.
+// is_large_struct_type reports whether an aggregate uses indirect argument/return passing.
 fn (g &Gen) is_large_struct_type(typ_id ssa.TypeID) bool {
-	if typ_id <= 0 || typ_id >= g.m.type_store.types.len {
-		return false
-	}
-	typ := g.m.type_store.types[typ_id]
-	return typ.kind == .struct_t && g.m.type_size(typ_id) > 16
+	return g.is_value_aggregate_type(typ_id) && g.m.type_size(typ_id) > 16
 }
 
-// is_aggregate_type reports whether is aggregate type applies in arm64.
+// is_aggregate_type reports whether an aggregate needs more than one register/word.
 fn (g &Gen) is_aggregate_type(typ_id ssa.TypeID) bool {
+	return g.is_value_aggregate_type(typ_id) && g.m.type_size(typ_id) > 8
+}
+
+fn (g &Gen) is_value_aggregate_type(typ_id ssa.TypeID) bool {
 	if typ_id <= 0 || typ_id >= g.m.type_store.types.len {
 		return false
 	}
 	typ := g.m.type_store.types[typ_id]
-	return typ.kind == .struct_t && g.m.type_size(typ_id) > 8
+	return typ.kind in [.struct_t, .array_t]
 }
 
 // is_zero_const reports whether is zero const applies in arm64.
@@ -652,8 +651,7 @@ fn (mut g Gen) gen_instr(val_id int) {
 				g.emit32(asm_str_imm(Reg(10), Reg(ptr_reg), 1))
 			} else {
 				src_size := g.m.type_size(src_val.typ)
-				if src_size > 8 && src_val.typ > 0 && src_val.typ < g.m.type_store.types.len
-					&& g.m.type_store.types[src_val.typ].kind == .struct_t {
+				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)
@@ -701,9 +699,8 @@ fn (mut g Gen) gen_instr(val_id int) {
 			} else {
 				ptr_reg := g.load_val(ptr_id, 9)
 				result_size := g.m.type_size(val.typ)
-				if result_size > 8 && val.typ > 0 && val.typ < g.m.type_store.types.len {
-					typ := g.m.type_store.types[val.typ]
-					if typ.kind == .struct_t {
+				if result_size > 8 && g.is_value_aggregate_type(val.typ) {
+					if val.typ > 0 && val.typ < g.m.type_store.types.len {
 						if off := g.stack_slot(val_id) {
 							if g.is_string_struct_type(val.typ) {
 								copy_size := g.aggregate_load_size(ptr_id, val.typ)
@@ -1041,8 +1038,7 @@ fn (mut g Gen) gen_instr(val_id int) {
 					g.emit32(asm_mov_reg(Reg(1), Reg(10)))
 				} else {
 					ret_size := g.m.type_size(ret_val.typ)
-					if ret_size > 8 && ret_val.typ > 0 && ret_val.typ < g.m.type_store.types.len
-						&& g.m.type_store.types[ret_val.typ].kind == .struct_t {
+					if ret_size > 8 && g.is_value_aggregate_type(ret_val.typ) {
 						if off := g.stack_slot(ret_id) {
 							if g.is_string_struct_type(ret_val.typ) {
 								g.emit_load_string_regs_from_fp(off, 0, 1, ret_val.typ)
@@ -1159,9 +1155,8 @@ fn (mut g Gen) gen_call(val_id int, instr ssa.Instruction) {
 		} else {
 			arg_type_id := arg_val.typ
 			arg_size := g.m.type_size(arg_type_id)
-			if arg_size > 8 && arg_type_id > 0 && arg_type_id < g.m.type_store.types.len {
-				typ := g.m.type_store.types[arg_type_id]
-				if typ.kind == .struct_t {
+			if arg_size > 8 && g.is_value_aggregate_type(arg_type_id) {
+				if arg_type_id > 0 && arg_type_id < g.m.type_store.types.len {
 					if g.is_large_struct_type(arg_type_id) {
 						if arg_reg < 8 {
 							if !g.emit_value_address(arg_id, arg_reg) {
@@ -1296,9 +1291,8 @@ fn (mut g Gen) gen_call(val_id int, instr ssa.Instruction) {
 
 	if instr.typ != 0 {
 		ret_size := g.m.type_size(instr.typ)
-		if ret_size > 8 && instr.typ > 0 && instr.typ < g.m.type_store.types.len {
-			typ := g.m.type_store.types[instr.typ]
-			if typ.kind == .struct_t {
+		if ret_size > 8 && g.is_value_aggregate_type(instr.typ) {
+			if instr.typ > 0 && instr.typ < g.m.type_store.types.len {
 				if off := g.stack_slot(val_id) {
 					if g.is_string_struct_type(instr.typ) {
 						g.emit_store_fp(0, off)
@@ -1377,8 +1371,7 @@ fn (g &Gen) call_stack_arg_size(instr ssa.Instruction) int {
 			n_words = 2
 		} else {
 			arg_size := g.m.type_size(arg_val.typ)
-			if arg_size > 8 && arg_val.typ > 0 && arg_val.typ < g.m.type_store.types.len
-				&& g.m.type_store.types[arg_val.typ].kind == .struct_t {
+			if arg_size > 8 && g.is_value_aggregate_type(arg_val.typ) {
 				n_words = if g.is_large_struct_type(arg_val.typ) { 1 } else { (arg_size + 7) / 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: use_prepared && !detect_reachable_generics
+		body_checker_edges_authoritative: !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

@@ -587,7 +587,7 @@ fn (mut b Builder) ssa_type_from_checker_type(typ types.Type) TypeID {
 		return b.array_type
 	}
 	if typ is types.ArrayFixed {
-		return b.m.type_store.get_ptr(b.ssa_type_from_checker_type(typ.elem_type))
+		return b.m.type_store.get_array(b.ssa_type_from_checker_type(typ.elem_type), typ.len)
 	}
 	if typ is types.Map {
 		return b.map_type
@@ -1182,7 +1182,9 @@ fn (mut b Builder) register_functions() {
 	b.register_printing_stubs()
 	b.register_at_exit_stub()
 	b.register_rand_prng_interface_stubs()
+	b.register_embed_file_interface_stubs()
 	b.register_pthread_compat_stubs()
+	b.register_closure_once_stub()
 	b.register_prealloc_allocator_stubs()
 	b.register_prealloc_atomic_stubs()
 	b.register_atomic_builtin_stubs()
@@ -2492,6 +2494,98 @@ fn (mut b Builder) register_array_runtime_stubs() {
 	array_repeat_id := b.register_synthetic_function('array.repeat_to_depth', b.array_type,
 		p3_repeat)
 	b.generate_array_repeat_to_depth_body(array_repeat_id)
+
+	for sort_type in ['int', 'i8', 'i16', 'i64', 'u8', 'u16', 'u32', 'u64', 'isize', 'usize', 'f32',
+		'f64', 'rune', 'char'] {
+		elem_type := match sort_type {
+			'int', 'rune' { b.i32_type }
+			'i8' { b.i8_type }
+			'i16' { b.m.type_store.get_int(16) }
+			'i64', 'isize' { b.i64_type }
+			'u8', 'char' { b.u8_type }
+			'u16' { b.u16_type }
+			'u32' { b.u32_type }
+			'u64', 'usize' { b.u64_type }
+			'f32' { b.f32_type }
+			else { b.f64_type }
+		}
+		mut sort_params := []TypeID{}
+		sort_params << ptr_array
+		sort_id := b.register_synthetic_function('v3_array_sort_${sort_type}', b.void_type,
+			sort_params)
+		b.generate_scalar_array_sort_body(sort_id, elem_type)
+	}
+}
+
+// generate_scalar_array_sort_body emits the native equivalent of the scalar qsort helpers
+// generated by the C backend.
+fn (mut b Builder) generate_scalar_array_sort_body(func_id int, elem_type TypeID) {
+	ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
+	ptr_i64 := b.m.type_store.get_ptr(b.i64_type)
+	ptr_array := b.m.type_store.get_ptr(b.array_type)
+	ptr_elem := b.m.type_store.get_ptr(elem_type)
+	entry := b.m.add_block(func_id, 'entry')
+	arr := b.func_add_argument(func_id, ptr_array, 'arr')
+	i_slot := b.block_instr0(.alloca, entry, ptr_i64)
+	j_slot := b.block_instr0(.alloca, entry, ptr_i64)
+	data_ptr := b.block_struct_field_ptr(entry, arr, b.array_type, 0)
+	data := b.block_instr1(.load, entry, ptr_i8, data_ptr)
+	len := b.block_load_array_int_field(entry, arr, 2)
+	zero := b.m.get_or_add_const(b.i64_type, '0')
+	one := b.m.get_or_add_const(b.i64_type, '1')
+	elem_size := b.m.get_or_add_const(b.i64_type, '${b.m.type_size(elem_type)}')
+	has_multiple := b.block_instr2(.gt, entry, b.i1_type, len, one)
+	outer_init := b.m.add_block(func_id, 'sort_outer_init')
+	outer_check := b.m.add_block(func_id, 'sort_outer_check')
+	inner_init := b.m.add_block(func_id, 'sort_inner_init')
+	inner_check := b.m.add_block(func_id, 'sort_inner_check')
+	compare := b.m.add_block(func_id, 'sort_compare')
+	swap := b.m.add_block(func_id, 'sort_swap')
+	inner_next := b.m.add_block(func_id, 'sort_inner_next')
+	outer_next := b.m.add_block(func_id, 'sort_outer_next')
+	done := b.m.add_block(func_id, 'sort_done')
+	b.block_instr3(.br, entry, b.void_type, has_multiple, ValueID(outer_init), ValueID(done))
+
+	b.block_instr2(.store, outer_init, b.void_type, zero, i_slot)
+	b.block_instr1(.jmp, outer_init, b.void_type, ValueID(outer_check))
+
+	i := b.block_instr1(.load, outer_check, b.i64_type, i_slot)
+	last := b.block_instr2(.sub, outer_check, b.i64_type, len, one)
+	has_outer := b.block_instr2(.lt, outer_check, b.i1_type, i, last)
+	b.block_instr3(.br, outer_check, b.void_type, has_outer, ValueID(inner_init), ValueID(done))
+
+	b.block_instr2(.store, inner_init, b.void_type, one, j_slot)
+	b.block_instr1(.jmp, inner_init, b.void_type, ValueID(inner_check))
+
+	j := b.block_instr1(.load, inner_check, b.i64_type, j_slot)
+	remaining := b.block_instr2(.sub, inner_check, b.i64_type, len, i)
+	has_inner := b.block_instr2(.lt, inner_check, b.i1_type, j, remaining)
+	b.block_instr3(.br, inner_check, b.void_type, has_inner, ValueID(compare), ValueID(outer_next))
+
+	prev_idx := b.block_instr2(.sub, compare, b.i64_type, j, one)
+	cur_offset := b.block_instr2(.mul, compare, b.i64_type, j, elem_size)
+	prev_offset := b.block_instr2(.mul, compare, b.i64_type, prev_idx, elem_size)
+	cur_ptr := b.block_instr2(.get_element_ptr, compare, ptr_elem, data, cur_offset)
+	prev_ptr := b.block_instr2(.get_element_ptr, compare, ptr_elem, data, prev_offset)
+	cur := b.block_instr1(.load, compare, elem_type, cur_ptr)
+	prev := b.block_instr1(.load, compare, elem_type, prev_ptr)
+	less_op := if b.is_unsigned_type(elem_type) { OpCode.ult } else { OpCode.lt }
+	less := b.block_instr2(less_op, compare, b.i1_type, cur, prev)
+	b.block_instr3(.br, compare, b.void_type, less, ValueID(swap), ValueID(inner_next))
+
+	b.block_instr2(.store, swap, b.void_type, cur, prev_ptr)
+	b.block_instr2(.store, swap, b.void_type, prev, cur_ptr)
+	b.block_instr1(.jmp, swap, b.void_type, ValueID(inner_next))
+
+	next_j := b.block_instr2(.add, inner_next, b.i64_type, j, one)
+	b.block_instr2(.store, inner_next, b.void_type, next_j, j_slot)
+	b.block_instr1(.jmp, inner_next, b.void_type, ValueID(inner_check))
+
+	next_i := b.block_instr2(.add, outer_next, b.i64_type, i, one)
+	b.block_instr2(.store, outer_next, b.void_type, next_i, i_slot)
+	b.block_instr1(.jmp, outer_next, b.void_type, ValueID(outer_check))
+
+	b.block_instr0(.ret, done, b.void_type)
 }
 
 // register_panic_stub updates register panic stub state for ssa.
@@ -3993,6 +4087,8 @@ fn (mut b Builder) generate_at_exit_body(func_id int, result_type TypeID, params
 
 fn (mut b Builder) register_pthread_compat_stubs() {
 	ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
+	zero_id := b.register_synthetic_c_function('v3_pthread_zero', b.u64_type, []TypeID{})
+	b.generate_const_body_with_params(zero_id, b.u64_type, '0', []TypeID{})
 	mut p_create := []TypeID{}
 	p_create << ptr_i8
 	p_create << b.i64_type
@@ -4008,6 +4104,24 @@ fn (mut b Builder) register_pthread_compat_stubs() {
 	b.generate_const_body_with_params(setkind_id, b.i32_type, '0', p_setkind)
 }
 
+fn (mut b Builder) register_closure_once_stub() {
+	callback_type := b.m.type_store.get_ptr(b.i8_type)
+	params := [callback_type]
+	func_id := b.register_synthetic_c_function('v_closure_init_once', b.void_type, params)
+	once_flag := b.m.add_global('v3_closure_init_once_done', b.i1_type)
+	entry := b.m.add_block(func_id, 'closure_once_entry')
+	callback := b.func_add_argument(func_id, callback_type, 'init_fn')
+	done := b.block_instr1(.load, entry, b.i1_type, once_flag)
+	call_init := b.m.add_block(func_id, 'closure_once_call')
+	return_block := b.m.add_block(func_id, 'closure_once_return')
+	b.block_instr3(.br, entry, b.void_type, done, ValueID(return_block), ValueID(call_init))
+	true_value := b.m.get_or_add_const(b.i1_type, '1')
+	b.block_instr2(.store, call_init, b.void_type, true_value, once_flag)
+	b.block_instr1(.call_indirect, call_init, b.void_type, callback)
+	b.block_instr1(.jmp, call_init, b.void_type, ValueID(return_block))
+	b.block_instr0(.ret, return_block, b.void_type)
+}
+
 fn (mut b Builder) register_rand_prng_interface_stubs() {
 	ptr_i8 := b.m.type_store.get_ptr(b.i8_type)
 	mut p_recv := []TypeID{}
@@ -4053,6 +4167,20 @@ fn (mut b Builder) register_rand_prng_interface_stubs() {
 	}
 }
 
+fn (mut b Builder) register_embed_file_interface_stubs() {
+	result_type := b.option_type_id('[]u8')
+	mut params := []TypeID{}
+	params << b.resolve_type('embed_file.Decoder')
+	params << b.array_type
+	func_id := b.register_synthetic_function('embed_file.Decoder.decompress', result_type, params)
+	entry := b.m.add_block(func_id, 'decompress_entry')
+	for i, param_type in params {
+		_ := b.func_add_argument(func_id, param_type, 'arg${i}')
+	}
+	result := b.block_option_value(entry, result_type, true, ValueID(0))
+	b.block_instr1(.ret, entry, b.void_type, result)
+}
+
 fn (mut b Builder) generate_noop_body(func_id int, params []TypeID) {
 	entry := b.m.add_block(func_id, 'noop_entry')
 	for i, param_type in params {
@@ -10121,7 +10249,13 @@ fn (mut b Builder) build_indirect_call(id flat.NodeId, node flat.Node, callee_id
 
 fn (b &Builder) is_function_value_expr(id flat.NodeId) bool {
 	typ := b.checked_expr_type_name(id).trim_space()
-	return typ.starts_with('fn(') || typ.starts_with('fn (')
+	if typ.starts_with('fn(') || typ.starts_with('fn (') {
+		return true
+	}
+	if b.tc != unsafe { nil } && typ.len > 0 && typ != 'unknown' {
+		return types.unalias_type(b.tc.parse_type(typ)) is types.FnType
+	}
+	return false
 }
 
 fn (mut b Builder) call_expr_result_type(id flat.NodeId, node flat.Node) TypeID {

vlib/v3/tests/ssa_builder_parity_test.v

@@ -219,6 +219,19 @@ fn main() {
 	assert f.blocks.len > 0
 }
 
+// test_scalar_array_sort_helper_builds_for_ssa validates this v3 regression case.
+fn test_scalar_array_sort_helper_builds_for_ssa() {
+	m := build_transformed_source('scalar_array_sort_helper', '
+fn main() {
+	mut values := [3, 1, 2]
+	values.sort()
+}
+')
+	assert has_call_to(m, 'main', 'v3_array_sort_int')
+	f := find_func(m, 'v3_array_sort_int')
+	assert f.blocks.len > 1
+}
+
 // test_u8_array_bytestr_alias_builds_for_ssa validates this v3 regression case.
 fn test_u8_array_bytestr_alias_builds_for_ssa() {
 	m := build_source('u8_array_bytestr_alias', '
@@ -320,6 +333,56 @@ fn apply(f fn (int, int) int, x int, y int) int {
 	assert found_indirect
 }
 
+// test_function_alias_field_call_lowers_to_call_indirect validates this v3 regression case.
+fn test_function_alias_field_call_lowers_to_call_indirect() {
+	m := build_source('call_indirect_alias_field', '
+type Callback = fn (int, int) int
+
+struct Holder {
+	callback Callback
+}
+
+fn apply(holder Holder, x int, y int) int {
+	return holder.callback(x, y)
+}
+')
+	assert has_instr_op(m, 'apply', .call_indirect)
+}
+
+// test_embed_file_decoder_dispatch_stub_builds_for_ssa validates this v3 regression case.
+fn test_embed_file_decoder_dispatch_stub_builds_for_ssa() {
+	m := build_source('embed_file_decoder_stub', 'fn main() {}')
+	f := find_func(m, 'embed_file.Decoder.decompress')
+	assert f.blocks.len == 1
+}
+
+// test_closure_once_stub_builds_for_ssa validates this v3 regression case.
+fn test_closure_once_stub_builds_for_ssa() {
+	m := build_source('closure_once_stub', 'fn main() {}')
+	f := find_func(m, 'v_closure_init_once')
+	assert f.blocks.len == 3
+	assert has_instr_op(m, 'v_closure_init_once', .call_indirect)
+	zero_fn := find_func(m, 'v3_pthread_zero')
+	assert zero_fn.blocks.len == 1
+}
+
+// test_fixed_array_return_keeps_value_type validates this v3 regression case.
+fn test_fixed_array_return_keeps_value_type() {
+	m := build_source('fixed_array_return', '
+struct Digest {
+	bytes [32]u8
+}
+
+fn get_bytes(d &Digest) [32]u8 {
+	return d.bytes
+}
+')
+	f := find_func(m, 'get_bytes')
+	typ := m.type_store.types[f.typ]
+	assert typ.kind == .array_t
+	assert typ.len == 32
+}
+
 // 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', '