From 665f5de33fe9ce8c4f250cb7ce2f755bab946803 Mon Sep 17 00:00:00 2001
From: Delyan Angelov <delian66@gmail.com>
Date: Wed, 4 May 2022 18:42:06 +0300
Subject: [PATCH] builtin: improve support for large arrays (`[]int{len:
 1_000_000_000}` now works), fix an arr.repeat() bug (#14294)

---
 vlib/builtin/array.v                     | 136 +++++++++++++----------
 vlib/builtin/array_d_gcboehm_opt.v       |  56 +++++-----
 vlib/builtin/array_test.v                | 119 ++++++++++++--------
 vlib/builtin/builtin.c.v                 |  10 +-
 vlib/builtin/cfns_wrapper.c.v            |   8 +-
 vlib/builtin/linux_bare/old/mm_bare.v    |   4 +-
 vlib/builtin/prealloc.c.v                |  14 +--
 vlib/v/tests/big_array_allocation_test.v |  19 ++++
 8 files changed, 216 insertions(+), 150 deletions(-)
 create mode 100644 vlib/v/tests/big_array_allocation_test.v

diff --git a/vlib/builtin/array.v b/vlib/builtin/array.v
index 0b99cce0fc..65b27022fc 100644
--- a/vlib/builtin/array.v
+++ b/vlib/builtin/array.v
@@ -31,7 +31,7 @@ fn __new_array(mylen int, cap int, elm_size int) array {
 	cap_ := if cap < mylen { mylen } else { cap }
 	arr := array{
 		element_size: elm_size
-		data: vcalloc(cap_ * elm_size)
+		data: vcalloc(u64(cap_) * u64(elm_size))
 		len: mylen
 		cap: cap_
 	}
@@ -45,14 +45,19 @@ fn __new_array_with_default(mylen int, cap int, elm_size int, val voidptr) array
 		len: mylen
 		cap: cap_
 	}
+	total_size := u64(cap_) * u64(elm_size)
 	if cap_ > 0 && mylen == 0 {
-		arr.data = unsafe { malloc(cap_ * elm_size) }
+		arr.data = unsafe { malloc(total_size) }
 	} else {
-		arr.data = vcalloc(cap_ * elm_size)
+		arr.data = vcalloc(total_size)
 	}
 	if val != 0 {
-		for i in 0 .. arr.len {
-			unsafe { arr.set_unsafe(i, val) }
+		mut eptr := &u8(arr.data)
+		unsafe {
+			for _ in 0 .. arr.len {
+				vmemcpy(eptr, val, arr.element_size)
+				eptr += arr.element_size
+			}
 		}
 	}
 	return arr
@@ -62,13 +67,17 @@ fn __new_array_with_array_default(mylen int, cap int, elm_size int, val array) a
 	cap_ := if cap < mylen { mylen } else { cap }
 	mut arr := array{
 		element_size: elm_size
-		data: unsafe { malloc(cap_ * elm_size) }
+		data: unsafe { malloc(u64(cap_) * u64(elm_size)) }
 		len: mylen
 		cap: cap_
 	}
-	for i in 0 .. arr.len {
-		val_clone := unsafe { val.clone_to_depth(1) }
-		unsafe { arr.set_unsafe(i, &val_clone) }
+	mut eptr := &u8(arr.data)
+	unsafe {
+		for _ in 0 .. arr.len {
+			val_clone := val.clone_to_depth(1)
+			vmemcpy(eptr, &val_clone, arr.element_size)
+			eptr += arr.element_size
+		}
 	}
 	return arr
 }
@@ -77,13 +86,17 @@ fn __new_array_with_map_default(mylen int, cap int, elm_size int, val map) array
 	cap_ := if cap < mylen { mylen } else { cap }
 	mut arr := array{
 		element_size: elm_size
-		data: unsafe { malloc(cap_ * elm_size) }
+		data: unsafe { malloc(u64(cap_) * u64(elm_size)) }
 		len: mylen
 		cap: cap_
 	}
-	for i in 0 .. arr.len {
-		val_clone := unsafe { val.clone() }
-		unsafe { arr.set_unsafe(i, &val_clone) }
+	mut eptr := &u8(arr.data)
+	unsafe {
+		for _ in 0 .. arr.len {
+			val_clone := val.clone()
+			vmemcpy(eptr, &val_clone, arr.element_size)
+			eptr += arr.element_size
+		}
 	}
 	return arr
 }
@@ -93,12 +106,12 @@ fn new_array_from_c_array(len int, cap int, elm_size int, c_array voidptr) array
 	cap_ := if cap < len { len } else { cap }
 	arr := array{
 		element_size: elm_size
-		data: vcalloc(cap_ * elm_size)
+		data: vcalloc(u64(cap_) * u64(elm_size))
 		len: len
 		cap: cap_
 	}
 	// TODO Write all memory functions (like memcpy) in V
-	unsafe { vmemcpy(arr.data, c_array, len * elm_size) }
+	unsafe { vmemcpy(arr.data, c_array, u64(len) * u64(elm_size)) }
 	return arr
 }
 
@@ -124,10 +137,10 @@ fn (mut a array) ensure_cap(required int) {
 	for required > cap {
 		cap *= 2
 	}
-	new_size := cap * a.element_size
+	new_size := u64(cap) * u64(a.element_size)
 	new_data := unsafe { malloc(new_size) }
 	if a.data != voidptr(0) {
-		unsafe { vmemcpy(new_data, a.data, a.len * a.element_size) }
+		unsafe { vmemcpy(new_data, a.data, u64(a.len) * u64(a.element_size)) }
 		// TODO: the old data may be leaked when no GC is used (ref-counting?)
 		if a.flags.has(.noslices) {
 			unsafe {
@@ -153,14 +166,14 @@ pub fn (a array) repeat(count int) array {
 // multi-dimensional arrays.
 //
 // It is `unsafe` to call directly because `depth` is not checked
-[unsafe]
+[direct_array_access; unsafe]
 pub fn (a array) repeat_to_depth(count int, depth int) array {
 	if count < 0 {
 		panic('array.repeat: count is negative: $count')
 	}
-	mut size := count * a.len * a.element_size
+	mut size := u64(count) * u64(a.len) * u64(a.element_size)
 	if size == 0 {
-		size = a.element_size
+		size = u64(a.element_size)
 	}
 	arr := array{
 		element_size: a.element_size
@@ -169,12 +182,18 @@ pub fn (a array) repeat_to_depth(count int, depth int) array {
 		cap: count * a.len
 	}
 	if a.len > 0 {
-		for i in 0 .. count {
-			if depth > 0 {
-				ary_clone := unsafe { a.clone_to_depth(depth) }
-				unsafe { vmemcpy(arr.get_unsafe(i * a.len), &u8(ary_clone.data), a.len * a.element_size) }
-			} else {
-				unsafe { vmemcpy(arr.get_unsafe(i * a.len), &u8(a.data), a.len * a.element_size) }
+		a_total_size := u64(a.len) * u64(a.element_size)
+		arr_step_size := u64(a.len) * u64(arr.element_size)
+		mut eptr := &u8(arr.data)
+		unsafe {
+			for _ in 0 .. count {
+				if depth > 0 {
+					ary_clone := a.clone_to_depth(depth)
+					vmemcpy(eptr, &u8(ary_clone.data), a_total_size)
+				} else {
+					vmemcpy(eptr, &u8(a.data), a_total_size)
+				}
+				eptr += arr_step_size
 			}
 		}
 	}
@@ -209,7 +228,7 @@ pub fn (mut a array) insert(i int, val voidptr) {
 		a.ensure_cap(a.len + 1)
 	}
 	unsafe {
-		vmemmove(a.get_unsafe(i + 1), a.get_unsafe(i), (a.len - i) * a.element_size)
+		vmemmove(a.get_unsafe(i + 1), a.get_unsafe(i), u64((a.len - i)) * u64(a.element_size))
 		a.set_unsafe(i, val)
 	}
 	a.len++
@@ -228,8 +247,8 @@ fn (mut a array) insert_many(i int, val voidptr, size int) {
 	elem_size := a.element_size
 	unsafe {
 		iptr := a.get_unsafe(i)
-		vmemmove(a.get_unsafe(i + size), iptr, (a.len - i) * elem_size)
-		vmemcpy(iptr, val, size * elem_size)
+		vmemmove(a.get_unsafe(i + size), iptr, u64(a.len - i) * u64(elem_size))
+		vmemcpy(iptr, val, u64(size) * u64(elem_size))
 	}
 	a.len += size
 }
@@ -286,8 +305,8 @@ pub fn (mut a array) delete_many(i int, size int) {
 	}
 	if a.flags.all(.noshrink | .noslices) {
 		unsafe {
-			vmemmove(&u8(a.data) + i * a.element_size, &u8(a.data) + (i + size) * a.element_size,
-				(a.len - i - size) * a.element_size)
+			vmemmove(&u8(a.data) + u64(i) * u64(a.element_size), &u8(a.data) + u64(i +
+				size) * u64(a.element_size), u64(a.len - i - size) * u64(a.element_size))
 		}
 		a.len -= size
 		return
@@ -297,11 +316,11 @@ pub fn (mut a array) delete_many(i int, size int) {
 	old_data := a.data
 	new_size := a.len - size
 	new_cap := if new_size == 0 { 1 } else { new_size }
-	a.data = vcalloc(new_cap * a.element_size)
-	unsafe { vmemcpy(a.data, old_data, i * a.element_size) }
+	a.data = vcalloc(u64(new_cap) * u64(a.element_size))
+	unsafe { vmemcpy(a.data, old_data, u64(i) * u64(a.element_size)) }
 	unsafe {
-		vmemcpy(&u8(a.data) + i * a.element_size, &u8(old_data) + (i + size) * a.element_size,
-			(a.len - i - size) * a.element_size)
+		vmemcpy(&u8(a.data) + u64(i) * u64(a.element_size), &u8(old_data) + u64(i +
+			size) * u64(a.element_size), u64(a.len - i - size) * u64(a.element_size))
 	}
 	if a.flags.has(.noslices) {
 		unsafe {
@@ -343,9 +362,9 @@ pub fn (mut a array) drop(num int) {
 		return
 	}
 	n := if num <= a.len { num } else { a.len }
-	blen := n * a.element_size
+	blen := u64(n) * u64(a.element_size)
 	a.data = unsafe { &u8(a.data) + blen }
-	a.offset += blen
+	a.offset += int(blen) // TODO: offset should become 64bit as well
 	a.len -= n
 	a.cap -= n
 }
@@ -354,7 +373,7 @@ pub fn (mut a array) drop(num int) {
 [inline; unsafe]
 fn (a array) get_unsafe(i int) voidptr {
 	unsafe {
-		return &u8(a.data) + i * a.element_size
+		return &u8(a.data) + u64(i) * u64(a.element_size)
 	}
 }
 
@@ -366,7 +385,7 @@ fn (a array) get(i int) voidptr {
 		}
 	}
 	unsafe {
-		return &u8(a.data) + i * a.element_size
+		return &u8(a.data) + u64(i) * u64(a.element_size)
 	}
 }
 
@@ -376,7 +395,7 @@ fn (a array) get_with_check(i int) voidptr {
 		return 0
 	}
 	unsafe {
-		return &u8(a.data) + i * a.element_size
+		return &u8(a.data) + u64(i) * u64(a.element_size)
 	}
 }
 
@@ -402,7 +421,7 @@ pub fn (a array) last() voidptr {
 		}
 	}
 	unsafe {
-		return &u8(a.data) + (a.len - 1) * a.element_size
+		return &u8(a.data) + u64(a.len - 1) * u64(a.element_size)
 	}
 }
 
@@ -429,7 +448,7 @@ pub fn (mut a array) pop() voidptr {
 		}
 	}
 	new_len := a.len - 1
-	last_elem := unsafe { &u8(a.data) + new_len * a.element_size }
+	last_elem := unsafe { &u8(a.data) + u64(new_len) * u64(a.element_size) }
 	a.len = new_len
 	// Note: a.cap is not changed here *on purpose*, so that
 	// further << ops on that array will be more efficient.
@@ -474,13 +493,13 @@ fn (a array) slice(start int, _end int) array {
 	}
 	// TODO: integrate reference counting
 	// a.flags.clear(.noslices)
-	offset := start * a.element_size
+	offset := u64(start) * u64(a.element_size)
 	data := unsafe { &u8(a.data) + offset }
 	l := end - start
 	res := array{
 		element_size: a.element_size
 		data: data
-		offset: a.offset + offset
+		offset: a.offset + int(offset) // TODO: offset should become 64bit
 		len: l
 		cap: l
 	}
@@ -526,13 +545,13 @@ fn (a array) slice_ni(_start int, _end int) array {
 		return res
 	}
 
-	offset := start * a.element_size
+	offset := u64(start) * u64(a.element_size)
 	data := unsafe { &u8(a.data) + offset }
 	l := end - start
 	res := array{
 		element_size: a.element_size
 		data: data
-		offset: a.offset + offset
+		offset: a.offset + int(offset) // TODO: offset should be 64bit
 		len: l
 		cap: l
 	}
@@ -562,7 +581,7 @@ pub fn (a &array) clone() array {
 // recursively clone given array - `unsafe` when called directly because depth is not checked
 [unsafe]
 pub fn (a &array) clone_to_depth(depth int) array {
-	mut size := a.cap * a.element_size
+	mut size := u64(a.cap) * u64(a.element_size)
 	if size == 0 {
 		size++
 	}
@@ -583,7 +602,7 @@ pub fn (a &array) clone_to_depth(depth int) array {
 		return arr
 	} else {
 		if !isnil(a.data) {
-			unsafe { vmemcpy(&u8(arr.data), a.data, a.cap * a.element_size) }
+			unsafe { vmemcpy(&u8(arr.data), a.data, u64(a.cap) * u64(a.element_size)) }
 		}
 		return arr
 	}
@@ -592,7 +611,7 @@ pub fn (a &array) clone_to_depth(depth int) array {
 // we manually inline this for single operations for performance without -prod
 [inline; unsafe]
 fn (mut a array) set_unsafe(i int, val voidptr) {
-	unsafe { vmemcpy(&u8(a.data) + a.element_size * i, val, a.element_size) }
+	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * u64(i), val, a.element_size) }
 }
 
 // Private function. Used to implement assigment to the array element.
@@ -602,14 +621,14 @@ fn (mut a array) set(i int, val voidptr) {
 			panic('array.set: index out of range (i == $i, a.len == $a.len)')
 		}
 	}
-	unsafe { vmemcpy(&u8(a.data) + a.element_size * i, val, a.element_size) }
+	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * u64(i), val, a.element_size) }
 }
 
 fn (mut a array) push(val voidptr) {
 	if a.len >= a.cap {
 		a.ensure_cap(a.len + 1)
 	}
-	unsafe { vmemcpy(&u8(a.data) + a.element_size * a.len, val, a.element_size) }
+	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * u64(a.len), val, a.element_size) }
 	a.len++
 }
 
@@ -623,11 +642,11 @@ pub fn (mut a3 array) push_many(val voidptr, size int) {
 		copy := a3.clone()
 		unsafe {
 			// vmemcpy(a.data, copy.data, copy.element_size * copy.len)
-			vmemcpy(a3.get_unsafe(a3.len), copy.data, a3.element_size * size)
+			vmemcpy(a3.get_unsafe(a3.len), copy.data, u64(a3.element_size) * u64(size))
 		}
 	} else {
 		if !isnil(a3.data) && !isnil(val) {
-			unsafe { vmemcpy(a3.get_unsafe(a3.len), val, a3.element_size * size) }
+			unsafe { vmemcpy(a3.get_unsafe(a3.len), val, u64(a3.element_size) * u64(size)) }
 		}
 	}
 	a3.len += size
@@ -641,10 +660,11 @@ pub fn (mut a array) reverse_in_place() {
 	unsafe {
 		mut tmp_value := malloc(a.element_size)
 		for i in 0 .. a.len / 2 {
-			vmemcpy(tmp_value, &u8(a.data) + i * a.element_size, a.element_size)
-			vmemcpy(&u8(a.data) + i * a.element_size, &u8(a.data) + (a.len - 1 - i) * a.element_size,
+			vmemcpy(tmp_value, &u8(a.data) + u64(i) * u64(a.element_size), a.element_size)
+			vmemcpy(&u8(a.data) + u64(i) * u64(a.element_size), &u8(a.data) +
+				u64(a.len - 1 - i) * u64(a.element_size), a.element_size)
+			vmemcpy(&u8(a.data) + u64(a.len - 1 - i) * u64(a.element_size), tmp_value,
 				a.element_size)
-			vmemcpy(&u8(a.data) + (a.len - 1 - i) * a.element_size, tmp_value, a.element_size)
 		}
 		free(tmp_value)
 	}
@@ -657,7 +677,7 @@ pub fn (a array) reverse() array {
 	}
 	mut arr := array{
 		element_size: a.element_size
-		data: vcalloc(a.cap * a.element_size)
+		data: vcalloc(u64(a.cap) * u64(a.element_size))
 		len: a.len
 		cap: a.cap
 	}
@@ -840,7 +860,7 @@ pub fn (a []string) str() string {
 // hex returns a string with the hexadecimal representation
 // of the byte elements of the array.
 pub fn (b []u8) hex() string {
-	mut hex := unsafe { malloc_noscan(b.len * 2 + 1) }
+	mut hex := unsafe { malloc_noscan(u64(b.len) * 2 + 1) }
 	mut dst_i := 0
 	for i in b {
 		n0 := i >> 4
diff --git a/vlib/builtin/array_d_gcboehm_opt.v b/vlib/builtin/array_d_gcboehm_opt.v
index d40ed47897..f68ab7665a 100644
--- a/vlib/builtin/array_d_gcboehm_opt.v
+++ b/vlib/builtin/array_d_gcboehm_opt.v
@@ -9,7 +9,7 @@ fn __new_array_noscan(mylen int, cap int, elm_size int) array {
 	cap_ := if cap < mylen { mylen } else { cap }
 	arr := array{
 		element_size: elm_size
-		data: vcalloc_noscan(cap_ * elm_size)
+		data: vcalloc_noscan(u64(cap_) * u64(elm_size))
 		len: mylen
 		cap: cap_
 	}
@@ -20,7 +20,7 @@ fn __new_array_with_default_noscan(mylen int, cap int, elm_size int, val voidptr
 	cap_ := if cap < mylen { mylen } else { cap }
 	mut arr := array{
 		element_size: elm_size
-		data: vcalloc_noscan(cap_ * elm_size)
+		data: vcalloc_noscan(u64(cap_) * u64(elm_size))
 		len: mylen
 		cap: cap_
 	}
@@ -36,7 +36,7 @@ fn __new_array_with_array_default_noscan(mylen int, cap int, elm_size int, val a
 	cap_ := if cap < mylen { mylen } else { cap }
 	mut arr := array{
 		element_size: elm_size
-		data: vcalloc_noscan(cap_ * elm_size)
+		data: vcalloc_noscan(u64(cap_) * u64(elm_size))
 		len: mylen
 		cap: cap_
 	}
@@ -52,12 +52,12 @@ fn new_array_from_c_array_noscan(len int, cap int, elm_size int, c_array voidptr
 	cap_ := if cap < len { len } else { cap }
 	arr := array{
 		element_size: elm_size
-		data: vcalloc_noscan(cap_ * elm_size)
+		data: vcalloc_noscan(u64(cap_) * u64(elm_size))
 		len: len
 		cap: cap_
 	}
 	// TODO Write all memory functions (like memcpy) in V
-	unsafe { vmemcpy(arr.data, c_array, len * elm_size) }
+	unsafe { vmemcpy(arr.data, c_array, u64(len) * u64(elm_size)) }
 	return arr
 }
 
@@ -70,10 +70,10 @@ fn (mut a array) ensure_cap_noscan(required int) {
 	for required > cap {
 		cap *= 2
 	}
-	new_size := cap * a.element_size
+	new_size := u64(cap) * u64(a.element_size)
 	new_data := vcalloc_noscan(new_size)
 	if a.data != voidptr(0) {
-		unsafe { vmemcpy(new_data, a.data, a.len * a.element_size) }
+		unsafe { vmemcpy(new_data, a.data, u64(a.len) * u64(a.element_size)) }
 		// TODO: the old data may be leaked when no GC is used (ref-counting?)
 	}
 	a.data = new_data
@@ -91,9 +91,9 @@ fn (a array) repeat_to_depth_noscan(count int, depth int) array {
 	if count < 0 {
 		panic('array.repeat: count is negative: $count')
 	}
-	mut size := count * a.len * a.element_size
+	mut size := u64(count) * u64(a.len) * u64(a.element_size)
 	if size == 0 {
-		size = a.element_size
+		size = u64(a.element_size)
 	}
 	arr := array{
 		element_size: a.element_size
@@ -102,12 +102,18 @@ fn (a array) repeat_to_depth_noscan(count int, depth int) array {
 		cap: count * a.len
 	}
 	if a.len > 0 {
-		for i in 0 .. count {
-			if depth > 0 {
-				ary_clone := unsafe { a.clone_to_depth_noscan(depth) }
-				unsafe { vmemcpy(arr.get_unsafe(i * a.len), &u8(ary_clone.data), a.len * a.element_size) }
-			} else {
-				unsafe { vmemcpy(arr.get_unsafe(i * a.len), &u8(a.data), a.len * a.element_size) }
+		a_total_size := u64(a.len) * u64(a.element_size)
+		arr_step_size := u64(a.len) * u64(arr.element_size)
+		mut eptr := &u8(arr.data)
+		unsafe {
+			for _ in 0 .. count {
+				if depth > 0 {
+					ary_clone := a.clone_to_depth_noscan(depth)
+					vmemcpy(eptr, &u8(ary_clone.data), a_total_size)
+				} else {
+					vmemcpy(eptr, &u8(a.data), a_total_size)
+				}
+				eptr += arr_step_size
 			}
 		}
 	}
@@ -123,7 +129,7 @@ fn (mut a array) insert_noscan(i int, val voidptr) {
 	}
 	a.ensure_cap_noscan(a.len + 1)
 	unsafe {
-		vmemmove(a.get_unsafe(i + 1), a.get_unsafe(i), (a.len - i) * a.element_size)
+		vmemmove(a.get_unsafe(i + 1), a.get_unsafe(i), u64(a.len - i) * u64(a.element_size))
 		a.set_unsafe(i, val)
 	}
 	a.len++
@@ -141,8 +147,8 @@ fn (mut a array) insert_many_noscan(i int, val voidptr, size int) {
 	elem_size := a.element_size
 	unsafe {
 		iptr := a.get_unsafe(i)
-		vmemmove(a.get_unsafe(i + size), iptr, (a.len - i) * elem_size)
-		vmemcpy(iptr, val, size * elem_size)
+		vmemmove(a.get_unsafe(i + size), iptr, u64(a.len - i) * u64(elem_size))
+		vmemcpy(iptr, val, u64(size) * u64(elem_size))
 	}
 	a.len += size
 }
@@ -167,7 +173,7 @@ fn (mut a array) pop_noscan() voidptr {
 		}
 	}
 	new_len := a.len - 1
-	last_elem := unsafe { &u8(a.data) + new_len * a.element_size }
+	last_elem := unsafe { &u8(a.data) + u64(new_len) * u64(a.element_size) }
 	a.len = new_len
 	// Note: a.cap is not changed here *on purpose*, so that
 	// further << ops on that array will be more efficient.
@@ -184,7 +190,7 @@ fn (a array) clone_static_to_depth_noscan(depth int) array {
 // recursively clone given array - `unsafe` when called directly because depth is not checked
 [unsafe]
 fn (a &array) clone_to_depth_noscan(depth int) array {
-	mut size := a.cap * a.element_size
+	mut size := u64(a.cap) * u64(a.element_size)
 	if size == 0 {
 		size++
 	}
@@ -205,7 +211,7 @@ fn (a &array) clone_to_depth_noscan(depth int) array {
 		return arr
 	} else {
 		if !isnil(a.data) {
-			unsafe { vmemcpy(&u8(arr.data), a.data, a.cap * a.element_size) }
+			unsafe { vmemcpy(&u8(arr.data), a.data, u64(a.cap) * u64(a.element_size)) }
 		}
 		return arr
 	}
@@ -213,7 +219,7 @@ fn (a &array) clone_to_depth_noscan(depth int) array {
 
 fn (mut a array) push_noscan(val voidptr) {
 	a.ensure_cap_noscan(a.len + 1)
-	unsafe { vmemcpy(&u8(a.data) + a.element_size * a.len, val, a.element_size) }
+	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * u64(a.len), val, a.element_size) }
 	a.len++
 }
 
@@ -226,12 +232,12 @@ fn (mut a3 array) push_many_noscan(val voidptr, size int) {
 		copy := a3.clone()
 		a3.ensure_cap_noscan(a3.len + size)
 		unsafe {
-			vmemcpy(a3.get_unsafe(a3.len), copy.data, a3.element_size * size)
+			vmemcpy(a3.get_unsafe(a3.len), copy.data, u64(a3.element_size) * u64(size))
 		}
 	} else {
 		a3.ensure_cap_noscan(a3.len + size)
 		if !isnil(a3.data) && !isnil(val) {
-			unsafe { vmemcpy(a3.get_unsafe(a3.len), val, a3.element_size * size) }
+			unsafe { vmemcpy(a3.get_unsafe(a3.len), val, u64(a3.element_size) * u64(size)) }
 		}
 	}
 	a3.len += size
@@ -244,7 +250,7 @@ fn (a array) reverse_noscan() array {
 	}
 	mut arr := array{
 		element_size: a.element_size
-		data: vcalloc_noscan(a.cap * a.element_size)
+		data: vcalloc_noscan(u64(a.cap) * u64(a.element_size))
 		len: a.len
 		cap: a.cap
 	}
diff --git a/vlib/builtin/array_test.v b/vlib/builtin/array_test.v
index 7ee03579a3..adc11276a4 100644
--- a/vlib/builtin/array_test.v
+++ b/vlib/builtin/array_test.v
@@ -209,61 +209,82 @@ fn test_compare_ints() {
     assert compare_ints(a, a) == 0
 }
 */
-fn test_repeat() {
-	{
-		a := [0].repeat(5)
-		assert a.len == 5
-		assert a[0] == 0 && a[1] == 0 && a[2] == 0 && a[3] == 0 && a[4] == 0
-	}
-	{
-		a := [1.1].repeat(10)
-		assert a[0] == 1.1
-		assert a[5] == 1.1
-		assert a[9] == 1.1
-	}
-	{
-		a := [i64(-123)].repeat(10)
-		assert a[0] == -123
-		assert a[5] == -123
-		assert a[9] == -123
-	}
-	{
-		a := [u64(123)].repeat(10)
-		assert a[0] == 123
-		assert a[5] == 123
-		assert a[9] == 123
-	}
-	{
-		a := [1.1].repeat(10)
-		assert a[0] == 1.1
-		assert a[5] == 1.1
-		assert a[9] == 1.1
-	}
-	{
-		a := [1, 2].repeat(2)
-		assert a[0] == 1
-		assert a[1] == 2
-		assert a[2] == 1
-		assert a[3] == 2
-	}
-	{
-		a := ['1', 'abc'].repeat(2)
-		assert a[0] == '1'
-		assert a[1] == 'abc'
-		assert a[2] == '1'
-		assert a[3] == 'abc'
-	}
-	{
-		mut a := ['1', 'abc'].repeat(0)
-		assert a.len == 0
-		a << 'abc'
-		assert a[0] == 'abc'
+
+fn test_repeat_int() {
+	a := [1234].repeat(5)
+	dump(a)
+	assert a.len == 5
+	for x in a {
+		assert x == 1234
 	}
 }
 
+fn test_repeat_f64() {
+	a := [1.1].repeat(10)
+	dump(a)
+	assert a.len == 10
+	assert a[0] == 1.1
+	assert a[5] == 1.1
+	assert a[9] == 1.1
+}
+
+fn test_repeat_f32() {
+	a := [f32(1.1)].repeat(10)
+	dump(a)
+	assert a.len == 10
+	assert a[0] == f32(1.1)
+	assert a[5] == f32(1.1)
+	assert a[9] == f32(1.1)
+}
+
+fn test_repeat_i64() {
+	a := [i64(-123)].repeat(10)
+	dump(a)
+	assert a.len == 10
+	assert a[0] == -123
+	assert a[5] == -123
+	assert a[9] == -123
+}
+
+fn test_repeat_u64() {
+	a := [u64(123)].repeat(10)
+	assert a[0] == 123
+	assert a[5] == 123
+	assert a[9] == 123
+}
+
+fn test_repeat_several_ints() {
+	a := [1, 2].repeat(2)
+	dump(a)
+	assert a.len == 4
+	assert a[0] == 1
+	assert a[1] == 2
+	assert a[2] == 1
+	assert a[3] == 2
+}
+
+fn test_repeat_several_strings_2() {
+	a := ['1', 'abc'].repeat(2)
+	dump(a)
+	assert a.len == 4
+	assert a[0] == '1'
+	assert a[1] == 'abc'
+	assert a[2] == '1'
+	assert a[3] == 'abc'
+}
+
+fn test_repeat_several_strings_0() {
+	mut a := ['1', 'abc'].repeat(0)
+	dump(a)
+	assert a.len == 0
+	a << 'abc'
+	assert a[0] == 'abc'
+}
+
 fn test_deep_repeat() {
 	mut a3 := [[[1, 1], [2, 2], [3, 3]], [[4, 4], [5, 5], [6, 6]]]
 	r := a3.repeat(3)
+	dump(r)
 	a3[1][1][0] = 17
 	assert r == [
 		[[1, 1], [2, 2], [3, 3]],
diff --git a/vlib/builtin/builtin.c.v b/vlib/builtin/builtin.c.v
index 5091e88de6..d295730919 100644
--- a/vlib/builtin/builtin.c.v
+++ b/vlib/builtin/builtin.c.v
@@ -276,7 +276,7 @@ __global total_m = i64(0)
 // malloc returns a `byteptr` pointing to the memory address of the allocated space.
 // unlike the `calloc` family of functions - malloc will not zero the memory block.
 [unsafe]
-pub fn malloc(n int) &u8 {
+pub fn malloc(n isize) &u8 {
 	if n <= 0 {
 		panic('malloc($n <= 0)')
 	}
@@ -319,7 +319,7 @@ pub fn malloc(n int) &u8 {
 }
 
 [unsafe]
-pub fn malloc_noscan(n int) &u8 {
+pub fn malloc_noscan(n isize) &u8 {
 	if n <= 0 {
 		panic('malloc_noscan($n <= 0)')
 	}
@@ -370,7 +370,7 @@ pub fn malloc_noscan(n int) &u8 {
 // previously allocated with `malloc`, `v_calloc` or `vcalloc`.
 // Please, see also realloc_data, and use it instead if possible.
 [unsafe]
-pub fn v_realloc(b &u8, n int) &u8 {
+pub fn v_realloc(b &u8, n isize) &u8 {
 	$if trace_realloc ? {
 		C.fprintf(C.stderr, c'v_realloc %6d\n', n)
 	}
@@ -441,7 +441,7 @@ pub fn realloc_data(old_data &u8, old_size int, new_size int) &u8 {
 // vcalloc dynamically allocates a zeroed `n` bytes block of memory on the heap.
 // vcalloc returns a `byteptr` pointing to the memory address of the allocated space.
 // Unlike `v_calloc` vcalloc checks for negative values given in `n`.
-pub fn vcalloc(n int) &u8 {
+pub fn vcalloc(n isize) &u8 {
 	if n < 0 {
 		panic('calloc($n < 0)')
 	} else if n == 0 {
@@ -462,7 +462,7 @@ pub fn vcalloc(n int) &u8 {
 
 // special versions of the above that allocate memory which is not scanned
 // for pointers (but is collected) when the Boehm garbage collection is used
-pub fn vcalloc_noscan(n int) &u8 {
+pub fn vcalloc_noscan(n isize) &u8 {
 	$if trace_vcalloc ? {
 		total_m += n
 		C.fprintf(C.stderr, c'vcalloc_noscan %6d total %10d\n', n, total_m)
diff --git a/vlib/builtin/cfns_wrapper.c.v b/vlib/builtin/cfns_wrapper.c.v
index 30d45b55fb..148aa9de96 100644
--- a/vlib/builtin/cfns_wrapper.c.v
+++ b/vlib/builtin/cfns_wrapper.c.v
@@ -18,7 +18,7 @@ pub fn vstrlen_char(s &char) int {
 // The memory areas *MUST NOT OVERLAP*.  Use vmemmove, if the memory
 // areas do overlap. vmemcpy returns a pointer to `dest`.
 [inline; unsafe]
-pub fn vmemcpy(dest voidptr, const_src voidptr, n int) voidptr {
+pub fn vmemcpy(dest voidptr, const_src voidptr, n isize) voidptr {
 	unsafe {
 		return C.memcpy(dest, const_src, n)
 	}
@@ -30,7 +30,7 @@ pub fn vmemcpy(dest voidptr, const_src voidptr, n int) voidptr {
 // `src` or `dest`, and the bytes are then copied from the temporary array
 // to `dest`. vmemmove returns a pointer to `dest`.
 [inline; unsafe]
-pub fn vmemmove(dest voidptr, const_src voidptr, n int) voidptr {
+pub fn vmemmove(dest voidptr, const_src voidptr, n isize) voidptr {
 	unsafe {
 		return C.memmove(dest, const_src, n)
 	}
@@ -49,7 +49,7 @@ pub fn vmemmove(dest voidptr, const_src voidptr, n int) voidptr {
 // You should use a function that performs comparisons in constant time for
 // this.
 [inline; unsafe]
-pub fn vmemcmp(const_s1 voidptr, const_s2 voidptr, n int) int {
+pub fn vmemcmp(const_s1 voidptr, const_s2 voidptr, n isize) int {
 	unsafe {
 		return C.memcmp(const_s1, const_s2, n)
 	}
@@ -58,7 +58,7 @@ pub fn vmemcmp(const_s1 voidptr, const_s2 voidptr, n int) int {
 // vmemset fills the first `n` bytes of the memory area pointed to by `s`,
 // with the constant byte `c`. It returns a pointer to the memory area `s`.
 [inline; unsafe]
-pub fn vmemset(s voidptr, c int, n int) voidptr {
+pub fn vmemset(s voidptr, c int, n isize) voidptr {
 	unsafe {
 		return C.memset(s, c, n)
 	}
diff --git a/vlib/builtin/linux_bare/old/mm_bare.v b/vlib/builtin/linux_bare/old/mm_bare.v
index e17cf4f32d..a1a77dbd61 100644
--- a/vlib/builtin/linux_bare/old/mm_bare.v
+++ b/vlib/builtin/linux_bare/old/mm_bare.v
@@ -31,7 +31,7 @@ pub fn mm_free(addr &byte) Errno {
 	return sys_munmap(ap, size)
 }
 
-pub fn mem_copy(dest0 voidptr, src0 voidptr, n int) voidptr {
+pub fn mem_copy(dest0 voidptr, src0 voidptr, n isize) voidptr {
 	mut dest := &u8(dest0)
 	src := &u8(src0)
 	for i in 0 .. n {
@@ -41,7 +41,7 @@ pub fn mem_copy(dest0 voidptr, src0 voidptr, n int) voidptr {
 }
 
 [unsafe]
-pub fn malloc(n int) &byte {
+pub fn malloc(n isize) &byte {
 	if n < 0 {
 		panic('malloc(<0)')
 	}
diff --git a/vlib/builtin/prealloc.c.v b/vlib/builtin/prealloc.c.v
index abe901022c..a8d64639de 100644
--- a/vlib/builtin/prealloc.c.v
+++ b/vlib/builtin/prealloc.c.v
@@ -21,16 +21,16 @@ __global g_memory_block &VMemoryBlock
 struct VMemoryBlock {
 mut:
 	id        int
-	cap       int
+	cap       isize
 	start     &byte = 0
 	previous  &VMemoryBlock = 0
-	remaining int
+	remaining isize
 	current   &u8 = 0
 	mallocs   int
 }
 
 [unsafe]
-fn vmemory_block_new(prev &VMemoryBlock, at_least int) &VMemoryBlock {
+fn vmemory_block_new(prev &VMemoryBlock, at_least isize) &VMemoryBlock {
 	mut v := unsafe { &VMemoryBlock(C.calloc(1, sizeof(VMemoryBlock))) }
 	if prev != 0 {
 		v.id = prev.id + 1
@@ -45,7 +45,7 @@ fn vmemory_block_new(prev &VMemoryBlock, at_least int) &VMemoryBlock {
 }
 
 [unsafe]
-fn vmemory_block_malloc(n int) &byte {
+fn vmemory_block_malloc(n isize) &byte {
 	unsafe {
 		if g_memory_block.remaining < n {
 			g_memory_block = vmemory_block_new(g_memory_block, n)
@@ -95,12 +95,12 @@ fn prealloc_vcleanup() {
 }
 
 [unsafe]
-fn prealloc_malloc(n int) &byte {
+fn prealloc_malloc(n isize) &byte {
 	return unsafe { vmemory_block_malloc(n) }
 }
 
 [unsafe]
-fn prealloc_realloc(old_data &byte, old_size int, new_size int) &byte {
+fn prealloc_realloc(old_data &byte, old_size isize, new_size isize) &byte {
 	new_ptr := unsafe { vmemory_block_malloc(new_size) }
 	min_size := if old_size < new_size { old_size } else { new_size }
 	unsafe { C.memcpy(new_ptr, old_data, min_size) }
@@ -108,7 +108,7 @@ fn prealloc_realloc(old_data &byte, old_size int, new_size int) &byte {
 }
 
 [unsafe]
-fn prealloc_calloc(n int) &byte {
+fn prealloc_calloc(n isize) &byte {
 	new_ptr := unsafe { vmemory_block_malloc(n) }
 	unsafe { C.memset(new_ptr, 0, n) }
 	return new_ptr
diff --git a/vlib/v/tests/big_array_allocation_test.v b/vlib/v/tests/big_array_allocation_test.v
new file mode 100644
index 0000000000..1a6e5a1581
--- /dev/null
+++ b/vlib/v/tests/big_array_allocation_test.v
@@ -0,0 +1,19 @@
+[direct_array_access]
+fn test_big_int_array() {
+	dump(sizeof(isize))
+	mut maxn := 500_000_000 // try allocating ~2GB worth of integers on 32bit platforms
+	if sizeof(isize) > 4 {
+		maxn = 1_000_000_000 // 1 billion integers, when each is 4 bytes => require ~4GB
+	}
+	dump(maxn)
+	mut data := []int{len: maxn}
+
+	// ensure that all of the elements are written at least once, to prevent the OS from cheating:
+	for i in 0 .. maxn {
+		data[i] = i
+	}
+	assert data[0] == 0
+	assert data[maxn - 1] == maxn - 1
+	dump(data#[0..10])
+	dump(data#[-10..])
+}