From a4a6ea16ce53847095ba3148ebd01565cbeb8616 Mon Sep 17 00:00:00 2001
From: Christoffer Lerno <christoffer@aegik.com>
Date: Thu, 18 Nov 2021 23:23:55 +0100
Subject: [PATCH] Use element initialization for <= 16 bytes structs and
 arrays.

---
 src/compiler/llvm_codegen.c                   |  29 +++
 src/compiler/llvm_codegen_c_abi_x64.c         |   1 -
 test/test_suite/abi/regcall_expand.c3t        |  17 +-
 test/test_suite/abi/vec2_aarch64.c3t          |  62 +++---
 test/test_suite/abi/vec2_x64.c3t              | 101 ++++++----
 test/test_suite/arrays/array_casts.c3t        |  30 +--
 test/test_suite/builtins/simple_builtins.c3t  |  28 +--
 .../test_suite/expressions/pointer_access.c3t |  72 +++----
 test/test_suite/functions/test_regression.c3t | 182 +++++++++---------
 .../functions/test_regression_mingw.c3t       | 158 +++++++--------
 .../initializer_lists/general_tests.c3t       |  36 ++--
 .../initializer_lists/subarrays.c3t           |  44 ++---
 .../initializer_lists/zero_init.c3t           |  53 ++---
 test/test_suite/macros/userland_bitcast.c3t   |  50 +++--
 test/test_suite/statements/foreach_break.c3t  |  43 +++--
 15 files changed, 507 insertions(+), 399 deletions(-)

diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c
index de7e15be8..e71b46eba 100644
--- a/src/compiler/llvm_codegen.c
+++ b/src/compiler/llvm_codegen.c
@@ -82,6 +82,35 @@ void llvm_emit_memclear(GenContext *c, BEValue *ref)
 		llvm_emit_memclear(c, &element);
 		return;
 	}
+	if (type_size(type) <= 16)
+	{
+		if (type->type_kind == TYPE_STRUCT)
+		{
+			Decl *decl = type->decl;
+			Decl **members = decl->strukt.members;
+			VECEACH(members, i)
+			{
+				if (!type_size(members[i]->type)) continue;
+				BEValue member_ref;
+				llvm_emit_struct_member_ref(c, ref, &member_ref, i);
+				llvm_emit_memclear(c, &member_ref);
+			}
+			return;
+		}
+		if (type->type_kind == TYPE_ARRAY)
+		{
+			LLVMTypeRef array_type = llvm_get_type(c, type);
+			for (unsigned i = 0; i < type->array.len; i++)
+			{
+				AlignSize align;
+				LLVMValueRef element_ptr = llvm_emit_array_gep_raw(c, ref->value, array_type, i, ref->alignment, &align);
+				BEValue be_value;
+				llvm_value_set_address_align(&be_value, element_ptr, type->array.base, align);
+				llvm_emit_memclear(c, &be_value);
+			}
+			return;
+		}
+	}
 	llvm_emit_memclear_size_align(c, ref->value, type_size(ref->type), ref->alignment, true);
 }
 
diff --git a/src/compiler/llvm_codegen_c_abi_x64.c b/src/compiler/llvm_codegen_c_abi_x64.c
index a49c51eca..bf11bfc4c 100644
--- a/src/compiler/llvm_codegen_c_abi_x64.c
+++ b/src/compiler/llvm_codegen_c_abi_x64.c
@@ -428,7 +428,6 @@ static void x64_classify(Type *type, ByteSize offset_base, X64Class *lo_class, X
 			*current = CLASS_INTEGER;
 			break;
 		case TYPE_F16:
-			TODO
 		case TYPE_F32:
 		case TYPE_F64:
 			*current = CLASS_SSE;
diff --git a/test/test_suite/abi/regcall_expand.c3t b/test/test_suite/abi/regcall_expand.c3t
index 001ee9f60..0f45bcadf 100644
--- a/test/test_suite/abi/regcall_expand.c3t
+++ b/test/test_suite/abi/regcall_expand.c3t
@@ -41,13 +41,16 @@ entry:
 define void @main() #0 {
 entry:
   %literal = alloca %Foo, align 4
-  %0 = bitcast %Foo* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false)
-  %1 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
-  %2 = getelementptr inbounds [2 x float], [2 x float]* %1, i64 0, i64 0
-  %loadexpanded = load float, float* %2, align 4
-  %3 = getelementptr inbounds [2 x float], [2 x float]* %1, i64 0, i64 1
-  %loadexpanded1 = load float, float* %3, align 4
+  %0 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
+  %1 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 0
+  store float 0.000000e+00, float* %1, align 4
+  %2 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 1
+  store float 0.000000e+00, float* %2, align 4
+  %3 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
+  %4 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
+  %loadexpanded = load float, float* %4, align 4
+  %5 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
+  %loadexpanded1 = load float, float* %5, align 4
   call x86_regcallcc void @test.test(float %loadexpanded, float %loadexpanded1)
   ret void
 }
diff --git a/test/test_suite/abi/vec2_aarch64.c3t b/test/test_suite/abi/vec2_aarch64.c3t
index 9e6dc33ba..014c4f562 100644
--- a/test/test_suite/abi/vec2_aarch64.c3t
+++ b/test/test_suite/abi/vec2_aarch64.c3t
@@ -18,19 +18,24 @@ extern fn Vector2 vector2_subtract_value(Vector2 v, float sub) { return Vector2
 define %Vector2 @vector2_zero()
 entry:
   %literal = alloca %Vector2, align 4
-  %0 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false)
-  %1 = load %Vector2, %Vector2* %literal, align 4
-  ret %Vector2 %1
+  %0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %0, align 4
+  %1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %1, align 4
+  %2 = load %Vector2, %Vector2* %literal, align 4
+  ret %Vector2 %2
 }
 
 define %Vector2 @vector2_one()
 entry:
   %literal = alloca %Vector2, align 4
-  %0 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false)
-  %1 = load %Vector2, %Vector2* %literal, align 4
-  ret %Vector2 %1
+  %0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %0, align 4
+  %1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %1, align 4
+  %2 = load %Vector2, %Vector2* %literal, align 4
+  ret %Vector2 %2
+}
 
 
 define %Vector2 @vector2_add(float %0, float %1, float %2, float %3)
@@ -48,10 +53,12 @@ entry:
   store float %2, float* %6, align 4
   %7 = getelementptr inbounds { float, float }, { float, float }* %coerce1, i32 0, i32 1
   store float %3, float* %7, align 4
-  %8 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %8, i8 0, i64 8, i1 false)
-  %9 = load %Vector2, %Vector2* %literal, align 4
-  ret %Vector2 %9
+  %8 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %8, align 4
+  %9 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %9, align 4
+  %10 = load %Vector2, %Vector2* %literal, align 4
+  ret %Vector2 %10
 }
 
 define %Vector2 @vector2_add_value(float %0, float %1, float %2)
@@ -65,10 +72,12 @@ entry:
   %4 = getelementptr inbounds { float, float }, { float, float }* %coerce, i32 0, i32 1
   store float %1, float* %4, align 4
   store float %2, float* %add, align 4
-  %5 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %5, i8 0, i64 8, i1 false)
-  %6 = load %Vector2, %Vector2* %literal, align 4
-  ret %Vector2 %6
+  %5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %5, align 4
+  %6 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %6, align 4
+  %7 = load %Vector2, %Vector2* %literal, align 4
+  ret %Vector2 %7
 }
 
 define %Vector2 @vector2_subtract(float %0, float %1, float %2, float %3)
@@ -86,10 +95,13 @@ entry:
   store float %2, float* %6, align 4
   %7 = getelementptr inbounds { float, float }, { float, float }* %coerce1, i32 0, i32 1
   store float %3, float* %7, align 4
-  %8 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %8, i8 0, i64 8, i1 false)
-  %9 = load %Vector2, %Vector2* %literal, align 4
-  ret %Vector2 %9
+  %8 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %8, align 4
+  %9 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %9, align 4
+  %10 = load %Vector2, %Vector2* %literal, align 4
+  ret %Vector2 %10
+}
 
 define %Vector2 @vector2_subtract_value(float %0, float %1, float %2)
 entry:
@@ -102,8 +114,10 @@ entry:
   %4 = getelementptr inbounds { float, float }, { float, float }* %coerce, i32 0, i32 1
   store float %1, float* %4, align 4
   store float %2, float* %sub, align 4
-  %5 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %5, i8 0, i64 8, i1 false)
-  %6 = load %Vector2, %Vector2* %literal, align 4
-  ret %Vector2 %6
+  %5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %5, align 4
+  %6 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %6, align 4
+  %7 = load %Vector2, %Vector2* %literal, align 4
+  ret %Vector2 %7
 }
diff --git a/test/test_suite/abi/vec2_x64.c3t b/test/test_suite/abi/vec2_x64.c3t
index e5bf7e0dd..b477afbc3 100644
--- a/test/test_suite/abi/vec2_x64.c3t
+++ b/test/test_suite/abi/vec2_x64.c3t
@@ -20,24 +20,30 @@ define <2 x float> @vector2_zero()
 entry:
   %literal = alloca %Vector2, align 4
   %tempcoerce = alloca <2 x float>, align 8
-  %0 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false)
-  %1 = bitcast <2 x float>* %tempcoerce to i8*
-  %2 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %1, i8* align 4 %2, i32 8, i1 false)
-  %3 = load <2 x float>, <2 x float>* %tempcoerce, align 8
-  ret <2 x float> %3
+  %0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %0, align 4
+  %1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %1, align 4
+  %2 = bitcast <2 x float>* %tempcoerce to i8*
+  %3 = bitcast %Vector2* %literal to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %2, i8* align 4 %3, i32 8, i1 false)
+  %4 = load <2 x float>, <2 x float>* %tempcoerce, align 8
+  ret <2 x float> %4
+}
 
 define <2 x float> @vector2_one()
   %literal = alloca %Vector2, align 4
   %tempcoerce = alloca <2 x float>, align 8
-  %0 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 8, i1 false)
-  %1 = bitcast <2 x float>* %tempcoerce to i8*
-  %2 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %1, i8* align 4 %2, i32 8, i1 false)
-  %3 = load <2 x float>, <2 x float>* %tempcoerce, align 8
-  ret <2 x float> %3
+  %0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %0, align 4
+  %1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %1, align 4
+  %2 = bitcast <2 x float>* %tempcoerce to i8*
+  %3 = bitcast %Vector2* %literal to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %2, i8* align 4 %3, i32 8, i1 false)
+  %4 = load <2 x float>, <2 x float>* %tempcoerce, align 8
+  ret <2 x float> %4
+}
 
 define <2 x float> @vector2_add(<2 x float> %0, <2 x float> %1)
 entry:
@@ -49,13 +55,15 @@ entry:
   store <2 x float> %0, <2 x float>* %2, align 4
   %3 = bitcast %Vector2* %v2 to <2 x float>*
   store <2 x float> %1, <2 x float>* %3, align 4
-  %4 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %4, i8 0, i64 8, i1 false)
-  %5 = bitcast <2 x float>* %tempcoerce to i8*
-  %6 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %5, i8* align 4 %6, i32 8, i1 false)
-  %7 = load <2 x float>, <2 x float>* %tempcoerce, align 8
-  ret <2 x float> %7
+  %4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %4, align 4
+  %5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %5, align 4
+  %6 = bitcast <2 x float>* %tempcoerce to i8*
+  %7 = bitcast %Vector2* %literal to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %6, i8* align 4 %7, i32 8, i1 false)
+  %8 = load <2 x float>, <2 x float>* %tempcoerce, align 8
+  ret <2 x float> %8
 }
 
 define <2 x float> @vector2_add_value(<2 x float> %0, float %1) #0 {
@@ -66,13 +74,16 @@ define <2 x float> @vector2_add_value(<2 x float> %0, float %1) #0 {
   %2 = bitcast %Vector2* %v to <2 x float>*
   store <2 x float> %0, <2 x float>* %2, align 4
   store float %1, float* %add, align 4
-  %3 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %3, i8 0, i64 8, i1 false)
-  %4 = bitcast <2 x float>* %tempcoerce to i8*
-  %5 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %4, i8* align 4 %5, i32 8, i1 false)
-  %6 = load <2 x float>, <2 x float>* %tempcoerce, align 8
-  ret <2 x float> %6
+  %3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %3, align 4
+  %4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %4, align 4
+  %5 = bitcast <2 x float>* %tempcoerce to i8*
+  %6 = bitcast %Vector2* %literal to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %5, i8* align 4 %6, i32 8, i1 false)
+  %7 = load <2 x float>, <2 x float>* %tempcoerce, align 8
+  ret <2 x float> %7
+}
 
 define <2 x float> @vector2_subtract(<2 x float> %0, <2 x float> %1)
 entry:
@@ -84,13 +95,16 @@ entry:
   store <2 x float> %0, <2 x float>* %2, align 4
   %3 = bitcast %Vector2* %v2 to <2 x float>*
   store <2 x float> %1, <2 x float>* %3, align 4
-  %4 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %4, i8 0, i64 8, i1 false)
-  %5 = bitcast <2 x float>* %tempcoerce to i8*
-  %6 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %5, i8* align 4 %6, i32 8, i1 false)
-  %7 = load <2 x float>, <2 x float>* %tempcoerce, align 8
-  ret <2 x float> %7
+  %4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %4, align 4
+  %5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %5, align 4
+  %6 = bitcast <2 x float>* %tempcoerce to i8*
+  %7 = bitcast %Vector2* %literal to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %6, i8* align 4 %7, i32 8, i1 false)
+  %8 = load <2 x float>, <2 x float>* %tempcoerce, align 8
+  ret <2 x float> %8
+}
 
 define <2 x float> @vector2_subtract_value(<2 x float> %0, float %1)
 entry:
@@ -101,10 +115,13 @@ entry:
   %2 = bitcast %Vector2* %v to <2 x float>*
   store <2 x float> %0, <2 x float>* %2, align 4
   store float %1, float* %sub, align 4
-  %3 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %3, i8 0, i64 8, i1 false)
-  %4 = bitcast <2 x float>* %tempcoerce to i8*
-  %5 = bitcast %Vector2* %literal to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %4, i8* align 4 %5, i32 8, i1 false)
-  %6 = load <2 x float>, <2 x float>* %tempcoerce, align 8
-  ret <2 x float> %6
+  %3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
+  store float 0.000000e+00, float* %3, align 4
+  %4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
+  store float 0.000000e+00, float* %4, align 4
+  %5 = bitcast <2 x float>* %tempcoerce to i8*
+  %6 = bitcast %Vector2* %literal to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %5, i8* align 4 %6, i32 8, i1 false)
+  %7 = load <2 x float>, <2 x float>* %tempcoerce, align 8
+  ret <2 x float> %7
+}
diff --git a/test/test_suite/arrays/array_casts.c3t b/test/test_suite/arrays/array_casts.c3t
index 5d2930b6c..0d8079585 100644
--- a/test/test_suite/arrays/array_casts.c3t
+++ b/test/test_suite/arrays/array_casts.c3t
@@ -12,14 +12,22 @@ fn void test()
 
 %"int[]" = type { i32*, i64 }
 
-%x = alloca [3 x i32], align 4
-%y = alloca i32*, align 8
-%z = alloca %"int[]", align 8
-%0 = bitcast [3 x i32]* %x to i8*
-call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 12, i1 false)
-%ptrptr = bitcast [3 x i32]* %x to i32*
-store i32* %ptrptr, i32** %y, align 8
-%1 = bitcast [3 x i32]* %x to i32*
-%2 = insertvalue %"int[]" undef, i32* %1, 0
-%3 = insertvalue %"int[]" %2, i64 3, 1
-store %"int[]" %3, %"int[]"* %z, align 8
\ No newline at end of file
+define void @array_casts.test() #0 {
+entry:
+  %x = alloca [3 x i32], align 4
+  %y = alloca i32*, align 8
+  %z = alloca %"int[]", align 8
+  %0 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 0
+  store i32 0, i32* %0, align 4
+  %1 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 1
+  store i32 0, i32* %1, align 4
+  %2 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 2
+  store i32 0, i32* %2, align 4
+  %ptrptr = bitcast [3 x i32]* %x to i32*
+  store i32* %ptrptr, i32** %y, align 8
+  %3 = bitcast [3 x i32]* %x to i32*
+  %4 = insertvalue %"int[]" undef, i32* %3, 0
+  %5 = insertvalue %"int[]" %4, i64 3, 1
+  store %"int[]" %5, %"int[]"* %z, align 8
+  ret void
+}
\ No newline at end of file
diff --git a/test/test_suite/builtins/simple_builtins.c3t b/test/test_suite/builtins/simple_builtins.c3t
index 83ede8c20..e73bdcf90 100644
--- a/test/test_suite/builtins/simple_builtins.c3t
+++ b/test/test_suite/builtins/simple_builtins.c3t
@@ -39,19 +39,23 @@ entry:
   %7 = call double @llvm.fma.f64(double %4, double %5, double %6)
   store double %7, double* %f, align 8
   store i32 13, i32* %xeb, align 4
-  %8 = bitcast [3 x i32]* %abcd to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %8, i8 0, i64 12, i1 false)
-  %9 = load volatile i32, i32* %xeb, align 4
-  store i32 %9, i32* %sy, align 4
-  %10 = load i32, i32* %sy, align 4
-  %add = add i32 %10, 1
-  store volatile i32 %add, i32* %xeb, align 4
-  %11 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
+  %8 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 0
+  store i32 0, i32* %8, align 4
+  %9 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 1
+  store i32 0, i32* %9, align 4
+  %10 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
+  store i32 0, i32* %10, align 4
+  %11 = load volatile i32, i32* %xeb, align 4
+  store i32 %11, i32* %sy, align 4
   %12 = load i32, i32* %sy, align 4
-  %add1 = add i32 %12, 2
-  store volatile i32 %add1, i32* %11, align 4
+  %add = add i32 %12, 1
+  store volatile i32 %add, i32* %xeb, align 4
   %13 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
-  %14 = load volatile i32, i32* %13, align 4
-  store i32 %14, i32* %sy, align 4
+  %14 = load i32, i32* %sy, align 4
+  %add1 = add i32 %14, 2
+  store volatile i32 %add1, i32* %13, align 4
+  %15 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
+  %16 = load volatile i32, i32* %15, align 4
+  store i32 %16, i32* %sy, align 4
   ret i32 1
 }
\ No newline at end of file
diff --git a/test/test_suite/expressions/pointer_access.c3t b/test/test_suite/expressions/pointer_access.c3t
index 7639e7f21..0d01fc2f4 100644
--- a/test/test_suite/expressions/pointer_access.c3t
+++ b/test/test_suite/expressions/pointer_access.c3t
@@ -35,7 +35,7 @@ fn void testSimple()
 }
 
 // TODO these may be wrong.
-// #expect: pointer_access.ll
+/* #expect: pointer_access.ll
 
 %ExtraSimple = type { i32, i32, %c, %anon, %anon.0, i32 }
 %c = type { double, double, double, double, double }
@@ -44,6 +44,7 @@ fn void testSimple()
 
 @ExtraSimple = linkonce_odr constant i8 1
 
+define void @pointer_access.testSimple() #0 {
 entry:
   %a = alloca %ExtraSimple, align 8
   %0 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 0
@@ -62,37 +63,40 @@ entry:
   %7 = getelementptr inbounds %c, %c* %2, i32 0, i32 4
   store double 3.300000e+00, double* %7, align 8
   %8 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
-  %9 = bitcast %anon* %8 to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 8 %9, i8 0, i64 8, i1 false)
-  %10 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 4
-  %11 = bitcast %anon.0* %10 to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 8 %11, i8 0, i64 8, i1 false)
-  %12 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 5
-  store i32 0, i32* %12, align 8
-  %13 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
-  %14 = getelementptr inbounds %c, %c* %13, i32 0, i32 4
-  store double 3.400000e+00, double* %14, align 8
-  %15 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 0
-  %16 = load i32, i32* %15, align 8
-  %17 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
-  %18 = getelementptr inbounds %c, %c* %17, i32 0, i32 0
-  %19 = load double, double* %18, align 8
-  %20 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
-  %21 = getelementptr inbounds %c, %c* %20, i32 0, i32 3
-  %22 = load double, double* %21, align 8
-  %23 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
-  %24 = getelementptr inbounds %c, %c* %23, i32 0, i32 4
-  %25 = load double, double* %24, align 8
-  %26 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 5
-  %27 = load i32, i32* %26, align 8
-  %28 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 4
-  %29 = bitcast %anon.0* %28 to double*
-  %30 = load double, double* %29, align 8
-  %31 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
-  %32 = getelementptr inbounds %anon, %anon* %31, i32 0, i32 0
-  %33 = load i32, i32* %32, align 8
-  %34 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
-  %35 = getelementptr inbounds %anon, %anon* %34, i32 0, i32 1
-  %36 = load i32, i32* %35, align 4
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str, i32 0, i32 0), i32 %16, double %19, double %22, double %25, i32 %27, double %30, i32 %33, i32 %36)
+  %9 = getelementptr inbounds %anon, %anon* %8, i32 0, i32 0
+  store i32 0, i32* %9, align 8
+  %10 = getelementptr inbounds %anon, %anon* %8, i32 0, i32 1
+  store i32 0, i32* %10, align 4
+  %11 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 4
+  %12 = bitcast %anon.0* %11 to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 8 %12, i8 0, i64 8, i1 false)
+  %13 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 5
+  store i32 0, i32* %13, align 8
+  %14 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
+  %15 = getelementptr inbounds %c, %c* %14, i32 0, i32 4
+  store double 3.400000e+00, double* %15, align 8
+  %16 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 0
+  %17 = load i32, i32* %16, align 8
+  %18 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
+  %19 = getelementptr inbounds %c, %c* %18, i32 0, i32 0
+  %20 = load double, double* %19, align 8
+  %21 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
+  %22 = getelementptr inbounds %c, %c* %21, i32 0, i32 3
+  %23 = load double, double* %22, align 8
+  %24 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 2
+  %25 = getelementptr inbounds %c, %c* %24, i32 0, i32 4
+  %26 = load double, double* %25, align 8
+  %27 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 5
+  %28 = load i32, i32* %27, align 8
+  %29 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 4
+  %30 = bitcast %anon.0* %29 to double*
+  %31 = load double, double* %30, align 8
+  %32 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
+  %33 = getelementptr inbounds %anon, %anon* %32, i32 0, i32 0
+  %34 = load i32, i32* %33, align 8
+  %35 = getelementptr inbounds %ExtraSimple, %ExtraSimple* %a, i32 0, i32 3
+  %36 = getelementptr inbounds %anon, %anon* %35, i32 0, i32 1
+  %37 = load i32, i32* %36, align 4
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str, i32 0, i32 0), i32 %17, double %20, double %23, double %26, i32 %28, double %31, i32 %34, i32 %37)
   ret void
+}
diff --git a/test/test_suite/functions/test_regression.c3t b/test/test_suite/functions/test_regression.c3t
index 023c963d3..9359a2f88 100644
--- a/test/test_suite/functions/test_regression.c3t
+++ b/test/test_suite/functions/test_regression.c3t
@@ -562,98 +562,100 @@ for.exit9:                                        ; preds = %for.cond2
   %35 = call double @test2.double.getMult(double 3.300000e+00)
   %36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.11, i32 0, i32 0), double %35)
   call void @test.helloWorld()
-  %37 = bitcast %Foo* %ddx to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %37, i8 0, i64 8, i1 false)
+  %37 = getelementptr inbounds %Foo, %Foo* %ddx, i32 0, i32 0
+  store i32 0, i32* %37, align 4
+  %38 = getelementptr inbounds %Foo, %Foo* %ddx, i32 0, i32 1
+  store i32 0, i32* %38, align 4
   store i32 3, i32* %fro, align 4
-  %38 = bitcast [4 x i32]* %x to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %38, i8* align 16 bitcast ([4 x i32]* @.__const.12 to i8*), i32 16, i1 false)
-  %39 = load i32, i32* %fro, align 4
-  %40 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1
-  %41 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0
-  store i64 4, i64* %40, align 8
-  %42 = bitcast [4 x i32]* %x to i32*
-  store i32* %42, i32** %41, align 8
-  %43 = bitcast %"int[]"* %vararg to { i8*, i64 }*
-  %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0
-  %lo = load i8*, i8** %44, align 8
-  %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1
-  %hi = load i64, i64* %45, align 8
-  %46 = call i32 @test.sum_us(i8* %lo, i64 %hi)
-  %47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i32 0, i32 0), i32 %46)
-  %add10 = add i32 %39, %47
+  %39 = bitcast [4 x i32]* %x to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %39, i8* align 16 bitcast ([4 x i32]* @.__const.12 to i8*), i32 16, i1 false)
+  %40 = load i32, i32* %fro, align 4
+  %41 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1
+  %42 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0
+  store i64 4, i64* %41, align 8
+  %43 = bitcast [4 x i32]* %x to i32*
+  store i32* %43, i32** %42, align 8
+  %44 = bitcast %"int[]"* %vararg to { i8*, i64 }*
+  %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0
+  %lo = load i8*, i8** %45, align 8
+  %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1
+  %hi = load i64, i64* %46, align 8
+  %47 = call i32 @test.sum_us(i8* %lo, i64 %hi)
+  %48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i32 0, i32 0), i32 %47)
+  %add10 = add i32 %40, %48
   store i32 %add10, i32* %fro, align 4
-  %48 = load i32, i32* %fro, align 4
-  %49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i32 %48)
-  %50 = bitcast [4 x i32]* %x to i32*
-  %51 = insertvalue %"int[]" undef, i32* %50, 0
-  %52 = insertvalue %"int[]" %51, i64 4, 1
-  store %"int[]" %52, %"int[]"* %z, align 8
-  %53 = bitcast [3 x i32]* %de to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %53, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false)
-  %54 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 1
-  %55 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 0
-  store i64 4, i64* %54, align 8
-  %56 = bitcast [4 x i32]* %x to i32*
-  store i32* %56, i32** %55, align 8
-  %57 = bitcast %"int[]"* %vararg11 to { i8*, i64 }*
-  %58 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %57, i32 0, i32 0
-  %lo12 = load i8*, i8** %58, align 8
-  %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %57, i32 0, i32 1
-  %hi13 = load i64, i64* %59, align 8
-  %60 = call i32 @test.sum_us(i8* %lo12, i64 %hi13)
-  %61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i32 0, i32 0), i32 %60)
-  %62 = getelementptr inbounds %"int[]", %"int[]"* %vararg14, i32 0, i32 1
-  %63 = getelementptr inbounds %"int[]", %"int[]"* %vararg14, i32 0, i32 0
-  %64 = bitcast %"int[]"* %z to { i8*, i64 }*
-  %65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0
-  %lo15 = load i8*, i8** %65, align 8
-  %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1
-  %hi16 = load i64, i64* %66, align 8
-  %67 = call i32 @test.sum_us(i8* %lo15, i64 %hi16)
-  %68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i32 0, i32 0), i32 %67)
-  %69 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0
-  store i32 1, i32* %69, align 4
-  %70 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1
-  store i32 2, i32* %70, align 4
-  %71 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2
-  store i32 4, i32* %71, align 4
-  %72 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3
-  store i32 5, i32* %72, align 4
-  %73 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 1
-  store i64 4, i64* %73, align 8
-  %74 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 0
-  %75 = bitcast [4 x i32]* %varargslots to i32*
-  store i32* %75, i32** %74, align 8
-  %76 = bitcast %"int[]"* %vararg17 to { i8*, i64 }*
-  %77 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %76, i32 0, i32 0
-  %lo18 = load i8*, i8** %77, align 8
-  %78 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %76, i32 0, i32 1
-  %hi19 = load i64, i64* %78, align 8
-  %79 = call i32 @test.sum_us(i8* %lo18, i64 %hi19)
-  %80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %79)
-  %81 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots21, i64 0, i64 0
-  store i32 1, i32* %81, align 4
-  %82 = getelementptr inbounds %"int[]", %"int[]"* %vararg20, i32 0, i32 1
-  store i64 1, i64* %82, align 8
-  %83 = getelementptr inbounds %"int[]", %"int[]"* %vararg20, i32 0, i32 0
-  %84 = bitcast [1 x i32]* %varargslots21 to i32*
-  store i32* %84, i32** %83, align 8
-  %85 = bitcast %"int[]"* %vararg20 to { i8*, i64 }*
-  %86 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 0
-  %lo22 = load i8*, i8** %86, align 8
-  %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %85, i32 0, i32 1
-  %hi23 = load i64, i64* %87, align 8
-  %88 = call i32 @test.sum_us(i8* %lo22, i64 %hi23)
-  %89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %88)
-  %90 = getelementptr inbounds %"int[]", %"int[]"* %vararg24, i32 0, i32 1
-  store i64 0, i64* %90, align 8
-  %91 = bitcast %"int[]"* %vararg24 to { i8*, i64 }*
-  %92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %91, i32 0, i32 0
-  %lo25 = load i8*, i8** %92, align 8
-  %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %91, i32 0, i32 1
-  %hi26 = load i64, i64* %93, align 8
-  %94 = call i32 @test.sum_us(i8* %lo25, i64 %hi26)
-  %95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %94)
+  %49 = load i32, i32* %fro, align 4
+  %50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i32 %49)
+  %51 = bitcast [4 x i32]* %x to i32*
+  %52 = insertvalue %"int[]" undef, i32* %51, 0
+  %53 = insertvalue %"int[]" %52, i64 4, 1
+  store %"int[]" %53, %"int[]"* %z, align 8
+  %54 = bitcast [3 x i32]* %de to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %54, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false)
+  %55 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 1
+  %56 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 0
+  store i64 4, i64* %55, align 8
+  %57 = bitcast [4 x i32]* %x to i32*
+  store i32* %57, i32** %56, align 8
+  %58 = bitcast %"int[]"* %vararg11 to { i8*, i64 }*
+  %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0
+  %lo12 = load i8*, i8** %59, align 8
+  %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1
+  %hi13 = load i64, i64* %60, align 8
+  %61 = call i32 @test.sum_us(i8* %lo12, i64 %hi13)
+  %62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i32 0, i32 0), i32 %61)
+  %63 = getelementptr inbounds %"int[]", %"int[]"* %vararg14, i32 0, i32 1
+  %64 = getelementptr inbounds %"int[]", %"int[]"* %vararg14, i32 0, i32 0
+  %65 = bitcast %"int[]"* %z to { i8*, i64 }*
+  %66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 0
+  %lo15 = load i8*, i8** %66, align 8
+  %67 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 1
+  %hi16 = load i64, i64* %67, align 8
+  %68 = call i32 @test.sum_us(i8* %lo15, i64 %hi16)
+  %69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i32 0, i32 0), i32 %68)
+  %70 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0
+  store i32 1, i32* %70, align 4
+  %71 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1
+  store i32 2, i32* %71, align 4
+  %72 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2
+  store i32 4, i32* %72, align 4
+  %73 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3
+  store i32 5, i32* %73, align 4
+  %74 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 1
+  store i64 4, i64* %74, align 8
+  %75 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 0
+  %76 = bitcast [4 x i32]* %varargslots to i32*
+  store i32* %76, i32** %75, align 8
+  %77 = bitcast %"int[]"* %vararg17 to { i8*, i64 }*
+  %78 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %77, i32 0, i32 0
+  %lo18 = load i8*, i8** %78, align 8
+  %79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %77, i32 0, i32 1
+  %hi19 = load i64, i64* %79, align 8
+  %80 = call i32 @test.sum_us(i8* %lo18, i64 %hi19)
+  %81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %80)
+  %82 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots21, i64 0, i64 0
+  store i32 1, i32* %82, align 4
+  %83 = getelementptr inbounds %"int[]", %"int[]"* %vararg20, i32 0, i32 1
+  store i64 1, i64* %83, align 8
+  %84 = getelementptr inbounds %"int[]", %"int[]"* %vararg20, i32 0, i32 0
+  %85 = bitcast [1 x i32]* %varargslots21 to i32*
+  store i32* %85, i32** %84, align 8
+  %86 = bitcast %"int[]"* %vararg20 to { i8*, i64 }*
+  %87 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 0
+  %lo22 = load i8*, i8** %87, align 8
+  %88 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %86, i32 0, i32 1
+  %hi23 = load i64, i64* %88, align 8
+  %89 = call i32 @test.sum_us(i8* %lo22, i64 %hi23)
+  %90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %89)
+  %91 = getelementptr inbounds %"int[]", %"int[]"* %vararg24, i32 0, i32 1
+  store i64 0, i64* %91, align 8
+  %92 = bitcast %"int[]"* %vararg24 to { i8*, i64 }*
+  %93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 0
+  %lo25 = load i8*, i8** %93, align 8
+  %94 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %92, i32 0, i32 1
+  %hi26 = load i64, i64* %94, align 8
+  %95 = call i32 @test.sum_us(i8* %lo25, i64 %hi26)
+  %96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %95)
   store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %a1, align 8
   store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %b2, align 8
   ret void
diff --git a/test/test_suite/functions/test_regression_mingw.c3t b/test/test_suite/functions/test_regression_mingw.c3t
index d20b74aa1..677157180 100644
--- a/test/test_suite/functions/test_regression_mingw.c3t
+++ b/test/test_suite/functions/test_regression_mingw.c3t
@@ -624,86 +624,88 @@ for.exit9:                                        ; preds = %for.cond2
   %35 = call double @test2.double.getMult(double 3.300000e+00)
   %36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.11, i32 0, i32 0), double %35)
   call void @test.helloWorld()
-  %37 = bitcast %Foo* %ddx to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %37, i8 0, i64 8, i1 false)
+  %37 = getelementptr inbounds %Foo, %Foo* %ddx, i32 0, i32 0
+  store i32 0, i32* %37, align 4
+  %38 = getelementptr inbounds %Foo, %Foo* %ddx, i32 0, i32 1
+  store i32 0, i32* %38, align 4
   store i32 3, i32* %fro, align 4
-  %38 = bitcast [4 x i32]* %x to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %38, i8* align 16 bitcast ([4 x i32]* @.__const.12 to i8*), i32 16, i1 false)
-  %39 = load i32, i32* %fro, align 4
-  %40 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1
-  %41 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0
-  store i64 4, i64* %40, align 8
-  %42 = bitcast [4 x i32]* %x to i32*
-  store i32* %42, i32** %41, align 8
-  %43 = bitcast %"int[]"* %indirectarg to i8*
-  %44 = bitcast %"int[]"* %vararg to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %43, i8* align 8 %44, i32 16, i1 false)
-  %45 = call i32 @test.sum_us(%"int[]"* %indirectarg)
-  %46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i32 0, i32 0), i32 %45)
-  %add10 = add i32 %39, %46
+  %39 = bitcast [4 x i32]* %x to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %39, i8* align 16 bitcast ([4 x i32]* @.__const.12 to i8*), i32 16, i1 false)
+  %40 = load i32, i32* %fro, align 4
+  %41 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 1
+  %42 = getelementptr inbounds %"int[]", %"int[]"* %vararg, i32 0, i32 0
+  store i64 4, i64* %41, align 8
+  %43 = bitcast [4 x i32]* %x to i32*
+  store i32* %43, i32** %42, align 8
+  %44 = bitcast %"int[]"* %indirectarg to i8*
+  %45 = bitcast %"int[]"* %vararg to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %44, i8* align 8 %45, i32 16, i1 false)
+  %46 = call i32 @test.sum_us(%"int[]"* %indirectarg)
+  %47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i32 0, i32 0), i32 %46)
+  %add10 = add i32 %40, %47
   store i32 %add10, i32* %fro, align 4
-  %47 = load i32, i32* %fro, align 4
-  %48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i32 %47)
-  %49 = bitcast [4 x i32]* %x to i32*
-  %50 = insertvalue %"int[]" undef, i32* %49, 0
-  %51 = insertvalue %"int[]" %50, i64 4, 1
-  store %"int[]" %51, %"int[]"* %z, align 8
-  %52 = bitcast [3 x i32]* %de to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %52, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false)
-  %53 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 1
-  %54 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 0
-  store i64 4, i64* %53, align 8
-  %55 = bitcast [4 x i32]* %x to i32*
-  store i32* %55, i32** %54, align 8
-  %56 = bitcast %"int[]"* %indirectarg12 to i8*
-  %57 = bitcast %"int[]"* %vararg11 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %56, i8* align 8 %57, i32 16, i1 false)
-  %58 = call i32 @test.sum_us(%"int[]"* %indirectarg12)
-  %59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i32 0, i32 0), i32 %58)
-  %60 = getelementptr inbounds %"int[]", %"int[]"* %vararg13, i32 0, i32 1
-  %61 = getelementptr inbounds %"int[]", %"int[]"* %vararg13, i32 0, i32 0
-  %62 = bitcast %"int[]"* %indirectarg14 to i8*
-  %63 = bitcast %"int[]"* %z to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %62, i8* align 8 %63, i32 16, i1 false)
-  %64 = call i32 @test.sum_us(%"int[]"* %indirectarg14)
-  %65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i32 0, i32 0), i32 %64)
-  %66 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0
-  store i32 1, i32* %66, align 4
-  %67 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1
-  store i32 2, i32* %67, align 4
-  %68 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2
-  store i32 4, i32* %68, align 4
-  %69 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3
-  store i32 5, i32* %69, align 4
-  %70 = getelementptr inbounds %"int[]", %"int[]"* %vararg15, i32 0, i32 1
-  store i64 4, i64* %70, align 8
-  %71 = getelementptr inbounds %"int[]", %"int[]"* %vararg15, i32 0, i32 0
-  %72 = bitcast [4 x i32]* %varargslots to i32*
-  store i32* %72, i32** %71, align 8
-  %73 = bitcast %"int[]"* %indirectarg16 to i8*
-  %74 = bitcast %"int[]"* %vararg15 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %73, i8* align 8 %74, i32 16, i1 false)
-  %75 = call i32 @test.sum_us(%"int[]"* %indirectarg16)
-  %76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %75)
-  %77 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots18, i64 0, i64 0
-  store i32 1, i32* %77, align 4
-  %78 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 1
-  store i64 1, i64* %78, align 8
-  %79 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 0
-  %80 = bitcast [1 x i32]* %varargslots18 to i32*
-  store i32* %80, i32** %79, align 8
-  %81 = bitcast %"int[]"* %indirectarg19 to i8*
-  %82 = bitcast %"int[]"* %vararg17 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %81, i8* align 8 %82, i32 16, i1 false)
-  %83 = call i32 @test.sum_us(%"int[]"* %indirectarg19)
-  %84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %83)
-  %85 = getelementptr inbounds %"int[]", %"int[]"* %vararg20, i32 0, i32 1
-  store i64 0, i64* %85, align 8
-  %86 = bitcast %"int[]"* %indirectarg21 to i8*
-  %87 = bitcast %"int[]"* %vararg20 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %86, i8* align 8 %87, i32 16, i1 false)
-  %88 = call i32 @test.sum_us(%"int[]"* %indirectarg21)
-  %89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %88)
+  %48 = load i32, i32* %fro, align 4
+  %49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i32 %48)
+  %50 = bitcast [4 x i32]* %x to i32*
+  %51 = insertvalue %"int[]" undef, i32* %50, 0
+  %52 = insertvalue %"int[]" %51, i64 4, 1
+  store %"int[]" %52, %"int[]"* %z, align 8
+  %53 = bitcast [3 x i32]* %de to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %53, i8* align 4 bitcast ([3 x i32]* @.__const.15 to i8*), i32 12, i1 false)
+  %54 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 1
+  %55 = getelementptr inbounds %"int[]", %"int[]"* %vararg11, i32 0, i32 0
+  store i64 4, i64* %54, align 8
+  %56 = bitcast [4 x i32]* %x to i32*
+  store i32* %56, i32** %55, align 8
+  %57 = bitcast %"int[]"* %indirectarg12 to i8*
+  %58 = bitcast %"int[]"* %vararg11 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %57, i8* align 8 %58, i32 16, i1 false)
+  %59 = call i32 @test.sum_us(%"int[]"* %indirectarg12)
+  %60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i32 0, i32 0), i32 %59)
+  %61 = getelementptr inbounds %"int[]", %"int[]"* %vararg13, i32 0, i32 1
+  %62 = getelementptr inbounds %"int[]", %"int[]"* %vararg13, i32 0, i32 0
+  %63 = bitcast %"int[]"* %indirectarg14 to i8*
+  %64 = bitcast %"int[]"* %z to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %63, i8* align 8 %64, i32 16, i1 false)
+  %65 = call i32 @test.sum_us(%"int[]"* %indirectarg14)
+  %66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i32 0, i32 0), i32 %65)
+  %67 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 0
+  store i32 1, i32* %67, align 4
+  %68 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 1
+  store i32 2, i32* %68, align 4
+  %69 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 2
+  store i32 4, i32* %69, align 4
+  %70 = getelementptr inbounds [4 x i32], [4 x i32]* %varargslots, i64 0, i64 3
+  store i32 5, i32* %70, align 4
+  %71 = getelementptr inbounds %"int[]", %"int[]"* %vararg15, i32 0, i32 1
+  store i64 4, i64* %71, align 8
+  %72 = getelementptr inbounds %"int[]", %"int[]"* %vararg15, i32 0, i32 0
+  %73 = bitcast [4 x i32]* %varargslots to i32*
+  store i32* %73, i32** %72, align 8
+  %74 = bitcast %"int[]"* %indirectarg16 to i8*
+  %75 = bitcast %"int[]"* %vararg15 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %74, i8* align 8 %75, i32 16, i1 false)
+  %76 = call i32 @test.sum_us(%"int[]"* %indirectarg16)
+  %77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %76)
+  %78 = getelementptr inbounds [1 x i32], [1 x i32]* %varargslots18, i64 0, i64 0
+  store i32 1, i32* %78, align 4
+  %79 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 1
+  store i64 1, i64* %79, align 8
+  %80 = getelementptr inbounds %"int[]", %"int[]"* %vararg17, i32 0, i32 0
+  %81 = bitcast [1 x i32]* %varargslots18 to i32*
+  store i32* %81, i32** %80, align 8
+  %82 = bitcast %"int[]"* %indirectarg19 to i8*
+  %83 = bitcast %"int[]"* %vararg17 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %82, i8* align 8 %83, i32 16, i1 false)
+  %84 = call i32 @test.sum_us(%"int[]"* %indirectarg19)
+  %85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %84)
+  %86 = getelementptr inbounds %"int[]", %"int[]"* %vararg20, i32 0, i32 1
+  store i64 0, i64* %86, align 8
+  %87 = bitcast %"int[]"* %indirectarg21 to i8*
+  %88 = bitcast %"int[]"* %vararg20 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %87, i8* align 8 %88, i32 16, i1 false)
+  %89 = call i32 @test.sum_us(%"int[]"* %indirectarg21)
+  %90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i32 0, i32 0), i32 %89)
   store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %a1, align 8
   store i32 (double, %Bobo*)* null, i32 (double, %Bobo*)** %b2, align 8
   ret void
diff --git a/test/test_suite/initializer_lists/general_tests.c3t b/test/test_suite/initializer_lists/general_tests.c3t
index 6e8758cff..82b326767 100644
--- a/test/test_suite/initializer_lists/general_tests.c3t
+++ b/test/test_suite/initializer_lists/general_tests.c3t
@@ -63,27 +63,27 @@ entry:
   %baz = alloca [3 x %Baz], align 16
   %0 = bitcast %Baz* %ffe to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %0, i8* align 8 bitcast ({ i32, [4 x i8] }* @.__const to i8*), i32 8, i1 false)
-  %1 = bitcast [1 x i32]* %azz to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %1, i8 0, i64 4, i1 false)
-  %2 = bitcast [0 x i32]* %a to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %2, i8 0, i64 0, i1 false)
+  %1 = getelementptr inbounds [1 x i32], [1 x i32]* %azz, i64 0, i64 0
+  store i32 0, i32* %1, align 4
   store i32 33, i32* %foo2, align 4
   store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i8** %str, align 8
-  %3 = getelementptr inbounds [3 x i32], [3 x i32]* %literal, i64 0, i64 0
-  store i32 1, i32* %3, align 4
-  %4 = getelementptr inbounds [3 x i32], [3 x i32]* %literal, i64 0, i64 1
-  store i32 2, i32* %4, align 4
-  %5 = getelementptr inbounds [3 x i32], [3 x i32]* %literal, i64 0, i64 2
-  store i32 3, i32* %5, align 4
-  %6 = bitcast [3 x i32]* %literal to i32*
-  %7 = insertvalue %"int[]" undef, i32* %6, 0
-  %8 = insertvalue %"int[]" %7, i64 3, 1
-  %len = extractvalue %"int[]" %8, 1
+  %2 = getelementptr inbounds [3 x i32], [3 x i32]* %literal, i64 0, i64 0
+  store i32 1, i32* %2, align 4
+  %3 = getelementptr inbounds [3 x i32], [3 x i32]* %literal, i64 0, i64 1
+  store i32 2, i32* %3, align 4
+  %4 = getelementptr inbounds [3 x i32], [3 x i32]* %literal, i64 0, i64 2
+  store i32 3, i32* %4, align 4
+  %5 = bitcast [3 x i32]* %literal to i32*
+  %6 = insertvalue %"int[]" undef, i32* %5, 0
+  %7 = insertvalue %"int[]" %6, i64 3, 1
+  %len = extractvalue %"int[]" %7, 1
   %not = icmp eq i64 %len, 0
-  %9 = zext i1 %not to i8
-  store i8 %9, i8* %x, align 1
-  %10 = bitcast %Bar* %b to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %10, i8 0, i64 8, i1 false)
+  %8 = zext i1 %not to i8
+  store i8 %8, i8* %x, align 1
+  %9 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 0
+  store i32 0, i32* %9, align 4
+  %10 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 1
+  store i32 0, i32* %10, align 4
   %11 = bitcast %Baz* %z to i8*
   call void @llvm.memset.p0i8.i64(i8* align 8 %11, i8 0, i64 8, i1 false)
   store [0 x i32] zeroinitializer, [0 x i32]* %literal1, align 4
diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t
index 523cad75e..c622adf67 100644
--- a/test/test_suite/initializer_lists/subarrays.c3t
+++ b/test/test_suite/initializer_lists/subarrays.c3t
@@ -132,35 +132,35 @@ entry:
   %28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i32 0, i32 0), i32 %27)
   %29 = bitcast %Baz* %ffe to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %29, i8* align 8 bitcast ({ i32, [4 x i8] }* @.__const to i8*), i32 8, i1 false)
-  %30 = bitcast [1 x i32]* %azz to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %30, i8 0, i64 4, i1 false)
-  %31 = bitcast [0 x i32]* %a to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %31, i8 0, i64 0, i1 false)
-  %32 = getelementptr inbounds [3 x i32], [3 x i32]* %literal6, i64 0, i64 0
-  store i32 1, i32* %32, align 4
-  %33 = getelementptr inbounds [3 x i32], [3 x i32]* %literal6, i64 0, i64 1
-  store i32 2, i32* %33, align 4
-  %34 = getelementptr inbounds [3 x i32], [3 x i32]* %literal6, i64 0, i64 2
-  store i32 3, i32* %34, align 4
-  %35 = bitcast [3 x i32]* %literal6 to i32*
-  %36 = insertvalue %"int[]" undef, i32* %35, 0
-  %37 = insertvalue %"int[]" %36, i64 3, 1
-  %len = extractvalue %"int[]" %37, 1
+  %30 = getelementptr inbounds [1 x i32], [1 x i32]* %azz, i64 0, i64 0
+  store i32 0, i32* %30, align 4
+  %31 = getelementptr inbounds [3 x i32], [3 x i32]* %literal6, i64 0, i64 0
+  store i32 1, i32* %31, align 4
+  %32 = getelementptr inbounds [3 x i32], [3 x i32]* %literal6, i64 0, i64 1
+  store i32 2, i32* %32, align 4
+  %33 = getelementptr inbounds [3 x i32], [3 x i32]* %literal6, i64 0, i64 2
+  store i32 3, i32* %33, align 4
+  %34 = bitcast [3 x i32]* %literal6 to i32*
+  %35 = insertvalue %"int[]" undef, i32* %34, 0
+  %36 = insertvalue %"int[]" %35, i64 3, 1
+  %len = extractvalue %"int[]" %36, 1
   %not = icmp eq i64 %len, 0
-  %38 = zext i1 %not to i8
-  store i8 %38, i8* %xy, align 1
-  %39 = load i8, i8* %xy, align 1
-  %40 = trunc i8 %39 to i1
-  %not7 = xor i1 %40, true
+  %37 = zext i1 %not to i8
+  store i8 %37, i8* %xy, align 1
+  %38 = load i8, i8* %xy, align 1
+  %39 = trunc i8 %38 to i1
+  %not7 = xor i1 %39, true
   br i1 %not7, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %entry
-  %41 = call i32 @"std::io.println"(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0)) #3
+  %40 = call i32 @"std::io.println"(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0)) #3
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %entry
-  %42 = bitcast %Bar* %b to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %42, i8 0, i64 8, i1 false)
+  %41 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 0
+  store i32 0, i32* %41, align 4
+  %42 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 1
+  store i32 0, i32* %42, align 4
   %43 = bitcast %Baz* %z to i8*
   call void @llvm.memset.p0i8.i64(i8* align 8 %43, i8 0, i64 8, i1 false)
   store [0 x i32] zeroinitializer, [0 x i32]* %literal8, align 4
diff --git a/test/test_suite/initializer_lists/zero_init.c3t b/test/test_suite/initializer_lists/zero_init.c3t
index 1a7ef8387..686a52255 100644
--- a/test/test_suite/initializer_lists/zero_init.c3t
+++ b/test/test_suite/initializer_lists/zero_init.c3t
@@ -10,8 +10,15 @@ struct Bar
     int x;
     int y;
 }
+
+struct Mega
+{
+    int[10] z;
+}
+
 fn int test()
 {
+    Mega m = {};
     int[1] azz = {};
     int[*] a = {};
     Bar b = {};
@@ -24,17 +31,13 @@ fn int test()
 
 // #expect: zero_init.ll
 
+%Mega = type { [10 x i32] }
 %Bar = type { i32, i32 }
 %Baz = type { double }
-%"int[]" = type { i32*, i64 }
-%"Bar[]" = type { %Bar*, i64 }
 
-@Baz = linkonce_odr constant i8 1
-@Bar = linkonce_odr constant i8 1
-
-; Function Attrs: nounwind
 define i32 @zero_init.test() #0 {
 entry:
+  %m = alloca %Mega, align 4
   %azz = alloca [1 x i32], align 4
   %a = alloca [0 x i32], align 4
   %b = alloca %Bar, align 4
@@ -44,25 +47,27 @@ entry:
   %foo = alloca %"Bar[]", align 8
   %literal1 = alloca [0 x %Bar], align 4
   %baz = alloca [3 x %Baz], align 16
-  %0 = bitcast [1 x i32]* %azz to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 4, i1 false)
-  %1 = bitcast [0 x i32]* %a to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %1, i8 0, i64 0, i1 false)
-  %2 = bitcast %Bar* %b to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 4 %2, i8 0, i64 8, i1 false)
-  %3 = bitcast %Baz* %z to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 8 %3, i8 0, i64 8, i1 false)
+  %0 = bitcast %Mega* %m to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 0, i64 40, i1 false)
+  %1 = getelementptr inbounds [1 x i32], [1 x i32]* %azz, i64 0, i64 0
+  store i32 0, i32* %1, align 4
+  %2 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 0
+  store i32 0, i32* %2, align 4
+  %3 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 1
+  store i32 0, i32* %3, align 4
+  %4 = bitcast %Baz* %z to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 8 %4, i8 0, i64 8, i1 false)
   store [0 x i32] zeroinitializer, [0 x i32]* %literal, align 4
-  %4 = bitcast [0 x i32]* %literal to i32*
-  %5 = insertvalue %"int[]" undef, i32* %4, 0
-  %6 = insertvalue %"int[]" %5, i64 0, 1
-  store %"int[]" %6, %"int[]"* %sub, align 8
+  %5 = bitcast [0 x i32]* %literal to i32*
+  %6 = insertvalue %"int[]" undef, i32* %5, 0
+  %7 = insertvalue %"int[]" %6, i64 0, 1
+  store %"int[]" %7, %"int[]"* %sub, align 8
   store [0 x %Bar] zeroinitializer, [0 x %Bar]* %literal1, align 4
-  %7 = bitcast [0 x %Bar]* %literal1 to %Bar*
-  %8 = insertvalue %"Bar[]" undef, %Bar* %7, 0
-  %9 = insertvalue %"Bar[]" %8, i64 0, 1
-  store %"Bar[]" %9, %"Bar[]"* %foo, align 8
-  %10 = bitcast [3 x %Baz]* %baz to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 16 %10, i8 0, i64 24, i1 false)
+  %8 = bitcast [0 x %Bar]* %literal1 to %Bar*
+  %9 = insertvalue %"Bar[]" undef, %Bar* %8, 0
+  %10 = insertvalue %"Bar[]" %9, i64 0, 1
+  store %"Bar[]" %10, %"Bar[]"* %foo, align 8
+  %11 = bitcast [3 x %Baz]* %baz to i8*
+  call void @llvm.memset.p0i8.i64(i8* align 16 %11, i8 0, i64 24, i1 false)
   ret i32 1
 }
diff --git a/test/test_suite/macros/userland_bitcast.c3t b/test/test_suite/macros/userland_bitcast.c3t
index 6cc4c1830..ce085654d 100644
--- a/test/test_suite/macros/userland_bitcast.c3t
+++ b/test/test_suite/macros/userland_bitcast.c3t
@@ -92,13 +92,21 @@ entry:
   %to = alloca i16*, align 8
   %i = alloca i64, align 8
   store i16 %0, i16* %x, align 2
-  %1 = bitcast %Foo* %z to i8*
-  call void @llvm.memset.p0i8.i64(i8* align 2 %1, i8 0, i64 8, i1 false)
-  %2 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 0
-  %3 = load i16, i16* %x, align 2
-  store i16 %3, i16* %2, align 2
-  %4 = load %Foo, %Foo* %z, align 2
-  store %Foo %4, %Foo* %expr, align 2
+  %1 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 0
+  store i16 0, i16* %1, align 2
+  %2 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 1
+  store i8 0, i8* %2, align 2
+  %3 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 2
+  store i8 0, i8* %3, align 1
+  %4 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 3
+  store i16 0, i16* %4, align 2
+  %5 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 4
+  store i16 0, i16* %5, align 2
+  %6 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 0
+  %7 = load i16, i16* %x, align 2
+  store i16 %7, i16* %6, align 2
+  %8 = load %Foo, %Foo* %z, align 2
+  store %Foo %8, %Foo* %expr, align 2
   %ptrptr = bitcast %Foo* %expr to i16*
   store i16* %ptrptr, i16** %b, align 8
   %ptrptr2 = bitcast i64* %x1 to i16*
@@ -107,30 +115,30 @@ entry:
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
-  %5 = load i64, i64* %i, align 8
-  %lt = icmp ult i64 %5, 8
+  %9 = load i64, i64* %i, align 8
+  %lt = icmp ult i64 %9, 8
   br i1 %lt, label %for.body, label %for.exit
 
 for.body:                                         ; preds = %for.cond
-  %6 = load i16*, i16** %to, align 8
-  %7 = load i64, i64* %i, align 8
-  %ptroffset = getelementptr inbounds i16, i16* %6, i64 %7
-  %8 = load i16*, i16** %b, align 8
-  %9 = load i64, i64* %i, align 8
-  %ptroffset3 = getelementptr inbounds i16, i16* %8, i64 %9
-  %10 = load i16, i16* %ptroffset3, align 2
-  store i16 %10, i16* %ptroffset, align 2
+  %10 = load i16*, i16** %to, align 8
+  %11 = load i64, i64* %i, align 8
+  %ptroffset = getelementptr inbounds i16, i16* %10, i64 %11
+  %12 = load i16*, i16** %b, align 8
+  %13 = load i64, i64* %i, align 8
+  %ptroffset3 = getelementptr inbounds i16, i16* %12, i64 %13
+  %14 = load i16, i16* %ptroffset3, align 2
+  store i16 %14, i16* %ptroffset, align 2
   br label %for.inc
 
 for.inc:                                          ; preds = %for.body
-  %11 = load i64, i64* %i, align 8
-  %add = add i64 %11, 2
+  %15 = load i64, i64* %i, align 8
+  %add = add i64 %15, 2
   store i64 %add, i64* %i, align 8
   br label %for.cond
 
 for.exit:                                         ; preds = %for.cond
-  %12 = load i64, i64* %x1, align 8
-  ret i64 %12
+  %16 = load i64, i64* %x1, align 8
+  ret i64 %16
 }
 
 ; Function Attrs: nounwind
diff --git a/test/test_suite/statements/foreach_break.c3t b/test/test_suite/statements/foreach_break.c3t
index 8080720a8..3ecb37fcd 100644
--- a/test/test_suite/statements/foreach_break.c3t
+++ b/test/test_suite/statements/foreach_break.c3t
@@ -1,3 +1,4 @@
+// #target: x64-darwin
 module test;
 
 fn void test()
@@ -14,45 +15,57 @@ fn void test()
 
 // #expect: test.ll
 
+define void @test.test() #0 {
+entry:
+  %x = alloca [3 x i32], align 4
+  %g = alloca i32, align 4
+  %idx = alloca i64, align 8
+  %z = alloca i32, align 4
+  %0 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 0
+  store i32 0, i32* %0, align 4
+  %1 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 1
+  store i32 0, i32* %1, align 4
+  %2 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 2
+  store i32 0, i32* %2, align 4
   store i32 0, i32* %g, align 4
   store i64 0, i64* %idx, align 8
   br label %foreach.cond
 
 foreach.cond:                                     ; preds = %foreach.inc, %entry
-  %1 = load i64, i64* %idx, align 8
-  %lt = icmp ult i64 %1, 3
+  %3 = load i64, i64* %idx, align 8
+  %lt = icmp ult i64 %3, 3
   br i1 %lt, label %foreach.body, label %foreach.exit
 
 foreach.body:                                     ; preds = %foreach.cond
-  %ptroffset = getelementptr inbounds i32, [3 x i32]* %x, i64 %1
-  %2 = load i32, i32* %ptroffset, align 4
-  store i32 %2, i32* %z, align 4
-  %3 = load i32, i32* %z, align 4
-  %gt = icmp sgt i32 %3, 0
+  %ptroffset = getelementptr inbounds i32, [3 x i32]* %x, i64 %3
+  %4 = load i32, i32* %ptroffset, align 4
+  store i32 %4, i32* %z, align 4
+  %5 = load i32, i32* %z, align 4
+  %gt = icmp sgt i32 %5, 0
   br i1 %gt, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %foreach.body
   br label %foreach.exit
 
 if.exit:                                          ; preds = %foreach.body
-  %4 = load i32, i32* %z, align 4
-  %eq = icmp eq i32 %4, 1
+  %6 = load i32, i32* %z, align 4
+  %eq = icmp eq i32 %6, 1
   br i1 %eq, label %if.then1, label %if.exit2
 
 if.then1:                                         ; preds = %if.exit
   br label %foreach.inc
 
 if.exit2:                                         ; preds = %if.exit
-  %5 = load i32, i32* %g, align 4
-  %6 = load i32, i32* %z, align 4
-  %add = add i32 %5, %6
+  %7 = load i32, i32* %g, align 4
+  %8 = load i32, i32* %z, align 4
+  %add = add i32 %7, %8
   store i32 %add, i32* %g, align 4
   br label %foreach.inc
 
 foreach.inc:                                      ; preds = %if.exit2, %if.then1
-  %7 = load i64, i64* %idx, align 8
-  %8 = add i64 %7, 1
-  store i64 %8, i64* %idx, align 8
+  %9 = load i64, i64* %idx, align 8
+  %10 = add i64 %9, 1
+  store i64 %10, i64* %idx, align 8
   br label %foreach.cond
 
 foreach.exit:                                     ; preds = %if.then, %foreach.cond