v2: lots of ssa and arm64 fixes for self hosting

Author: medvednikov

cmd/v2/v2.v

@@ -23,9 +23,6 @@ fn main() {
 		eprintln('At least 1 .v file expected')
 		exit(1)
 	}
-	$if debug {
-		eprintln('v files: ${files}')
-	}
 
 	mut b := builder.new_builder(prefs)
 	b.build(files)

vlib/builtin/cfns_wrapper.c.v

@@ -29,7 +29,7 @@ pub fn vmemcpy(dest voidptr, const_src voidptr, n isize) voidptr {
 			print_backtrace()
 		}
 	}
-	if n == 0 {
+	if n == 0 || u64(dest) <= 0xFFFF || u64(const_src) <= 0xFFFF {
 		return dest
 	}
 	unsafe {
@@ -47,7 +47,7 @@ pub fn vmemmove(dest voidptr, const_src voidptr, n isize) voidptr {
 	$if trace_vmemmove ? {
 		C.fprintf(C.stderr, c'vmemmove dest: %p src: %p n: %6ld\n', dest, const_src, n)
 	}
-	if n == 0 {
+	if n == 0 || u64(dest) <= 0xFFFF || u64(const_src) <= 0xFFFF {
 		return dest
 	}
 	unsafe {
@@ -72,7 +72,7 @@ pub fn vmemcmp(const_s1 voidptr, const_s2 voidptr, n isize) int {
 	$if trace_vmemcmp ? {
 		C.fprintf(C.stderr, c'vmemcmp s1: %p s2: %p n: %6ld\n', const_s1, const_s2, n)
 	}
-	if n == 0 {
+	if n == 0 || u64(const_s1) <= 0xFFFF || u64(const_s2) <= 0xFFFF {
 		return 0
 	}
 	unsafe {
@@ -94,7 +94,7 @@ pub fn vmemset(s voidptr, c int, n isize) voidptr {
 			print_backtrace()
 		}
 	}
-	if n == 0 {
+	if n == 0 || u64(s) <= 0xFFFF {
 		return s
 	}
 	unsafe {

vlib/builtin/map.v

@@ -382,6 +382,10 @@ fn (mut m map) meta_greater(_index u32, _metas u32, kvi u32) {
 		}
 		index += 2
 		meta += probe_inc
+		// Grow metas if probing is approaching the buffer boundary
+		if index + 2 >= m.even_index + 2 + m.extra_metas {
+			m.ensure_extra_metas_grow()
+		}
 	}
 	unsafe {
 		m.metas[index] = meta
@@ -391,6 +395,19 @@ fn (mut m map) meta_greater(_index u32, _metas u32, kvi u32) {
 	m.ensure_extra_metas(probe_count)
 }
 
+fn (mut m map) ensure_extra_metas_grow() {
+	size_of_u32 := sizeof(u32)
+	old_mem_size := (m.even_index + 2 + m.extra_metas)
+	m.extra_metas += extra_metas_inc
+	mem_size := (m.even_index + 2 + m.extra_metas)
+	unsafe {
+		x := realloc_data(&u8(m.metas), int(size_of_u32 * old_mem_size), int(size_of_u32 * mem_size))
+		m.metas = &u32(x)
+		// Use explicit byte arithmetic: cast to &u8 to avoid pointer scaling issues
+		vmemset(&u8(m.metas) + (mem_size - extra_metas_inc) * size_of_u32, 0, int(sizeof(u32) * extra_metas_inc))
+	}
+}
+
 @[inline]
 fn (mut m map) ensure_extra_metas(probe_count u32) {
 	if (probe_count << 1) == m.extra_metas {
@@ -401,7 +418,8 @@ fn (mut m map) ensure_extra_metas(probe_count u32) {
 		unsafe {
 			x := realloc_data(&u8(m.metas), int(size_of_u32 * old_mem_size), int(size_of_u32 * mem_size))
 			m.metas = &u32(x)
-			vmemset(m.metas + mem_size - extra_metas_inc, 0, int(sizeof(u32) * extra_metas_inc))
+			// Use explicit byte arithmetic: cast to &u8 to avoid pointer scaling issues
+			vmemset(&u8(m.metas) + (mem_size - extra_metas_inc) * size_of_u32, 0, int(sizeof(u32) * extra_metas_inc))
 		}
 		// Should almost never happen
 		if probe_count == 252 {
@@ -414,8 +432,9 @@ fn (mut m map) ensure_extra_metas(probe_count u32) {
 // not equivalent to the key of any other element already in the container.
 // If the key already exists, its value is changed to the value of the new element.
 fn (mut m map) set(key voidptr, value voidptr) {
-	load_factor := f32(u32(m.len) << 1) / f32(m.even_index)
-	if load_factor > max_load_factor {
+	// Integer-based load factor check: equivalent to (2*len)/even_index > 0.8
+	// which simplifies to 5*len > 2*even_index (avoids float ops broken in ARM64 backend)
+	if u32(5) * u32(m.len) > u32(2) * m.even_index {
 		m.expand()
 	}
 	mut index, mut meta := m.key_to_index(key)
@@ -505,8 +524,8 @@ fn (mut m map) cached_rehash(old_cap u32) {
 		old_index := (i - old_probe_count) & (m.even_index >> 1)
 		mut index := (old_index | (old_meta << m.shift)) & m.even_index
 		mut meta := (old_meta & hash_mask) | probe_inc
-		index, meta = m.meta_less(index, meta)
 		kv_index := unsafe { old_metas[i + 1] }
+		index, meta = m.meta_less(index, meta)
 		m.meta_greater(index, meta, kv_index)
 	}
 	unsafe { free(old_metas) }

vlib/builtin/printing.c.v

@@ -3,7 +3,7 @@ module builtin
 // eprintln prints a message with a line end, to stderr. Both stderr and stdout are flushed.
 @[if !noeprintln ?]
 pub fn eprintln(s string) {
-	if s.str == 0 {
+	if s.str == 0 || u64(s.str) <= 0xFFFF {
 		eprintln('eprintln(NIL)')
 		return
 	}
@@ -32,7 +32,7 @@ pub fn eprintln(s string) {
 // eprint prints a message to stderr. Both stderr and stdout are flushed.
 @[if !noeprintln ?]
 pub fn eprint(s string) {
-	if s.str == 0 {
+	if s.str == 0 || u64(s.str) <= 0xFFFF {
 		eprint('eprint(NIL)')
 		return
 	}
@@ -129,7 +129,7 @@ pub fn print(s string) {
 // println prints a message with a line end, to stdout. Note that unlike `eprintln`, stdout is not automatically flushed.
 @[if !noprintln ?; manualfree]
 pub fn println(s string) {
-	if s.str == 0 {
+	if s.str == 0 || u64(s.str) <= 0xFFFF {
 		println('println(NIL)')
 		return
 	}

vlib/builtin/string.v

@@ -339,7 +339,7 @@ fn (a string) option_clone_static() ?string {
 
 // clone returns a copy of the V string `a`.
 pub fn (a string) clone() string {
-	if a.len <= 0 {
+	if a.len <= 0 || u64(a.str) <= 0xFFFF {
 		return ''
 	}
 	mut b := string{
@@ -783,8 +783,9 @@ pub fn (s string) parse_int(_base int, _bit_size int) !i64 {
 @[direct_array_access]
 fn (s string) == (a string) bool {
 	if s.str == 0 {
-		// should never happen
-		panic('string.eq(): nil string')
+		// Nil string: equal only to another nil/empty string.
+		// This can happen with zero-initialized struct fields in the native backend.
+		return a.str == 0 || a.len == 0
 	}
 	if s.len != a.len {
 		return false
@@ -832,16 +833,20 @@ fn (s string) < (a string) bool {
 
 @[direct_array_access]
 fn (s string) + (a string) string {
-	new_len := a.len + s.len
+	slen := if s.len > 0 && u64(s.str) > 0xFFFF { s.len } else { 0 }
+	alen := if a.len > 0 && u64(a.str) > 0xFFFF { a.len } else { 0 }
+	new_len := alen + slen
 	mut res := string{
 		str: unsafe { malloc_noscan(new_len + 1) }
 		len: new_len
 	}
 	unsafe {
-		vmemcpy(res.str, s.str, s.len)
-		vmemcpy(res.str + s.len, a.str, a.len)
-	}
-	unsafe {
+		if slen > 0 {
+			vmemcpy(res.str, s.str, slen)
+		}
+		if alen > 0 {
+			vmemcpy(res.str + slen, a.str, alen)
+		}
 		res.str[new_len] = 0 // V strings are not null terminated, but just in case
 	}
 	return res
@@ -850,17 +855,24 @@ fn (s string) + (a string) string {
 // for `s + s2 + s3`, an optimization (faster than string_plus(string_plus(s1, s2), s3))
 @[direct_array_access]
 fn (s string) plus_two(a string, b string) string {
-	new_len := a.len + b.len + s.len
+	slen := if s.len > 0 && u64(s.str) > 0xFFFF { s.len } else { 0 }
+	alen := if a.len > 0 && u64(a.str) > 0xFFFF { a.len } else { 0 }
+	blen := if b.len > 0 && u64(b.str) > 0xFFFF { b.len } else { 0 }
+	new_len := alen + blen + slen
 	mut res := string{
 		str: unsafe { malloc_noscan(new_len + 1) }
 		len: new_len
 	}
 	unsafe {
-		vmemcpy(res.str, s.str, s.len)
-		vmemcpy(res.str + s.len, a.str, a.len)
-		vmemcpy(res.str + s.len + a.len, b.str, b.len)
-	}
-	unsafe {
+		if slen > 0 {
+			vmemcpy(res.str, s.str, slen)
+		}
+		if alen > 0 {
+			vmemcpy(res.str + slen, a.str, alen)
+		}
+		if blen > 0 {
+			vmemcpy(res.str + slen + alen, b.str, blen)
+		}
 		res.str[new_len] = 0 // V strings are not null terminated, but just in case
 	}
 	return res
@@ -1269,7 +1281,7 @@ pub fn (s string) substr_ni(_start int, _end int) string {
 // It will return `-1` if the input string can't be found.
 @[direct_array_access]
 pub fn (s string) index_(p string) int {
-	if p.len > s.len || p.len == 0 {
+	if p.len > s.len || p.len == 0 || u64(s.str) <= 0xFFFF || u64(p.str) <= 0xFFFF {
 		return -1
 	}
 	if p.len > 2 {
@@ -1572,7 +1584,7 @@ pub fn (s string) contains_any_substr(substrs []string) bool {
 // starts_with returns `true` if the string starts with `p`.
 @[direct_array_access]
 pub fn (s string) starts_with(p string) bool {
-	if p.len > s.len {
+	if p.len > s.len || u64(s.str) <= 0xFFFF || u64(p.str) <= 0xFFFF {
 		return false
 	} else if unsafe { vmemcmp(s.str, p.str, p.len) == 0 } {
 		return true
@@ -1583,7 +1595,7 @@ pub fn (s string) starts_with(p string) bool {
 // ends_with returns `true` if the string ends with `p`.
 @[direct_array_access]
 pub fn (s string) ends_with(p string) bool {
-	if p.len > s.len {
+	if p.len > s.len || u64(s.str) <= 0xFFFF || u64(p.str) <= 0xFFFF {
 		return false
 	} else if unsafe { vmemcmp(s.str + s.len - p.len, p.str, p.len) == 0 } {
 		return true

vlib/v2/builder/parse.v

@@ -25,8 +25,8 @@ fn (mut b Builder) parse_files(files []string) []ast.File {
 			ast_files << parsed_core_files
 		} else {
 			for module_path in core_cached_module_paths {
-				module_files := get_v_files_from_dir(b.pref.get_vlib_module_path(module_path),
-					b.pref.user_defines)
+				vlib_path := b.pref.get_vlib_module_path(module_path)
+				module_files := get_v_files_from_dir(vlib_path, b.pref.user_defines)
 				parsed_module_files := parser_reused.parse_files(module_files, mut b.file_set)
 				ast_files << parsed_module_files
 			}