shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 12:01:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use element initialization for <= 16 bytes structs and arrays.

Browse Source
This commit is contained in:
Christoffer Lerno
2021-11-18 23:23:55 +01:00
parent 4d4bbbdebc
commit a4a6ea16ce
15 changed files with 507 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/compiler/llvm_codegen.c
View File

@@ -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);
}

1
src/compiler/llvm_codegen_c_abi_x64.c
View File

@@ -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;

17
test/test_suite/abi/regcall_expand.c3t
View File

@@ -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
}

62
test/test_suite/abi/vec2_aarch64.c3t
View File

@@ -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
}

101
test/test_suite/abi/vec2_x64.c3t
View File

@@ -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
}

30
test/test_suite/arrays/array_casts.c3t
View File

@@ -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
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
}

28
test/test_suite/builtins/simple_builtins.c3t
View File

@@ -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
}

72
test/test_suite/expressions/pointer_access.c3t
View File

@@ -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
}

182
test/test_suite/functions/test_regression.c3t
View File

@@ -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

158
test/test_suite/functions/test_regression_mingw.c3t
View File

@@ -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

36
test/test_suite/initializer_lists/general_tests.c3t
View File

@@ -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

44
test/test_suite/initializer_lists/subarrays.c3t
View File

@@ -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

53
test/test_suite/initializer_lists/zero_init.c3t
View File

@@ -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
}

50
test/test_suite/macros/userland_bitcast.c3t
View File

@@ -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

43
test/test_suite/statements/foreach_break.c3t
View File

@@ -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