native: support initializing a dynamic arrays with values (#25425)

Author: Eliyaan

vlib/builtin/builtin.c.v

@@ -682,6 +682,8 @@ pub fn vcalloc(n isize) &u8 {
 	}
 	$if prealloc {
 		return unsafe { prealloc_calloc(n) }
+	} $else $if native {
+		return unsafe { C.calloc(1, n) }
 	} $else $if gcboehm ? {
 		return unsafe { &u8(C.GC_MALLOC(n)) }
 	} $else {

vlib/v/gen/native/amd64.v

@@ -1879,7 +1879,7 @@ fn (mut c Amd64) div_reg_rax(b Amd64Register) {
 // rax % b
 fn (mut c Amd64) mod_reg_rax(b Amd64Register) {
 	c.div_reg_rax(b)
-	c.mov_reg(Amd64Register.rdx, Amd64Register.rax)
+	c.mov_reg(Amd64Register.rax, Amd64Register.rdx)
 }
 
 fn (mut c Amd64) sub_reg(a Amd64Register, b Amd64Register) {
@@ -2515,8 +2515,9 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 			match node.op {
 				.decl_assign {
 					if right.is_fixed {
-						c.g.n_error('${@LOCATION} Unexpected operator `${node.op}`')
-					} else {
+						c.g.n_error('${@LOCATION} Unsupported ${node} ${right}')
+					} else if right.exprs.len == 0 {
+						// `[]int{len: 6, cap:10, init:22}`
 						c.g.allocate_by_type(ident.name, ast.array_type)
 						len := ast.CallArg{
 							expr: if right.has_len {
@@ -2550,9 +2551,61 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 							return_type:        ast.array_type
 							nr_ret_values:      1
 							is_return_used:     true
-						})
+						}) // rax: address of returned array struct
 						c.lea_var_to_reg(Amd64Register.rdx, c.g.get_var_offset(ident.name))
-						c.move_struct(.rax, .rdx, c.g.get_type_size(ast.array_type))
+						c.move_struct(.rdx, .rax, c.g.get_type_size(ast.array_type))
+					} else {
+						// `[1, 2, 3]`
+
+						// array struct
+						c.g.allocate_by_type(ident.name, ast.array_type)
+						len := ast.CallArg{
+							expr: ast.IntegerLiteral{right.exprs.len.str(), right.pos}
+							typ:  ast.int_type
+							pos:  right.pos
+						}
+						cap := len
+						elem_size := c.g.get_type_size(right.elem_type)
+						size := ast.CallArg{
+							expr: ast.IntegerLiteral{elem_size.str(), right.pos}
+							typ:  ast.int_type
+							pos:  right.pos
+						}
+						c.call_fn(ast.CallExpr{
+							pos:                right.pos
+							name:               '__new_array'
+							args:               [len, cap, size]
+							expected_arg_types: [ast.int_type, ast.int_type, ast.int_type]
+							language:           .v
+							return_type:        ast.array_type
+							nr_ret_values:      1
+							is_return_used:     true
+						}) // rax: address of returned array struct
+						c.lea_var_to_reg(Amd64Register.rdx, c.g.get_var_offset(ident.name))
+						c.move_struct(.rdx, .rax, c.g.get_type_size(ast.array_type))
+
+						// init array
+						e_ts := c.g.table.sym(right.elem_type)
+						c.g.expr(node.left[i])
+						offset := c.g.get_field_offset(ast.array_type, 'data')
+						if offset != 0 {
+							c.add(Amd64Register.rax, offset)
+						}
+						c.mov_deref(Amd64Register.rdx, Amd64Register.rax, ast.u64_type) // address of the data
+						for e in right.exprs {
+							c.g.expr(e) // rax
+							if e_ts.info is ast.Struct {
+								c.move_struct(.rdx, .rax, elem_size)
+							} else {
+								c.mov_store(.rdx, .rax, match elem_size {
+									1 { ._8 }
+									2 { ._16 }
+									4 { ._32 }
+									else { ._64 }
+								})
+							}
+							c.add(Amd64Register.rdx, elem_size)
+						}
 					}
 				}
 				else {
@@ -2735,12 +2788,13 @@ fn (mut c Amd64) gen_index_expr(node ast.IndexExpr) {
 		c.mul_reg_main(Amd64Register.rbx)
 		c.add_reg2(Amd64Register.rax, Amd64Register.rcx)
 	} else if node.is_array {
+		// TODO: use functions from builtin instead (array.set, array.get...)
 		c.g.expr(node.left)
 		offset := c.g.get_field_offset(ast.array_type, 'data')
 		if offset != 0 {
 			c.add(Amd64Register.rax, offset)
 		}
-		c.mov_reg(Amd64Register.rcx, Amd64Register.rax)
+		c.mov_deref(Amd64Register.rcx, Amd64Register.rax, ast.u64_type)
 		// add the index times the size (bytes) of the type
 		c.g.expr(node.index)
 		c.mov(Amd64Register.rbx, i32(c.g.get_type_size(node.typ)))

vlib/v/gen/native/gen.v

@@ -819,8 +819,12 @@ fn (mut g Gen) get_var_offset(var_name string) i32 {
 fn (mut g Gen) get_field_offset(in_type ast.Type, name string) i32 {
 	typ := g.unwrap(in_type)
 	ts := g.table.sym(typ)
-	field := ts.find_field(name) or {
-		g.n_error('${@LOCATION} Could not find field `${name}` on init')
+	field := if ts.kind == .array {
+		g.table.sym(ast.array_type).find_field(name) or {
+			g.n_error('${@LOCATION} Could not find field `${name}` on init ${g.table.sym(ast.array_type)}')
+		}
+	} else {
+		ts.find_field(name) or { g.n_error('${@LOCATION} Could not find field `${name}` on init') }
 	}
 	return g.structs[typ.idx()].offsets[field.i]
 }

vlib/v/gen/native/tests/arrays.vv

@@ -1,6 +1,18 @@
 fn main() {
 	assert [1, 2, 3] != []
-	mut my_array := []int{len:3}
+	array_with_len()
+	array_with_values()
+}
+
+fn array_with_len() {
+	len := 20
+	mut my_array := []int{len:20}
+	for i in 0 .. len {
+		assert my_array[i] == 0	
+		unsafe {
+			assert &int(my_array.data)[i] == 0
+		}
+	}
 	my_array[0] = 4
 	my_array[1] = 5
 	my_array[2] = 6
@@ -10,4 +22,37 @@ fn main() {
 	assert my_array[0] == 4
 	assert my_array[1] == 5
 	assert my_array[2] == 6
+	unsafe {
+		assert &int(my_array.data)[0] == 4
+		assert &int(my_array.data)[1] == 5
+		assert &int(my_array.data)[2] == 6
+	}
+	assert my_array.len == len
+	assert my_array.cap == len
+}
+
+fn array_with_values() {
+	mut arr := [2, 4, 8, 16, 32, 64, 128]
+	assert arr[0] == 2
+	assert arr[1] == 4
+	assert arr[2] == 8
+	assert arr[3] == 16
+	assert arr[4] == 32
+	assert arr[5] == 64
+	assert arr[6] == 128
+	// below taken from builtin/array_test.v
+	arr[0] = 2
+	arr[1] &= 255
+	arr[2] |= 255
+	arr[3] <<= 4
+	arr[4] >>= 4
+	arr[5] %= 5
+	arr[6] ^= 3
+	assert arr[0] == 2
+	assert arr[1] == 4 & 255
+	assert arr[2] == 8 | 255
+	assert arr[3] == 16 << 4
+	assert arr[4] == 32 >> 4
+	assert arr[5] == 64 % 5
+	assert arr[6] == 128 ^ 3
 }

vlib/v/gen/native/tests/native_test.v

@@ -61,7 +61,7 @@ fn test_native() {
 
 	bench.set_total_expected_steps(tests.len)
 	for test in tests {
-		if skip_vv && test in ['libc.vv', 'linux.vv'] {
+		if skip_vv && test in ['libc.vv', 'linux.vv', 'arrays.vv'] {
 			// TODO: remove the skip here, when the native backend is more advanced
 			println('>>> SKIPPING ${test} since VNATIVE_SKIP_LIBC_VV is defined')
 			continue