native: generalize cmp_to_stack_top and gen_index_expr (#25493)

Author: Eliyaan

vlib/v/gen/native/amd64.v

@@ -914,6 +914,8 @@ fn (mut c Amd64) mov_reg_to_var(var Var, reg Amd64Register, config VarConfig) {
 	}
 }
 
+// does not support 64bits
+// TODO: remove and replace by a more general function (like mov_reg_to_var)
 fn (mut c Amd64) cg_mov_int_to_var(var Var, integer i32, config VarConfig) {
 	match var {
 		ast.Ident {
@@ -2410,7 +2412,7 @@ fn (mut c Amd64) assign_var(var IdentVar, raw_type ast.Type) {
 fn (mut c Amd64) assign_ident_int_lit(node ast.AssignStmt, i i32, int_lit ast.IntegerLiteral, left ast.Ident) {
 	match node.op {
 		.decl_assign {
-			c.cg_allocate_var(left.name, 8, i64(int_lit.val.int()))
+			c.cg_allocate_stack_var(left.name, 8, i64(int_lit.val.int()))
 		}
 		.assign {
 			c.mov64(.rax, i64(int_lit.val.int()))
@@ -2518,7 +2520,7 @@ fn (mut c Amd64) mov_float_xmm0_var(reg Amd64Register, var_type ast.Type) {
 }
 
 fn (mut c Amd64) cg_create_string_struct(typ ast.Type, name string, str string) i32 {
-	dest := c.cg_allocate_var(name, c.g.get_type_size(typ), i64(0))
+	dest := c.cg_allocate_stack_var(name, c.g.get_type_size(typ), i64(0))
 	c.learel(.rax, c.g.allocate_string(str, 3, .rel32))
 	c.cg_mov_reg_to_var(LocalVar{dest, ast.u64_type_idx, name}, .reg0)
 	offset := c.g.get_field_offset(typ, 'len')
@@ -2547,7 +2549,7 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 			match val {
 				Number {
 					if node.op == .decl_assign {
-						c.cg_allocate_var(ident.name, enum_info.size, val)
+						c.cg_allocate_stack_var(ident.name, enum_info.size, val)
 					} else {
 						c.mov64(.rax, val)
 						c.cg_mov_reg_to_var(ident, .reg0)
@@ -2695,7 +2697,7 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 			return
 		}
 		ast.AtExpr {
-			dest := c.cg_allocate_var(name, 8, i64(0))
+			dest := c.cg_allocate_stack_var(name, 8, i64(0))
 			c.learel(.rsi, c.g.allocate_string(c.g.comptime_at(right), 3, .rel32))
 			c.mov_reg_to_var(LocalVar{dest, ast.u64_type_idx, name}, .rsi)
 		}
@@ -2814,7 +2816,7 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 	/*
 	ast.IndexExpr {
 			// a := arr[0]
-			offset := c.cg_allocate_var(name, c.g.get_sizeof_ident(ident), 0)
+			offset := c.cg_allocate_stack_var(name, c.g.get_sizeof_ident(ident), 0)
 			if c.g.pref.is_verbose {
 				println('infix assignment ${name} offset=${offset.hex2()}')
 			}
@@ -2843,43 +2845,6 @@ fn (mut c Amd64) assign_ident_right_expr(node ast.AssignStmt, i i32, right ast.E
 	}*/
 }
 
-fn (mut c Amd64) cg_gen_index_expr(node ast.IndexExpr) {
-	if node.left_type.is_string() {
-		c.g.expr(node.index)
-		c.push(.rax)
-
-		c.g.expr(node.left) // load address of string struct
-		c.mov_deref(.rax, .rax, ast.u64_type_idx) // load value of the str pointer
-
-		c.pop(.rdx) // index
-		c.add_reg(.rax, .rdx) // add the offset to the address
-	} else if node.left_type.is_any_kind_of_pointer() {
-		// load the pointer
-		c.g.expr(node.left)
-		c.mov_reg(.rcx, .rax)
-		// add the index times the size (bytes) of the type
-		c.g.expr(node.index)
-		c.mov(.rbx, i32(c.g.get_type_size(node.typ)))
-		c.mul_reg_rax(.rbx)
-		c.add_reg(.rax, .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(.rax, offset)
-		}
-		c.mov_deref(.rcx, .rax, ast.u64_type)
-		// add the index times the size (bytes) of the type
-		c.g.expr(node.index)
-		c.mov(.rbx, i32(c.g.get_type_size(node.typ)))
-		c.mul_reg_rax(.rbx)
-		c.add_reg(.rax, .rcx)
-	} else {
-		c.g.n_error('${@LOCATION} index expr: unhandled node type {node}')
-	}
-}
-
 // /!\ for div, mul, mod the left value should always be .rax
 fn (mut c Amd64) apply_op_int(left_value Amd64Register, right_value Amd64Register, op token.Kind) {
 	match op {
@@ -4044,7 +4009,7 @@ fn (mut c Amd64) cg_fn_decl(node ast.FnDecl) {
 	// define defer vars
 	for i in 0 .. node.defer_stmts.len {
 		name := '_defer${i}'
-		c.cg_allocate_var(name, 8, i64(0))
+		c.cg_allocate_stack_var(name, 8, i64(0))
 	}
 	// body
 	c.g.stmts(node.stmts)
@@ -4084,14 +4049,14 @@ pub fn (mut c Amd64) cg_builtin_decl(builtin BuiltinFn) {
 	c.cg_leave()
 }
 
-pub fn (mut c Amd64) allocate_var_two_step(name string, size i32, initial_val Number) i32 {
-	c.cg_allocate_var(name, size - 8, i64(0))
-	return c.cg_allocate_var(name, 8, initial_val)
+pub fn (mut c Amd64) allocate_stack_var_two_step(name string, size i32, initial_val Number) i32 {
+	c.cg_allocate_stack_var(name, size - 8, i64(0))
+	return c.cg_allocate_stack_var(name, 8, initial_val)
 }
 
-pub fn (mut c Amd64) cg_allocate_var(name string, size i32, initial_val Number) i32 {
+pub fn (mut c Amd64) cg_allocate_stack_var(name string, size i32, initial_val Number) i32 {
 	if size > 8 {
-		return c.allocate_var_two_step(name, size, initial_val)
+		return c.allocate_stack_var_two_step(name, size, initial_val)
 	}
 
 	padding := (size - c.g.stack_var_pos % size) % size
@@ -4605,6 +4570,7 @@ fn (mut c Amd64) cg_gen_match_expr(expr ast.MatchExpr) {
 			for cond in branch.exprs {
 				match cond {
 					ast.RangeExpr {
+						// TODO: clean up
 						c.pop(.rdx)
 						c.g.expr(cond.low)
 						c.cmp_reg(.rax, .rdx)
@@ -5084,16 +5050,6 @@ fn (mut c Amd64) cg_gen_cast_expr(expr ast.CastExpr) {
 	}
 }
 
-fn (mut c Amd64) cg_cmp_to_stack_top(reg Register) {
-	second_reg := if reg.amd64() == Amd64Register.rbx {
-		Amd64Register.rax
-	} else {
-		Amd64Register.rbx
-	}
-	c.pop(second_reg)
-	c.cmp_reg(second_reg, reg.amd64())
-}
-
 // Temporary!
 fn (mut c Amd64) adr(r Arm64Register, delta i32) {
 	c.g.n_error('`adr` instruction not supported with amd64')

vlib/v/gen/native/arm64.v

@@ -54,7 +54,7 @@ mut:
 	// arm64 specific stuff for code generation
 }
 
-fn (mut x Arm64) cg_allocate_var(name string, size i32, initial_val Number) i32 {
+fn (mut x Arm64) cg_allocate_stack_var(name string, size i32, initial_val Number) i32 {
 	eprintln('TODO: allocating var on arm64 (${name}) = ${size} = ${initial_val}')
 	return 0
 }
@@ -522,10 +522,6 @@ fn (mut c Arm64) cg_call_addr_at(addr i32, at i64) i64 {
 	panic('Arm64.cg_call_addr_at() not implemented')
 }
 
-fn (mut c Arm64) cg_cmp_to_stack_top(reg Register) {
-	panic('Arm64.cg_cmp_to_stack_top() not implemented')
-}
-
 fn (mut c Arm64) cg_push(r Register) {
 	panic('Arm64.cg_push() not implemented')
 }
@@ -561,7 +557,3 @@ 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_gen_index_expr(node ast.IndexExpr) {
-	panic('Arm64.cg_gen_index_expr{) not implemented')
-}

vlib/v/gen/native/array.v

@@ -7,7 +7,7 @@ module native
 import v.ast
 
 fn (mut g Gen) allocate_raw_array(name string, size i32, items i32) i32 {
-	pos := g.cg.cg_allocate_var(name, size, items)
+	pos := g.cg.cg_allocate_stack_var(name, size, items)
 	g.stack_var_pos += (size * items)
 	return pos
 }

vlib/v/gen/native/expr.v

@@ -150,7 +150,7 @@ fn (mut g Gen) expr(node ast.Expr) {
 			g.gen_sizeof_expr(node)
 		}
 		ast.IndexExpr {
-			g.cg.cg_gen_index_expr(node)
+			g.gen_index_expr(node)
 			if node.left_type.is_string() {
 				g.cg.cg_mov_deref(.reg0, .reg0, ast.u8_type_idx)
 			} else {
@@ -556,7 +556,7 @@ fn (mut g Gen) gen_left_value(node ast.Expr) {
 			g.expr(node) // TODO: add a test that uses this
 		}
 		ast.IndexExpr {
-			g.cg.cg_gen_index_expr(node)
+			g.gen_index_expr(node)
 		}
 		ast.PrefixExpr {
 			if node.op != .mul {
@@ -569,3 +569,40 @@ fn (mut g Gen) gen_left_value(node ast.Expr) {
 		}
 	}
 }
+
+fn (mut g Gen) gen_index_expr(node ast.IndexExpr) {
+	if node.left_type.is_string() {
+		g.expr(node.index)
+		g.cg.cg_push(.reg0)
+
+		g.expr(node.left) // load address of string struct
+		g.cg.cg_mov_deref(.reg0, .reg0, ast.u64_type_idx) // load value of the str pointer
+
+		g.cg.cg_pop(.reg2) // index
+		g.cg.cg_add_reg(.reg0, .reg2) // add the offset to the address
+	} else if node.left_type.is_any_kind_of_pointer() {
+		// load the pointer
+		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 if node.is_array {
+		// TODO: use functions from builtin instead (array.set, array.get...)
+		g.expr(node.left)
+		offset := g.get_field_offset(ast.array_type, 'data')
+		if offset != 0 {
+			g.cg.cg_add(.reg0, offset)
+		}
+		g.cg.cg_mov_deref(.reg1, .reg0, ast.u64_type)
+		// 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

@@ -97,15 +97,14 @@ mut:
 	cg_add(r Register, val i32)
 	cg_add_reg(r Register, r2 Register)
 	cg_address_size() i32
-	cg_allocate_var(name string, size i32, initial_val Number) i32
+	cg_allocate_stack_var(name string, size i32, initial_val Number) i32
 	cg_assign_stmt(node ast.AssignStmt)
 	cg_builtin_decl(builtin BuiltinFn)
 	cg_call_addr_at(addr i32, at i64) i64
 	cg_call_builtin(name Builtin) i64
 	cg_call_fn(node ast.CallExpr)
 	cg_call(addr i32) i64
 	cg_cjmp(op JumpOp) i32
-	cg_cmp_to_stack_top(r Register)
 	cg_cmp_var_reg(var Var, reg Register, config VarConfig)
 	cg_cmp_var(var Var, val i32, config VarConfig)
 	cg_cmp_reg(reg Register, reg2 Register)
@@ -119,7 +118,6 @@ mut:
 	cg_gen_asm_stmt(asm_node ast.AsmStmt)
 	cg_gen_cast_expr(expr ast.CastExpr)
 	cg_gen_exit(expr ast.Expr)
-	cg_gen_index_expr(ast.IndexExpr)
 	cg_gen_match_expr(expr ast.MatchExpr)
 	cg_gen_print_reg(r Register, n i32, fd i32)
 	cg_gen_print(s string, fd i32)
@@ -1046,7 +1044,7 @@ 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 {
 	g.println('; allocate array `${name}` item-size:${size} items:${items}:')
-	pos := g.cg.cg_allocate_var(name, 4, i64(items)) // store the length of the array on the stack in a 4 byte var
+	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
 }
@@ -1167,7 +1165,7 @@ fn (mut g Gen) gen_var_to_string(reg Register, expr ast.Expr, var Var, config Va
 	g.println('; var_to_string {')
 	typ := g.get_type_from_var(var)
 	if typ == ast.rune_type_idx {
-		buffer := g.cg.cg_allocate_var('rune-buffer', 8, i64(0))
+		buffer := g.cg.cg_allocate_stack_var('rune-buffer', 8, i64(0))
 		g.cg.cg_convert_rune_to_string(reg, buffer, var, config)
 	} else if typ.is_int() {
 		if typ.is_unsigned() {
@@ -1437,3 +1435,13 @@ pub fn escape_string(s string) string {
 	}
 	return out.bytestr()
 }
+
+fn (mut g Gen) cmp_to_stack_top(reg Register) {
+	second_reg := if reg == .reg3 {
+		Register.reg0
+	} else {
+		Register.reg3
+	}
+	g.cg.cg_pop(second_reg)
+	g.cg.cg_cmp_reg(second_reg, reg)
+}

vlib/v/gen/native/stmt.c.v

@@ -266,7 +266,7 @@ fn (mut g Gen) for_in_stmt(node ast.ForInStmt) { // Work on that
 		g.println('; for ${node.val_var} in range {')
 		// for a in node.cond .. node.high {
 
-		i := g.cg.cg_allocate_var(node.val_var, 8, i64(0)) // iterator variable
+		i := g.cg.cg_allocate_stack_var(node.val_var, 8, i64(0)) // iterator variable
 		g.println('; evaluate node.cond for lower bound:')
 		g.expr(node.cond) // outputs the lower loop bound (initial value) to the main reg
 		g.println('; move the result to i')
@@ -278,7 +278,7 @@ fn (mut g Gen) for_in_stmt(node ast.ForInStmt) { // Work on that
 		g.cg.cg_mov_var_to_reg(.reg0, LocalVar{i, ast.i64_type_idx, node.val_var})
 		g.cg.cg_push(.reg0) // put the iterator on the stack
 		g.expr(node.high) // final value (upper bound) to the main reg
-		g.cg.cg_cmp_to_stack_top(.reg0)
+		g.cmp_to_stack_top(.reg0)
 		jump_addr := g.cg.cg_cjmp(.jge) // leave loop i >= upper bound
 		end_label := g.labels.new_label()
 		g.labels.patches << LabelPatch{
@@ -310,8 +310,8 @@ fn (mut g Gen) for_in_stmt(node ast.ForInStmt) { // Work on that
 		// for c in my_string {
 
 		key_var := if node.key_var == '' { 'i' } else { node.key_var }
-		i := g.cg.cg_allocate_var(key_var, 8, i64(0)) // iterator variable
-		c := g.cg.cg_allocate_var(node.val_var, 1, i64(0)) // char variable
+		i := g.cg.cg_allocate_stack_var(key_var, 8, i64(0)) // iterator variable
+		c := g.cg.cg_allocate_stack_var(node.val_var, 1, i64(0)) // char variable
 
 		g.expr(node.cond) // get the address of the string variable
 		g.cg.cg_mov_deref(.reg2, .reg0, ast.charptr_type)