native: fixed array, -new-transformer dynamic array (#25817)

Author: Eliyaan

vlib/v/gen/native/amd64.v

@@ -1962,6 +1962,10 @@ fn (mut c Amd64) mod_reg_rax(b Amd64Register) {
 	c.mov_reg(.rax, .rdx)
 }
 
+fn (mut c Amd64) cg_sub_reg(a Register, b Register) {
+	c.sub_reg(a.amd64(), b.amd64())
+}
+
 fn (mut c Amd64) sub_reg(a Amd64Register, b Amd64Register) {
 	if i32(a) <= i32(Amd64Register.r15) && i32(b) <= i32(Amd64Register.r15) {
 		c.g.write8(0x48 + if i32(a) >= i32(Amd64Register.r8) { i32(1) } else { i32(0) } +
@@ -2086,7 +2090,7 @@ pub fn (mut c Amd64) cg_call_fn(node ast.CallExpr) {
 	return_size := c.g.get_type_size(node.return_type)
 	mut return_pos := i32(-1)
 	mut is_struct_return := false
-	if ts.kind in [.struct, .multi_return] {
+	if ts.kind in [.struct, .multi_return, .array] {
 		return_pos = c.g.allocate_by_type('', node.return_type)
 		if return_size > 16 {
 			is_struct_return = true
@@ -2361,7 +2365,7 @@ fn (mut c Amd64) assign_struct_var(ident_var IdentVar, typ ast.Type, s i32) {
 	assert size == 0
 }
 
-fn (mut c Amd64) assign_var(var IdentVar, raw_type ast.Type) {
+fn (mut c Amd64) cg_assign_var(var IdentVar, raw_type ast.Type) {
 	typ := c.g.unwrap(raw_type)
 	info := c.g.table.sym(typ).info
 	size := c.g.get_type_size(typ)
@@ -2381,6 +2385,9 @@ fn (mut c Amd64) assign_var(var IdentVar, raw_type ast.Type) {
 	} else if info is ast.Struct && !typ.is_any_kind_of_pointer()
 		&& !raw_type.is_any_kind_of_pointer() {
 		c.assign_struct_var(var, typ, size)
+	} else if info is ast.Array && !typ.is_any_kind_of_pointer()
+		&& !raw_type.is_any_kind_of_pointer() {
+		c.assign_struct_var(var, typ, size)
 	} else if int(size) in [1, 2, 4, 8] {
 		match var {
 			LocalVar {
@@ -2593,8 +2600,12 @@ 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} Unsupported ${node} ${right}')
+						dest := c.g.allocate_by_type(name, ast.voidptr_type_idx)
+						c.g.expr(right)
+						c.cg_mov_reg_to_var(LocalVar{dest, ast.voidptr_type_idx, name},
+							.reg0)
 					} else if right.exprs.len == 0 {
+						// TODO: remove when ArrayInit for dynarrays will be solved in the transformer
 						// `[]int{len: 6, cap:10, init:22}`
 						c.g.allocate_by_type(ident.name, ast.array_type)
 						len := ast.CallArg{
@@ -2728,7 +2739,7 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 
 				if node.op in [.assign, .decl_assign] {
 					var := c.g.get_var_from_ident(ident)
-					c.assign_var(var, left_type)
+					c.cg_assign_var(var, left_type)
 				} else if left_type.is_pure_float() {
 					c.mov_var_to_ssereg(.xmm1, ident)
 
@@ -2775,7 +2786,7 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 
 			if node.op in [.assign, .decl_assign] {
 				var := c.g.get_var_from_ident(ident)
-				c.assign_var(var, left_type)
+				c.cg_assign_var(var, left_type)
 			} else if left_type.is_pure_float() {
 				c.mov_var_to_ssereg(.xmm1, ident)
 
@@ -4293,55 +4304,6 @@ fn (mut c Amd64) copy_struct_to_struct(field ast.StructField, f_offset i32, data
 	}
 }
 
-fn (mut c Amd64) cg_init_array(var Var, node ast.ArrayInit) {
-	match var {
-		ast.Ident {
-			var_object := c.g.get_var_from_ident(var)
-			match var_object {
-				LocalVar {
-					c.cg_init_array(var_object as LocalVar, node)
-				}
-				GlobalVar {
-					c.cg_init_array(var_object as GlobalVar, node)
-				}
-				Register {
-					// TODO
-					// c.g.cmp()
-				}
-				ExternVar {
-					c.cg_init_array(var_object as ExternVar, node)
-				}
-				PreprocVar {
-					c.cg_init_array(var_object as PreprocVar, node)
-				}
-				ConstVar {
-					c.cg_init_array(var_object as ConstVar, node)
-				}
-			}
-		}
-		LocalVar {
-			mut offset := var.offset
-			for expr in node.exprs {
-				c.g.expr(expr)
-				c.cg_mov_reg_to_var(LocalVar{offset, ast.i64_type_idx, ''}, .reg0)
-				offset += 8
-			}
-		}
-		GlobalVar {
-			c.g.n_error('${@LOCATION} unsupported var type ${var}')
-		}
-		ExternVar {
-			c.g.n_error('${@LOCATION} unsupported var type ${var}')
-		}
-		PreprocVar {
-			c.g.n_error('${@LOCATION} unsupported var type ${var}')
-		}
-		ConstVar {
-			c.g.n_error('${@LOCATION} unsupported var type ${var}')
-		}
-	}
-}
-
 // TODO: replace with .str()
 fn (mut c Amd64) cg_convert_bool_to_string(r Register) {
 	reg := r.amd64()

vlib/v/gen/native/arm64.v

@@ -446,10 +446,6 @@ fn (mut c Arm64) cg_init_struct(var Var, init ast.StructInit) {
 	panic('Arm64.cg_init_struct() not implemented')
 }
 
-fn (mut c Arm64) cg_init_array(var Var, init ast.ArrayInit) {
-	panic('Arm64.cg_init_array() not implemented')
-}
-
 fn (mut c Arm64) cg_load_fp_var(var Var, config VarConfig) {
 	panic('Arm64.cg_load_fp_var() not implemented')
 }
@@ -557,3 +553,11 @@ fn (mut c Arm64) cg_patch_relative_jmp(pos i32, addr i64) {
 fn (mut c Arm64) cg_mul_reg(a Register, b Register) {
 	panic('Arm64.cg_mul_reg() not implemented')
 }
+
+fn (mut c Arm64) cg_assign_var(var IdentVar, raw_type ast.Type) {
+	panic('Arm64.cg_assign_var() not implemented')
+}
+
+fn (mut c Arm64) cg_sub_reg(a Register, b Register) {
+	panic('Arm64.cg_sub_reg() not implemented')
+}

vlib/v/gen/native/blacklist.v

@@ -29,53 +29,54 @@ already compiling functions:
 // false: whitelist function
 // true: blacklist function
 const blacklist = {
-	'main.main':             false
-	'c_error_number_str':    false
-	'exit':                  false
-	'gc_is_enabled':         false
-	'int_max':               false
-	'int_min':               false
-	'flush_stdout':          false
-	'flush_stderr':          false
-	'print_character':       false
-	'u8.is_alnum':           false
-	'u8.is_bin_digit':       false
-	'u8.is_capital':         false
-	'u8.is_digit':           false
-	'u8.is_hex_digit':       false
-	'u8.is_letter':          false
-	'u8.is_oct_digit':       false
-	'u8.is_space':           false
-	'string.is_capital':     false
-	'string.is_ascii':       false
-	'string.is_identifier':  false
-	'string.is_blank':       false
-	'string.indent_width':   false
-	'string.index_u8':       false
-	'string.last_index':     true
-	'string.last_index_u8':  false
-	'string.contains_u8':    false
-	'malloc_noscan':         false
-	'malloc':                false
-	'is_nil':                false
-	'memdup':                false
-	'vcalloc':               false
-	'vmemcpy':               false
-	'eprint':                false
-	'eprintln':              false
-	'_write_buf_to_fd':      false
-	'_writeln_to_fd':        false
-	'_memory_panic':         false
-	'panic':                 false
-	'vcurrent_hash':         false
-	'__new_array':           false
-	'panic_on_negative_len': false
-	'panic_on_negative_cap': false
-	'panic_n':               false
-	'impl_i64_to_string':    false
-	'vmemmove':              false
-	'tos':                   false
-	'strings.new_builder':   true
+	'main.main':              false
+	'c_error_number_str':     false
+	'exit':                   false
+	'gc_is_enabled':          false
+	'int_max':                false
+	'int_min':                false
+	'flush_stdout':           false
+	'flush_stderr':           false
+	'print_character':        false
+	'u8.is_alnum':            false
+	'u8.is_bin_digit':        false
+	'u8.is_capital':          false
+	'u8.is_digit':            false
+	'u8.is_hex_digit':        false
+	'u8.is_letter':           false
+	'u8.is_oct_digit':        false
+	'u8.is_space':            false
+	'string.is_capital':      false
+	'string.is_ascii':        false
+	'string.is_identifier':   false
+	'string.is_blank':        false
+	'string.indent_width':    false
+	'string.index_u8':        false
+	'string.last_index':      true
+	'string.last_index_u8':   false
+	'string.contains_u8':     false
+	'malloc_noscan':          false
+	'malloc':                 false
+	'is_nil':                 false
+	'memdup':                 false
+	'vcalloc':                false
+	'vmemcpy':                false
+	'eprint':                 false
+	'eprintln':               false
+	'_write_buf_to_fd':       false
+	'_writeln_to_fd':         false
+	'_memory_panic':          false
+	'panic':                  false
+	'vcurrent_hash':          false
+	'__new_array':            false
+	'panic_on_negative_len':  false
+	'panic_on_negative_cap':  false
+	'panic_n':                false
+	'impl_i64_to_string':     false
+	'vmemmove':               false
+	'tos':                    false
+	'strings.new_builder':    true
+	'new_array_from_c_array': false
 }
 
 const windows_blacklist = {

vlib/v/gen/native/expr.v

@@ -16,9 +16,15 @@ fn (mut g Gen) expr(node ast.Expr) {
 			g.expr(node.expr)
 		}
 		ast.ArrayInit {
-			pos := g.allocate_array('_anonarray', 8, i32(node.exprs.len))
-			g.cg.cg_init_array(LocalVar{ offset: pos, typ: node.typ }, node)
-			g.cg.cg_lea_var_to_reg(.reg0, pos)
+			if node.is_fixed {
+				pos := g.allocate_fixed_array(node.elem_type, i32(node.exprs.len))
+				g.init_array(LocalVar{ offset: pos, typ: node.elem_type }, node)
+				g.cg.cg_lea_var_to_reg(.reg0, pos)
+			} else { // TODO: remove, it should not be on the stack
+				pos := g.allocate_array('_anonarray', 8, i32(node.exprs.len))
+				g.init_array(LocalVar{ offset: pos, typ: node.typ }, node)
+				g.cg.cg_lea_var_to_reg(.reg0, pos)
+			}
 		}
 		ast.BoolLiteral {
 			g.cg.cg_mov64(.reg0, i64(node.val))
@@ -168,6 +174,18 @@ fn (mut g Gen) expr(node ast.Expr) {
 	}
 }
 
+fn (mut g Gen) init_array(var LocalVar, node ast.ArrayInit) {
+	mut pos := var.offset
+	size := g.get_type_size(node.elem_type)
+	align := g.get_type_align(node.elem_type)
+	padding := (align - g.stack_var_pos % align) % align
+	for expr in node.exprs {
+		g.expr(expr)
+		g.cg.cg_assign_var(LocalVar{pos, node.elem_type, ''}, node.elem_type)
+		pos -= size + padding
+	}
+}
+
 fn (mut g Gen) local_var_ident(ident ast.Ident, var LocalVar) {
 	if g.is_register_type(var.typ) {
 		g.cg.cg_mov_var_to_reg(.reg0, ident)
@@ -185,6 +203,12 @@ fn (mut g Gen) local_var_ident(ident ast.Ident, var LocalVar) {
 			ast.Array {
 				g.cg.cg_lea_var_to_reg(.reg0, g.get_var_offset(ident.name))
 			}
+			ast.ArrayFixed {
+				g.cg.cg_mov_var_to_reg(.reg0, LocalVar{
+					offset: g.get_var_offset(ident.name)
+					typ:    ast.voidptr_type_idx
+				})
+			}
 			else {
 				g.n_error('${@LOCATION} Unsupported variable type ${ts.info}')
 			}
@@ -602,6 +626,14 @@ fn (mut g Gen) gen_index_expr(node ast.IndexExpr) {
 		g.cg.cg_mov(.reg3, i32(g.get_type_size(node.typ)))
 		g.cg.cg_mul_reg(.reg0, .reg3)
 		g.cg.cg_add_reg(.reg0, .reg1)
+	} else if node.is_farray {
+		g.expr(node.left)
+		g.cg.cg_mov_reg(.reg1, .reg0)
+		// add the index times the size (bytes) of the type
+		g.expr(node.index)
+		g.cg.cg_mov(.reg3, i32(g.get_type_size(node.typ)))
+		g.cg.cg_mul_reg(.reg0, .reg3)
+		g.cg.cg_add_reg(.reg0, .reg1)
 	} else {
 		g.n_error('${@LOCATION} index expr: unhandled node type {node}')
 	}

vlib/v/gen/native/gen.v

@@ -98,6 +98,7 @@ mut:
 	cg_add_reg(r Register, r2 Register)
 	cg_address_size() i32
 	cg_allocate_stack_var(name string, size i32, initial_val Number) i32
+	cg_assign_var(var IdentVar, raw_type ast.Type)
 	cg_assign_stmt(node ast.AssignStmt)
 	cg_builtin_decl(builtin BuiltinFn)
 	cg_call_addr_at(addr i32, at i64) i64
@@ -126,7 +127,6 @@ mut:
 	cg_infix_expr(node ast.InfixExpr)
 	cg_infloop()
 	cg_init_struct(var Var, init ast.StructInit)
-	cg_init_array(var Var, init ast.ArrayInit)
 	cg_jmp_back(start i64)
 	cg_jmp(addr i32) i32
 	cg_lea_var_to_reg(r Register, var_offset i32)
@@ -150,6 +150,7 @@ mut:
 	cg_ret()
 	cg_return_stmt(node ast.Return)
 	cg_reverse_string(r Register)
+	cg_sub_reg(a Register, b Register)
 	cg_syscall() // unix syscalls
 	cg_trap()
 	cg_zero_fill(size i32, var LocalVar)
@@ -826,6 +827,9 @@ fn (mut g Gen) unwrap(typ ast.Type) ast.Type {
 
 // get type size, and calculate size and align and store them to the cache when the type is struct
 fn (mut g Gen) get_type_size(raw_type ast.Type) i32 {
+	if raw_type == ast.no_type_idx {
+		g.n_error('${@LOCATION}: unknown type (0)')
+	}
 	// TODO: type flags
 	typ := g.unwrap(raw_type)
 	if raw_type.is_any_kind_of_pointer() || typ.is_any_kind_of_pointer() {
@@ -1042,13 +1046,22 @@ fn (mut g Gen) allocate_string(s string, opsize i32, typ RelocType) i32 {
 }
 
 // allocates a buffer variable: name, size of stored type (nb of bytes), nb of items
-fn (mut g Gen) allocate_array(name string, size i32, items i32) i32 {
+fn (mut g Gen) allocate_array(name string, size i32, items i32) i32 { // TODO: remove when proper strings are implemented, should not be used
 	g.println('; allocate array `${name}` item-size:${size} items:${items}:')
 	pos := g.cg.cg_allocate_stack_var(name, 4, i64(items)) // store the length of the array on the stack in a 4 byte var
 	g.stack_var_pos += (size * items) // reserve space on the stack for the items
 	return pos
 }
 
+fn (mut g Gen) allocate_fixed_array(typ ast.Type, nb_items i32) i32 {
+	g.println('; allocate fixed array type:${typ} nb_items:${nb_items}:')
+	size := g.get_type_size(typ)
+	align := g.get_type_align(typ)
+	padding := (align - g.stack_var_pos % align) % align
+	g.stack_var_pos += (size + padding) * nb_items // reserve space on the stack for the items
+	return g.stack_var_pos
+}
+
 fn (mut g Gen) eval_str_lit_escape_codes(str_lit ast.StringLiteral) string {
 	if str_lit.is_raw {
 		return str_lit.val

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

@@ -2,6 +2,14 @@ fn main() {
 	assert [1, 2, 3] != []
 	array_with_len()
 	array_with_values()
+	fixed_array()
+}
+
+fn fixed_array() {
+	f := [1, 2, 3]!
+	assert f[0] == 1
+	assert f[1] == 2
+	assert f[2] == 3
 }
 
 fn array_with_len() {