Add simd_extract and simd_insert

src/check_builtin.cpp

@@ -425,14 +425,9 @@ bool check_builtin_simd_operation(CheckerContext *c, Operand *operand, Ast *call
 		{
 			Operand x = {};
 			Operand y = {};
-			check_expr(c, &x, ce->args[0]);
+			check_expr(c, &x, ce->args[0]); if (x.mode == Addressing_Invalid) { return false; }
-			check_expr(c, &y, ce->args[1]);
+			check_expr_with_type_hint(c, &y, ce->args[1], x.type); if (y.mode == Addressing_Invalid) { return false; }
-			if (x.mode == Addressing_Invalid) {
+			convert_to_typed(c, &y, x.type);
-				return false;
-			}
-			if (y.mode == Addressing_Invalid) {
-				return false;
-			}
 			if (!is_type_simd_vector(x.type)) {
 				error(x.expr, "'%.*s' expected a simd vector type", LIT(builtin_name));
 				return false;
@@ -470,14 +465,9 @@ bool check_builtin_simd_operation(CheckerContext *c, Operand *operand, Ast *call
 		{
 			Operand x = {};
 			Operand y = {};
-			check_expr(c, &x, ce->args[0]);
+			check_expr(c, &x, ce->args[0]); if (x.mode == Addressing_Invalid) { return false; }
-			check_expr(c, &y, ce->args[1]);
+			check_expr_with_type_hint(c, &y, ce->args[1], x.type); if (y.mode == Addressing_Invalid) { return false; }
-			if (x.mode == Addressing_Invalid) {
+			convert_to_typed(c, &y, x.type);
-				return false;
-			}
-			if (y.mode == Addressing_Invalid) {
-				return false;
-			}
 			if (!is_type_simd_vector(x.type)) {
 				error(x.expr, "'%.*s' expected a simd vector type", LIT(builtin_name));
 				return false;
@@ -514,14 +504,9 @@ bool check_builtin_simd_operation(CheckerContext *c, Operand *operand, Ast *call
 		{
 			Operand x = {};
 			Operand y = {};
-			check_expr(c, &x, ce->args[0]);
+			check_expr(c, &x, ce->args[0]); if (x.mode == Addressing_Invalid) { return false; }
-			check_expr(c, &y, ce->args[1]);
+			check_expr_with_type_hint(c, &y, ce->args[1], x.type); if (y.mode == Addressing_Invalid) { return false; }
-			if (x.mode == Addressing_Invalid) {
+			convert_to_typed(c, &y, x.type);
-				return false;
-			}
-			if (y.mode == Addressing_Invalid) {
-				return false;
-			}
 			if (!is_type_simd_vector(x.type)) {
 				error(x.expr, "'%.*s' expected a simd vector type", LIT(builtin_name));
 				return false;
@@ -599,14 +584,9 @@ bool check_builtin_simd_operation(CheckerContext *c, Operand *operand, Ast *call
 
 			Operand x = {};
 			Operand y = {};
-			check_expr(c, &x, ce->args[0]);
+			check_expr(c, &x, ce->args[0]); if (x.mode == Addressing_Invalid) { return false; }
-			check_expr(c, &y, ce->args[1]);
+			check_expr_with_type_hint(c, &y, ce->args[1], x.type); if (y.mode == Addressing_Invalid) { return false; }
-			if (x.mode == Addressing_Invalid) {
+			convert_to_typed(c, &y, x.type);
-				return false;
-			}
-			if (y.mode == Addressing_Invalid) {
-				return false;
-			}
 			if (!is_type_simd_vector(x.type)) {
 				error(x.expr, "'%.*s' expected a simd vector type", LIT(builtin_name));
 				return false;
@@ -639,6 +619,81 @@ bool check_builtin_simd_operation(CheckerContext *c, Operand *operand, Ast *call
 			operand->type = alloc_type_simd_vector(count, new_elem);
 			return true;
 		}
+
+	case BuiltinProc_simd_extract:
+		{
+			Operand x = {};
+			check_expr(c, &x, ce->args[0]); if (x.mode == Addressing_Invalid) { return false; }
+
+			if (!is_type_simd_vector(x.type)) {
+				error(x.expr, "'%.*s' expected a simd vector type", LIT(builtin_name));
+				return false;
+			}
+			Type *elem = base_array_type(x.type);
+			if (!is_type_integer(elem) && !is_type_float(elem)) {
+				gbString xs = type_to_string(x.type);
+				error(x.expr, "'%.*s' expected a #simd type with an integer or floating-point element, got '%s'", LIT(builtin_name), xs);
+				gb_string_free(xs);
+				return false;
+			}
+			i64 max_count = x.type->SimdVector.count;
+			i64 value = -1;
+			if (!check_index_value(c, x.type, false, ce->args[1], max_count, &value)) {
+				return false;
+			}
+			if (max_count < 0) {
+				error(ce->args[1], "'%.*s' expected a constant integer index, got '%lld'", LIT(builtin_name), cast(long long)value);
+				return false;
+			}
+
+			operand->mode = Addressing_Value;
+			operand->type = elem;
+			return true;
+		}
+		break;
+	case BuiltinProc_simd_insert:
+		{
+			Operand x = {};
+			check_expr(c, &x, ce->args[0]); if (x.mode == Addressing_Invalid) { return false; }
+
+			if (!is_type_simd_vector(x.type)) {
+				error(x.expr, "'%.*s' expected a simd vector type", LIT(builtin_name));
+				return false;
+			}
+			Type *elem = base_array_type(x.type);
+			if (!is_type_integer(elem) && !is_type_float(elem)) {
+				gbString xs = type_to_string(x.type);
+				error(x.expr, "'%.*s' expected a #simd type with an integer or floating-point element, got '%s'", LIT(builtin_name), xs);
+				gb_string_free(xs);
+				return false;
+			}
+			i64 max_count = x.type->SimdVector.count;
+			i64 value = -1;
+			if (!check_index_value(c, x.type, false, ce->args[1], max_count, &value)) {
+				return false;
+			}
+			if (max_count < 0) {
+				error(ce->args[1], "'%.*s' expected a constant integer index, got '%lld'", LIT(builtin_name), cast(long long)value);
+				return false;
+			}
+
+			Operand y = {};
+			check_expr_with_type_hint(c, &y, ce->args[2], elem); if (y.mode == Addressing_Invalid) { return false; }
+			convert_to_typed(c, &y, elem);
+			if (!are_types_identical(y.type, elem)) {
+				gbString et = type_to_string(elem);
+				gbString yt = type_to_string(y.type);
+				error(y.expr, "'%.*s' expected a type of '%s' to insert, got '%s'", LIT(builtin_name), et, yt);
+				gb_string_free(yt);
+				gb_string_free(et);
+				return false;
+			}
+
+			operand->mode = Addressing_Value;
+			operand->type = x.type;
+			return true;
+		}
+		break;
 	default:
 		GB_PANIC("Unhandled simd intrinsic: %.*s", LIT(builtin_name));
 	}
@@ -736,6 +791,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 		}
 		operand->mode = Addressing_Value;
 		operand->value = {};
+		operand->expr = call;
 		return ok;
 	}
 

src/checker_builtin_procs.hpp

@@ -146,6 +146,9 @@ BuiltinProc__simd_begin,
 	BuiltinProc_simd_le,
 	BuiltinProc_simd_gt,
 	BuiltinProc_simd_ge,
+
+	BuiltinProc_simd_extract,
+	BuiltinProc_simd_insert,
 BuiltinProc__simd_end,
 	
 	// Platform specific intrinsics
@@ -395,6 +398,9 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 	{STR_LIT("simd_le"),  2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("simd_gt"),  2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("simd_ge"),  2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
+
+	{STR_LIT("simd_extract"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
+	{STR_LIT("simd_insert"),  3, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT(""), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics},
 
 

src/llvm_backend_proc.cpp

@@ -991,6 +991,7 @@ lbValue lb_build_builtin_simd_proc(lbProcedure *p, Ast *expr, TypeAndValue const
 
 	lbValue arg0 = lb_build_expr(p, ce->args[0]);
 	lbValue arg1 = {};
+	lbValue arg2 = {};
 
 	Type *elem = base_array_type(arg0.type);
 
@@ -1173,6 +1174,16 @@ lbValue lb_build_builtin_simd_proc(lbProcedure *p, Ast *expr, TypeAndValue const
 			}
 		}
 		break;
+
+	case BuiltinProc_simd_extract:
+		arg1 = lb_build_expr(p, ce->args[1]);
+		res.value = LLVMBuildExtractElement(p->builder, arg0.value, arg1.value, "");
+		return res;
+	case BuiltinProc_simd_insert:
+		arg1 = lb_build_expr(p, ce->args[1]);
+		arg2 = lb_build_expr(p, ce->args[2]);
+		res.value = LLVMBuildInsertElement(p->builder, arg0.value, arg2.value, arg1.value, "");
+		return res;
 	}
 	GB_PANIC("Unhandled simd intrinsic: '%.*s'", LIT(builtin_procs[id].name));
 	return {};