From d9e81c6035f9f7e14fbf0a495b2f773c1dcf3c05 Mon Sep 17 00:00:00 2001
From: Dmitry Atamanov <dataman@tutanota.com>
Date: Sat, 29 Oct 2022 19:23:49 +0500
Subject: [PATCH] Fix vector slices assignment

---
 src/compiler/llvm_codegen_expr.c              |   6 +-
 .../slices/slice_to_slice_vector_assign.c3t   | 292 ++++++++++++++++++
 .../slices/slice_to_slice_vector_assign.c3t   | 261 ++++++++++++++++
 3 files changed, 557 insertions(+), 2 deletions(-)
 create mode 100644 test/test_suite/slices/slice_to_slice_vector_assign.c3t
 create mode 100644 test/test_suite2/slices/slice_to_slice_vector_assign.c3t

diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c
index 7064eed98..959afc9c8 100644
--- a/src/compiler/llvm_codegen_expr.c
+++ b/src/compiler/llvm_codegen_expr.c
@@ -2498,6 +2498,7 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
 			break;
 		case TYPE_FLEXIBLE_ARRAY:
 		case TYPE_ARRAY:
+		case TYPE_VECTOR:
 			parent_base = parent_addr;
 			break;
 		default:
@@ -2528,6 +2529,7 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
 				llvm_value_set(&len, llvm_emit_extract_value(c, parent_load_value, 1), type_usize);
 				break;
 			case TYPE_ARRAY:
+			case TYPE_VECTOR:
 				llvm_value_set_int(c, &len, type_usize, parent_type->array.len);
 				break;
 			default:
@@ -2631,8 +2633,9 @@ static void gencontext_emit_slice(GenContext *c, BEValue *be_value, Expr *expr)
 	Type *type = type_lowering(parent.type);
 	switch (type->type_kind)
 	{
-		case TYPE_ARRAY:
 		case TYPE_FLEXIBLE_ARRAY:
+		case TYPE_ARRAY:
+		case TYPE_VECTOR:
 		{
 			// Move pointer
 			AlignSize alignment;
@@ -2646,7 +2649,6 @@ static void gencontext_emit_slice(GenContext *c, BEValue *be_value, Expr *expr)
 		case TYPE_POINTER:
 			start_pointer = llvm_emit_pointer_inbounds_gep_raw(c, llvm_get_pointee_type(c, parent.type), parent.value, start.value);
 			break;
-		case TYPE_VECTOR:
 			TODO
 		default:
 			UNREACHABLE
diff --git a/test/test_suite/slices/slice_to_slice_vector_assign.c3t b/test/test_suite/slices/slice_to_slice_vector_assign.c3t
new file mode 100644
index 000000000..2db09a602
--- /dev/null
+++ b/test/test_suite/slices/slice_to_slice_vector_assign.c3t
@@ -0,0 +1,292 @@
+// #target: macos-x64
+module test;
+import std::io;
+
+fn void main()
+{
+	int[<*>] z = { 1, 2, 3, 4, 5, 6, 7 };
+	int[<6>] y;
+	y[1..3] = z[3..5];
+	io::printfln("%s %s", y, z);
+	y[4..] = z[5..6];
+	io::printfln("%s %s", y, z);
+	int[][] a = { int[] { 1 } };
+	int[][] b = { int[] { 2 } };
+	io::printfln("%s", a);
+	a[0..0] = b[0..0];
+	io::printfln("%s", a);
+	a[0..0] = y[2..4];
+	io::printfln("%s", a);
+}
+/* #expect: test.ll
+
+define void @test_main() #0 {
+entry:
+  %z = alloca <7 x i32>, align 32
+  %y = alloca <6 x i32>, align 32
+  %taddr = alloca %"int[]", align 8
+  %retparam = alloca i64, align 8
+  %taddr1 = alloca %"char[]", align 8
+  %vararg = alloca %"variant[]", align 8
+  %varargslots = alloca [2 x %variant], align 16
+  %taddr4 = alloca %"int[]", align 8
+  %retparam5 = alloca i64, align 8
+  %taddr6 = alloca %"char[]", align 8
+  %vararg9 = alloca %"variant[]", align 8
+  %varargslots10 = alloca [2 x %variant], align 16
+  %a = alloca %"int[][]", align 8
+  %literal = alloca [1 x %"int[]"], align 16
+  %literal16 = alloca [1 x i32], align 4
+  %b = alloca %"int[][]", align 8
+  %literal17 = alloca [1 x %"int[]"], align 16
+  %literal18 = alloca [1 x i32], align 4
+  %retparam19 = alloca i64, align 8
+  %taddr20 = alloca %"char[]", align 8
+  %vararg23 = alloca %"variant[]", align 8
+  %varargslots24 = alloca [1 x %variant], align 16
+  %taddr31 = alloca %"int[][]", align 8
+  %retparam32 = alloca i64, align 8
+  %taddr33 = alloca %"char[]", align 8
+  %vararg36 = alloca %"variant[]", align 8
+  %varargslots37 = alloca [1 x %variant], align 16
+  %retparam44 = alloca i64, align 8
+  %taddr45 = alloca %"char[]", align 8
+  %vararg48 = alloca %"variant[]", align 8
+  %varargslots49 = alloca [1 x %variant], align 16
+  store <7 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>, <7 x i32>* %z, align 32
+  store <6 x i32> zeroinitializer, <6 x i32>* %y, align 32
+  %0 = getelementptr inbounds <7 x i32>, <7 x i32>* %z, i64 0, i64 3
+  %1 = insertvalue %"int[]" undef, i32* %0, 0
+  %2 = insertvalue %"int[]" %1, i64 3, 1
+  %3 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 1
+  %4 = insertvalue %"int[]" undef, i32* %3, 0
+  %5 = insertvalue %"int[]" %4, i64 3, 1
+  %6 = extractvalue %"int[]" %5, 0
+  %7 = extractvalue %"int[]" %2, 0
+  store %"int[]" %2, %"int[]"* %taddr, align 8
+  %8 = getelementptr inbounds %"int[]", %"int[]"* %taddr, i32 0, i32 1
+  %9 = load i64, i64* %8, align 8
+  %10 = mul i64 %9, 4
+  %11 = bitcast i32* %6 to i8*
+  %12 = bitcast i32* %7 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %11, i8* align 4 %12, i64 %10, i1 false)
+  store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 5 }, %"char[]"* %taddr1, align 8
+  %13 = bitcast %"char[]"* %taddr1 to { i8*, i64 }*
+  %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 0
+  %lo = load i8*, i8** %14, align 8
+  %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %13, i32 0, i32 1
+  %hi = load i64, i64* %15, align 8
+  %16 = bitcast <6 x i32>* %y to i8*
+  %17 = insertvalue %variant undef, i8* %16, 0
+  %18 = insertvalue %variant %17, i64 ptrtoint (%.introspect* @"ct$v6$int" to i64), 1
+  %19 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0
+  store %variant %18, %variant* %19, align 16
+  %20 = bitcast <7 x i32>* %z to i8*
+  %21 = insertvalue %variant undef, i8* %20, 0
+  %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$v7$int" to i64), 1
+  %23 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1
+  store %variant %22, %variant* %23, align 16
+  %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
+  store i64 2, i64* %24, align 8
+  %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
+  %26 = bitcast [2 x %variant]* %varargslots to %variant*
+  store %variant* %26, %variant** %25, align 8
+  %27 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
+  %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0
+  %lo2 = load i8*, i8** %28, align 8
+  %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1
+  %hi3 = load i64, i64* %29, align 8
+  %30 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3)
+  %not_err = icmp eq i64 %30, 0
+  br i1 %not_err, label %after_check, label %voiderr
+
+after_check:                                      ; preds = %entry
+  br label %voiderr
+
+voiderr:                                          ; preds = %after_check, %entry
+  %31 = getelementptr inbounds <7 x i32>, <7 x i32>* %z, i64 0, i64 5
+  %32 = insertvalue %"int[]" undef, i32* %31, 0
+  %33 = insertvalue %"int[]" %32, i64 2, 1
+  %34 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 4
+  %35 = insertvalue %"int[]" undef, i32* %34, 0
+  %36 = insertvalue %"int[]" %35, i64 2, 1
+  %37 = extractvalue %"int[]" %36, 0
+  %38 = extractvalue %"int[]" %33, 0
+  store %"int[]" %33, %"int[]"* %taddr4, align 8
+  %39 = getelementptr inbounds %"int[]", %"int[]"* %taddr4, i32 0, i32 1
+  %40 = load i64, i64* %39, align 8
+  %41 = mul i64 %40, 4
+  %42 = bitcast i32* %37 to i8*
+  %43 = bitcast i32* %38 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %42, i8* align 4 %43, i64 %41, i1 false)
+  store %"char[]" { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i64 5 }, %"char[]"* %taddr6, align 8
+  %44 = bitcast %"char[]"* %taddr6 to { i8*, i64 }*
+  %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0
+  %lo7 = load i8*, i8** %45, align 8
+  %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1
+  %hi8 = load i64, i64* %46, align 8
+  %47 = bitcast <6 x i32>* %y to i8*
+  %48 = insertvalue %variant undef, i8* %47, 0
+  %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$v6$int" to i64), 1
+  %50 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots10, i64 0, i64 0
+  store %variant %49, %variant* %50, align 16
+  %51 = bitcast <7 x i32>* %z to i8*
+  %52 = insertvalue %variant undef, i8* %51, 0
+  %53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$v7$int" to i64), 1
+  %54 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots10, i64 0, i64 1
+  store %variant %53, %variant* %54, align 16
+  %55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1
+  store i64 2, i64* %55, align 8
+  %56 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0
+  %57 = bitcast [2 x %variant]* %varargslots10 to %variant*
+  store %variant* %57, %variant** %56, align 8
+  %58 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }*
+  %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0
+  %lo11 = load i8*, i8** %59, align 8
+  %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1
+  %hi12 = load i64, i64* %60, align 8
+  %61 = call i64 @std_io_printfln(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12)
+  %not_err13 = icmp eq i64 %61, 0
+  br i1 %not_err13, label %after_check14, label %voiderr15
+
+after_check14:                                    ; preds = %voiderr
+  br label %voiderr15
+
+voiderr15:                                        ; preds = %after_check14, %voiderr
+  %62 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal, i64 0, i64 0
+  %63 = getelementptr inbounds [1 x i32], [1 x i32]* %literal16, i64 0, i64 0
+  store i32 1, i32* %63, align 4
+  %64 = bitcast [1 x i32]* %literal16 to i32*
+  %65 = insertvalue %"int[]" undef, i32* %64, 0
+  %66 = insertvalue %"int[]" %65, i64 1, 1
+  store %"int[]" %66, %"int[]"* %62, align 8
+  %67 = bitcast [1 x %"int[]"]* %literal to %"int[]"*
+  %68 = insertvalue %"int[][]" undef, %"int[]"* %67, 0
+  %69 = insertvalue %"int[][]" %68, i64 1, 1
+  store %"int[][]" %69, %"int[][]"* %a, align 8
+  %70 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %literal17, i64 0, i64 0
+  %71 = getelementptr inbounds [1 x i32], [1 x i32]* %literal18, i64 0, i64 0
+  store i32 2, i32* %71, align 4
+  %72 = bitcast [1 x i32]* %literal18 to i32*
+  %73 = insertvalue %"int[]" undef, i32* %72, 0
+  %74 = insertvalue %"int[]" %73, i64 1, 1
+  store %"int[]" %74, %"int[]"* %70, align 8
+  %75 = bitcast [1 x %"int[]"]* %literal17 to %"int[]"*
+  %76 = insertvalue %"int[][]" undef, %"int[]"* %75, 0
+  %77 = insertvalue %"int[][]" %76, i64 1, 1
+  store %"int[][]" %77, %"int[][]"* %b, align 8
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i64 2 }, %"char[]"* %taddr20, align 8
+  %78 = bitcast %"char[]"* %taddr20 to { i8*, i64 }*
+  %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 0
+  %lo21 = load i8*, i8** %79, align 8
+  %80 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %78, i32 0, i32 1
+  %hi22 = load i64, i64* %80, align 8
+  %81 = bitcast %"int[][]"* %a to i8*
+  %82 = insertvalue %variant undef, i8* %81, 0
+  %83 = insertvalue %variant %82, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1
+  %84 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0
+  store %variant %83, %variant* %84, align 16
+  %85 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1
+  store i64 1, i64* %85, align 8
+  %86 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0
+  %87 = bitcast [1 x %variant]* %varargslots24 to %variant*
+  store %variant* %87, %variant** %86, align 8
+  %88 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }*
+  %89 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 0
+  %lo25 = load i8*, i8** %89, align 8
+  %90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %88, i32 0, i32 1
+  %hi26 = load i64, i64* %90, align 8
+  %91 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26)
+  %not_err27 = icmp eq i64 %91, 0
+  br i1 %not_err27, label %after_check28, label %voiderr29
+
+after_check28:                                    ; preds = %voiderr15
+  br label %voiderr29
+
+voiderr29:                                        ; preds = %after_check28, %voiderr15
+  %92 = load %"int[][]", %"int[][]"* %b, align 8
+  %93 = extractvalue %"int[][]" %92, 0
+  %ptroffset = getelementptr inbounds %"int[]", %"int[]"* %93, i64 0
+  %94 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset, 0
+  %95 = insertvalue %"int[][]" %94, i64 1, 1
+  %96 = load %"int[][]", %"int[][]"* %a, align 8
+  %97 = extractvalue %"int[][]" %96, 0
+  %ptroffset30 = getelementptr inbounds %"int[]", %"int[]"* %97, i64 0
+  %98 = insertvalue %"int[][]" undef, %"int[]"* %ptroffset30, 0
+  %99 = insertvalue %"int[][]" %98, i64 1, 1
+  %100 = extractvalue %"int[][]" %99, 0
+  %101 = extractvalue %"int[][]" %95, 0
+  store %"int[][]" %95, %"int[][]"* %taddr31, align 8
+  %102 = getelementptr inbounds %"int[][]", %"int[][]"* %taddr31, i32 0, i32 1
+  %103 = load i64, i64* %102, align 8
+  %104 = mul i64 %103, 16
+  %105 = bitcast %"int[]"* %100 to i8*
+  %106 = bitcast %"int[]"* %101 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %105, i8* align 8 %106, i64 %104, i1 false)
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2 }, %"char[]"* %taddr33, align 8
+  %107 = bitcast %"char[]"* %taddr33 to { i8*, i64 }*
+  %108 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %107, i32 0, i32 0
+  %lo34 = load i8*, i8** %108, align 8
+  %109 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %107, i32 0, i32 1
+  %hi35 = load i64, i64* %109, align 8
+  %110 = bitcast %"int[][]"* %a to i8*
+  %111 = insertvalue %variant undef, i8* %110, 0
+  %112 = insertvalue %variant %111, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1
+  %113 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots37, i64 0, i64 0
+  store %variant %112, %variant* %113, align 16
+  %114 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg36, i32 0, i32 1
+  store i64 1, i64* %114, align 8
+  %115 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg36, i32 0, i32 0
+  %116 = bitcast [1 x %variant]* %varargslots37 to %variant*
+  store %variant* %116, %variant** %115, align 8
+  %117 = bitcast %"variant[]"* %vararg36 to { i8*, i64 }*
+  %118 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %117, i32 0, i32 0
+  %lo38 = load i8*, i8** %118, align 8
+  %119 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %117, i32 0, i32 1
+  %hi39 = load i64, i64* %119, align 8
+  %120 = call i64 @std_io_printfln(i64* %retparam32, i8* %lo34, i64 %hi35, i8* %lo38, i64 %hi39)
+  %not_err40 = icmp eq i64 %120, 0
+  br i1 %not_err40, label %after_check41, label %voiderr42
+
+after_check41:                                    ; preds = %voiderr29
+  br label %voiderr42
+
+voiderr42:                                        ; preds = %after_check41, %voiderr29
+  %121 = getelementptr inbounds <6 x i32>, <6 x i32>* %y, i64 0, i64 2
+  %122 = insertvalue %"int[]" undef, i32* %121, 0
+  %123 = insertvalue %"int[]" %122, i64 3, 1
+  %124 = load %"int[][]", %"int[][]"* %a, align 8
+  %125 = extractvalue %"int[][]" %124, 0
+  %ptroffset43 = getelementptr inbounds %"int[]", %"int[]"* %125, i64 0
+  store %"int[]" %123, %"int[]"* %ptroffset43, align 8
+  store %"char[]" { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2 }, %"char[]"* %taddr45, align 8
+  %126 = bitcast %"char[]"* %taddr45 to { i8*, i64 }*
+  %127 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %126, i32 0, i32 0
+  %lo46 = load i8*, i8** %127, align 8
+  %128 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %126, i32 0, i32 1
+  %hi47 = load i64, i64* %128, align 8
+  %129 = bitcast %"int[][]"* %a to i8*
+  %130 = insertvalue %variant undef, i8* %129, 0
+  %131 = insertvalue %variant %130, i64 ptrtoint (%.introspect* @"ct$sa$sa$int" to i64), 1
+  %132 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots49, i64 0, i64 0
+  store %variant %131, %variant* %132, align 16
+  %133 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 1
+  store i64 1, i64* %133, align 8
+  %134 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg48, i32 0, i32 0
+  %135 = bitcast [1 x %variant]* %varargslots49 to %variant*
+  store %variant* %135, %variant** %134, align 8
+  %136 = bitcast %"variant[]"* %vararg48 to { i8*, i64 }*
+  %137 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %136, i32 0, i32 0
+  %lo50 = load i8*, i8** %137, align 8
+  %138 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %136, i32 0, i32 1
+  %hi51 = load i64, i64* %138, align 8
+  %139 = call i64 @std_io_printfln(i64* %retparam44, i8* %lo46, i64 %hi47, i8* %lo50, i64 %hi51)
+  %not_err52 = icmp eq i64 %139, 0
+  br i1 %not_err52, label %after_check53, label %voiderr54
+
+after_check53:                                    ; preds = %voiderr42
+  br label %voiderr54
+
+voiderr54:                                        ; preds = %after_check53, %voiderr42
+  ret void
+}
diff --git a/test/test_suite2/slices/slice_to_slice_vector_assign.c3t b/test/test_suite2/slices/slice_to_slice_vector_assign.c3t
new file mode 100644
index 000000000..8683db6fa
--- /dev/null
+++ b/test/test_suite2/slices/slice_to_slice_vector_assign.c3t
@@ -0,0 +1,261 @@
+// #target: macos-x64
+module test;
+import std::io;
+
+fn void main()
+{
+	int[<*>] z = { 1, 2, 3, 4, 5, 6, 7 };
+	int[<6>] y;
+	y[1..3] = z[3..5];
+	io::printfln("%s %s", y, z);
+	y[4..] = z[5..6];
+	io::printfln("%s %s", y, z);
+	int[][] a = { int[] { 1 } };
+	int[][] b = { int[] { 2 } };
+	io::printfln("%s", a);
+	a[0..0] = b[0..0];
+	io::printfln("%s", a);
+	a[0..0] = y[2..4];
+	io::printfln("%s", a);
+}
+
+/* #expect: test.ll
+
+define void @test_main() #0 {
+entry:
+  %z = alloca <7 x i32>, align 32
+  %y = alloca <6 x i32>, align 32
+  %taddr = alloca %"int[]", align 8
+  %retparam = alloca i64, align 8
+  %taddr1 = alloca %"char[]", align 8
+  %vararg = alloca %"variant[]", align 8
+  %varargslots = alloca [2 x %variant], align 16
+  %taddr4 = alloca %"int[]", align 8
+  %retparam5 = alloca i64, align 8
+  %taddr6 = alloca %"char[]", align 8
+  %vararg9 = alloca %"variant[]", align 8
+  %varargslots10 = alloca [2 x %variant], align 16
+  %a = alloca %"int[][]", align 8
+  %literal = alloca [1 x %"int[]"], align 16
+  %literal16 = alloca [1 x i32], align 4
+  %b = alloca %"int[][]", align 8
+  %literal17 = alloca [1 x %"int[]"], align 16
+  %literal18 = alloca [1 x i32], align 4
+  %retparam19 = alloca i64, align 8
+  %taddr20 = alloca %"char[]", align 8
+  %vararg23 = alloca %"variant[]", align 8
+  %varargslots24 = alloca [1 x %variant], align 16
+  %taddr31 = alloca %"int[][]", align 8
+  %retparam32 = alloca i64, align 8
+  %taddr33 = alloca %"char[]", align 8
+  %vararg36 = alloca %"variant[]", align 8
+  %varargslots37 = alloca [1 x %variant], align 16
+  %retparam44 = alloca i64, align 8
+  %taddr45 = alloca %"char[]", align 8
+  %vararg48 = alloca %"variant[]", align 8
+  %varargslots49 = alloca [1 x %variant], align 16
+  store <7 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>, ptr %z, align 32
+  store <6 x i32> zeroinitializer, ptr %y, align 32
+  %0 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 3
+  %1 = insertvalue %"int[]" undef, ptr %0, 0
+  %2 = insertvalue %"int[]" %1, i64 3, 1
+  %3 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 1
+  %4 = insertvalue %"int[]" undef, ptr %3, 0
+  %5 = insertvalue %"int[]" %4, i64 3, 1
+  %6 = extractvalue %"int[]" %5, 0
+  %7 = extractvalue %"int[]" %2, 0
+  store %"int[]" %2, ptr %taddr, align 8
+  %8 = getelementptr inbounds %"int[]", ptr %taddr, i32 0, i32 1
+  %9 = load i64, ptr %8, align 8
+  %10 = mul i64 %9, 4
+  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %7, i64 %10, i1 false)
+  store %"char[]" { ptr @.str, i64 5 }, ptr %taddr1, align 8
+  %11 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 0
+  %lo = load ptr, ptr %11, align 8
+  %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr1, i32 0, i32 1
+  %hi = load i64, ptr %12, align 8
+  %13 = insertvalue %variant undef, ptr %y, 0
+  %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1
+  %15 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
+  store %variant %14, ptr %15, align 16
+  %16 = insertvalue %variant undef, ptr %z, 0
+  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1
+  %18 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
+  store %variant %17, ptr %18, align 16
+  %19 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  store i64 2, ptr %19, align 8
+  %20 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  store ptr %varargslots, ptr %20, align 8
+  %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %lo2 = load ptr, ptr %21, align 8
+  %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %hi3 = load i64, ptr %22, align 8
+  %23 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo2, i64 %hi3)
+  %not_err = icmp eq i64 %23, 0
+  br i1 %not_err, label %after_check, label %voiderr
+
+after_check:                                      ; preds = %entry
+  br label %voiderr
+
+voiderr:                                          ; preds = %after_check, %entry
+  %24 = getelementptr inbounds <7 x i32>, ptr %z, i64 0, i64 5
+  %25 = insertvalue %"int[]" undef, ptr %24, 0
+  %26 = insertvalue %"int[]" %25, i64 2, 1
+  %27 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 4
+  %28 = insertvalue %"int[]" undef, ptr %27, 0
+  %29 = insertvalue %"int[]" %28, i64 2, 1
+  %30 = extractvalue %"int[]" %29, 0
+  %31 = extractvalue %"int[]" %26, 0
+  store %"int[]" %26, ptr %taddr4, align 8
+  %32 = getelementptr inbounds %"int[]", ptr %taddr4, i32 0, i32 1
+  %33 = load i64, ptr %32, align 8
+  %34 = mul i64 %33, 4
+  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %30, ptr align 4 %31, i64 %34, i1 false)
+  store %"char[]" { ptr @.str.1, i64 5 }, ptr %taddr6, align 8
+  %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 0
+  %lo7 = load ptr, ptr %35, align 8
+  %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr6, i32 0, i32 1
+  %hi8 = load i64, ptr %36, align 8
+  %37 = insertvalue %variant undef, ptr %y, 0
+  %38 = insertvalue %variant %37, i64 ptrtoint (ptr @"ct$v6$int" to i64), 1
+  %39 = getelementptr inbounds [2 x %variant], ptr %varargslots10, i64 0, i64 0
+  store %variant %38, ptr %39, align 16
+  %40 = insertvalue %variant undef, ptr %z, 0
+  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$v7$int" to i64), 1
+  %42 = getelementptr inbounds [2 x %variant], ptr %varargslots10, i64 0, i64 1
+  store %variant %41, ptr %42, align 16
+  %43 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 1
+  store i64 2, ptr %43, align 8
+  %44 = getelementptr inbounds %"variant[]", ptr %vararg9, i32 0, i32 0
+  store ptr %varargslots10, ptr %44, align 8
+  %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 0
+  %lo11 = load ptr, ptr %45, align 8
+  %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg9, i32 0, i32 1
+  %hi12 = load i64, ptr %46, align 8
+  %47 = call i64 @std_io_printfln(ptr %retparam5, ptr %lo7, i64 %hi8, ptr %lo11, i64 %hi12)
+  %not_err13 = icmp eq i64 %47, 0
+  br i1 %not_err13, label %after_check14, label %voiderr15
+
+after_check14:                                    ; preds = %voiderr
+  br label %voiderr15
+
+voiderr15:                                        ; preds = %after_check14, %voiderr
+  %48 = getelementptr inbounds [1 x %"int[]"], ptr %literal, i64 0, i64 0
+  %49 = getelementptr inbounds [1 x i32], ptr %literal16, i64 0, i64 0
+  store i32 1, ptr %49, align 4
+  %50 = insertvalue %"int[]" undef, ptr %literal16, 0
+  %51 = insertvalue %"int[]" %50, i64 1, 1
+  store %"int[]" %51, ptr %48, align 8
+  %52 = insertvalue %"int[][]" undef, ptr %literal, 0
+  %53 = insertvalue %"int[][]" %52, i64 1, 1
+  store %"int[][]" %53, ptr %a, align 8
+  %54 = getelementptr inbounds [1 x %"int[]"], ptr %literal17, i64 0, i64 0
+  %55 = getelementptr inbounds [1 x i32], ptr %literal18, i64 0, i64 0
+  store i32 2, ptr %55, align 4
+  %56 = insertvalue %"int[]" undef, ptr %literal18, 0
+  %57 = insertvalue %"int[]" %56, i64 1, 1
+  store %"int[]" %57, ptr %54, align 8
+  %58 = insertvalue %"int[][]" undef, ptr %literal17, 0
+  %59 = insertvalue %"int[][]" %58, i64 1, 1
+  store %"int[][]" %59, ptr %b, align 8
+  store %"char[]" { ptr @.str.2, i64 2 }, ptr %taddr20, align 8
+  %60 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0
+  %lo21 = load ptr, ptr %60, align 8
+  %61 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1
+  %hi22 = load i64, ptr %61, align 8
+  %62 = insertvalue %variant undef, ptr %a, 0
+  %63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %64 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
+  store %variant %63, ptr %64, align 16
+  %65 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1
+  store i64 1, ptr %65, align 8
+  %66 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0
+  store ptr %varargslots24, ptr %66, align 8
+  %67 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0
+  %lo25 = load ptr, ptr %67, align 8
+  %68 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1
+  %hi26 = load i64, ptr %68, align 8
+  %69 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26)
+  %not_err27 = icmp eq i64 %69, 0
+  br i1 %not_err27, label %after_check28, label %voiderr29
+
+after_check28:                                    ; preds = %voiderr15
+  br label %voiderr29
+
+voiderr29:                                        ; preds = %after_check28, %voiderr15
+  %70 = load %"int[][]", ptr %b, align 8
+  %71 = extractvalue %"int[][]" %70, 0
+  %ptroffset = getelementptr inbounds %"int[]", ptr %71, i64 0
+  %72 = insertvalue %"int[][]" undef, ptr %ptroffset, 0
+  %73 = insertvalue %"int[][]" %72, i64 1, 1
+  %74 = load %"int[][]", ptr %a, align 8
+  %75 = extractvalue %"int[][]" %74, 0
+  %ptroffset30 = getelementptr inbounds %"int[]", ptr %75, i64 0
+  %76 = insertvalue %"int[][]" undef, ptr %ptroffset30, 0
+  %77 = insertvalue %"int[][]" %76, i64 1, 1
+  %78 = extractvalue %"int[][]" %77, 0
+  %79 = extractvalue %"int[][]" %73, 0
+  store %"int[][]" %73, ptr %taddr31, align 8
+  %80 = getelementptr inbounds %"int[][]", ptr %taddr31, i32 0, i32 1
+  %81 = load i64, ptr %80, align 8
+  %82 = mul i64 %81, 16
+  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %78, ptr align 8 %79, i64 %82, i1 false)
+  store %"char[]" { ptr @.str.3, i64 2 }, ptr %taddr33, align 8
+  %83 = getelementptr inbounds { ptr, i64 }, ptr %taddr33, i32 0, i32 0
+  %lo34 = load ptr, ptr %83, align 8
+  %84 = getelementptr inbounds { ptr, i64 }, ptr %taddr33, i32 0, i32 1
+  %hi35 = load i64, ptr %84, align 8
+  %85 = insertvalue %variant undef, ptr %a, 0
+  %86 = insertvalue %variant %85, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %87 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0
+  store %variant %86, ptr %87, align 16
+  %88 = getelementptr inbounds %"variant[]", ptr %vararg36, i32 0, i32 1
+  store i64 1, ptr %88, align 8
+  %89 = getelementptr inbounds %"variant[]", ptr %vararg36, i32 0, i32 0
+  store ptr %varargslots37, ptr %89, align 8
+  %90 = getelementptr inbounds { ptr, i64 }, ptr %vararg36, i32 0, i32 0
+  %lo38 = load ptr, ptr %90, align 8
+  %91 = getelementptr inbounds { ptr, i64 }, ptr %vararg36, i32 0, i32 1
+  %hi39 = load i64, ptr %91, align 8
+  %92 = call i64 @std_io_printfln(ptr %retparam32, ptr %lo34, i64 %hi35, ptr %lo38, i64 %hi39)
+  %not_err40 = icmp eq i64 %92, 0
+  br i1 %not_err40, label %after_check41, label %voiderr42
+
+after_check41:                                    ; preds = %voiderr29
+  br label %voiderr42
+
+voiderr42:                                        ; preds = %after_check41, %voiderr29
+  %93 = getelementptr inbounds <6 x i32>, ptr %y, i64 0, i64 2
+  %94 = insertvalue %"int[]" undef, ptr %93, 0
+  %95 = insertvalue %"int[]" %94, i64 3, 1
+  %96 = load %"int[][]", ptr %a, align 8
+  %97 = extractvalue %"int[][]" %96, 0
+  %ptroffset43 = getelementptr inbounds %"int[]", ptr %97, i64 0
+  store %"int[]" %95, ptr %ptroffset43, align 8
+  store %"char[]" { ptr @.str.4, i64 2 }, ptr %taddr45, align 8
+  %98 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 0
+  %lo46 = load ptr, ptr %98, align 8
+  %99 = getelementptr inbounds { ptr, i64 }, ptr %taddr45, i32 0, i32 1
+  %hi47 = load i64, ptr %99, align 8
+  %100 = insertvalue %variant undef, ptr %a, 0
+  %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$sa$sa$int" to i64), 1
+  %102 = getelementptr inbounds [1 x %variant], ptr %varargslots49, i64 0, i64 0
+  store %variant %101, ptr %102, align 16
+  %103 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 1
+  store i64 1, ptr %103, align 8
+  %104 = getelementptr inbounds %"variant[]", ptr %vararg48, i32 0, i32 0
+  store ptr %varargslots49, ptr %104, align 8
+  %105 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 0
+  %lo50 = load ptr, ptr %105, align 8
+  %106 = getelementptr inbounds { ptr, i64 }, ptr %vararg48, i32 0, i32 1
+  %hi51 = load i64, ptr %106, align 8
+  %107 = call i64 @std_io_printfln(ptr %retparam44, ptr %lo46, i64 %hi47, ptr %lo50, i64 %hi51)
+  %not_err52 = icmp eq i64 %107, 0
+  br i1 %not_err52, label %after_check53, label %voiderr54
+
+after_check53:                                    ; preds = %voiderr42
+  br label %voiderr54
+
+voiderr54:                                        ; preds = %after_check53, %voiderr42
+  ret void
+}