mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
482 lines
18 KiB
C
482 lines
18 KiB
C
// #target: macos-x64
|
|
module foo;
|
|
|
|
struct Foo
|
|
{
|
|
int[3] a;
|
|
}
|
|
|
|
extern fn void printf(char*, ...);
|
|
|
|
macro int* Foo.@operator_element_at_ref(Foo &f, int a) @operator(&[])
|
|
{
|
|
return &f.a[a];
|
|
}
|
|
|
|
macro int Foo.@operator_len(Foo &f) @operator(len)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
macro int Foo.@operator_element_at(Foo &f, int a) @operator([])
|
|
{
|
|
return f.a[a];
|
|
}
|
|
|
|
fn int[5] getFields()
|
|
{
|
|
printf("getFields\n");
|
|
return int[5] { 3, 5, 2, 10, 111};
|
|
}
|
|
fn Foo *call(Foo *f)
|
|
{
|
|
printf("Call made\n");
|
|
return f;
|
|
}
|
|
fn void main()
|
|
{
|
|
Foo x = { { 1, 5, 7} };
|
|
printf("%d %d %d\n", x[0], x[1], x[2]);
|
|
foreach (i, int y : *call(&x))
|
|
{
|
|
printf("Hello %d: %d\n", i, y);
|
|
}
|
|
foreach (i, int* &y : x)
|
|
{
|
|
*y += 1;
|
|
printf("Hello %d: %d\n", i, *y);
|
|
}
|
|
foreach (i, int y : x)
|
|
{
|
|
printf("After one %d: %d\n", i, y);
|
|
}
|
|
|
|
foreach (i, int y : &x)
|
|
{
|
|
printf("By pointer %d: %d\n", i, y);
|
|
}
|
|
|
|
foreach (i, int y : x)
|
|
{
|
|
printf("Adding %d: %d\n", i, y);
|
|
i++;
|
|
}
|
|
|
|
foreach(i, y : int[5] { 1, 2, 10, 111, 123 } )
|
|
{
|
|
printf("Adding %d: %d\n", i, y);
|
|
i++;
|
|
}
|
|
foreach(i, y : getFields() )
|
|
{
|
|
printf("Pull value %d: %d\n", i, y);
|
|
}
|
|
foreach(i, y : &&getFields())
|
|
{
|
|
printf("Pull value tempptr %d: %d\n", i, y);
|
|
}
|
|
printf("%d %d\n", x[0], x[1]);
|
|
int* y = &x[1];
|
|
*y += 1;
|
|
printf("%d %d\n", x[0], x[1]);
|
|
}
|
|
|
|
/* #expect: foo.ll
|
|
|
|
%Foo = type { [3 x i32] }
|
|
|
|
@"ct$foo_Foo" = linkonce constant %.introspect { i8 10, i64 12, i64 0, i64 1, [0 x i64] zeroinitializer }, align 8
|
|
@.str = private unnamed_addr constant [11 x i8] c"getFields\0A\00", align 1
|
|
@.str.1 = private unnamed_addr constant [11 x i8] c"Call made\0A\00", align 1
|
|
@.__const = private unnamed_addr constant %Foo { [3 x i32] [i32 1, i32 5, i32 7] }, align 4
|
|
@.str.2 = private unnamed_addr constant [10 x i8] c"%d %d %d\0A\00", align 1
|
|
@.str.3 = private unnamed_addr constant [14 x i8] c"Hello %d: %d\0A\00", align 1
|
|
@.str.4 = private unnamed_addr constant [14 x i8] c"Hello %d: %d\0A\00", align 1
|
|
@.str.5 = private unnamed_addr constant [18 x i8] c"After one %d: %d\0A\00", align 1
|
|
@.str.6 = private unnamed_addr constant [19 x i8] c"By pointer %d: %d\0A\00", align 1
|
|
@.str.7 = private unnamed_addr constant [15 x i8] c"Adding %d: %d\0A\00", align 1
|
|
@.__const.8 = private unnamed_addr constant [5 x i32] [i32 1, i32 2, i32 10, i32 111, i32 123], align 16
|
|
@.str.9 = private unnamed_addr constant [15 x i8] c"Adding %d: %d\0A\00", align 1
|
|
@.str.10 = private unnamed_addr constant [19 x i8] c"Pull value %d: %d\0A\00", align 1
|
|
@.str.11 = private unnamed_addr constant [27 x i8] c"Pull value tempptr %d: %d\0A\00", align 1
|
|
@.str.12 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
|
|
@.str.13 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
|
|
|
|
define void @foo_getFields([5 x i32]* noalias sret([5 x i32]) align 4 %0) #0 {
|
|
entry:
|
|
%literal = alloca [5 x i32], align 16
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0))
|
|
%1 = getelementptr inbounds [5 x i32], [5 x i32]* %literal, i64 0, i64 0
|
|
store i32 3, i32* %1, align 4
|
|
%2 = getelementptr inbounds [5 x i32], [5 x i32]* %literal, i64 0, i64 1
|
|
store i32 5, i32* %2, align 4
|
|
%3 = getelementptr inbounds [5 x i32], [5 x i32]* %literal, i64 0, i64 2
|
|
store i32 2, i32* %3, align 4
|
|
%4 = getelementptr inbounds [5 x i32], [5 x i32]* %literal, i64 0, i64 3
|
|
store i32 10, i32* %4, align 4
|
|
%5 = getelementptr inbounds [5 x i32], [5 x i32]* %literal, i64 0, i64 4
|
|
store i32 111, i32* %5, align 4
|
|
%6 = bitcast [5 x i32]* %0 to i8*
|
|
%7 = bitcast [5 x i32]* %literal to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %6, i8* align 4 %7, i32 20, i1 false)
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define %Foo* @foo_call(%Foo* %0) #0 {
|
|
entry:
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0))
|
|
ret %Foo* %0
|
|
}
|
|
define void @foo_main() #0 {
|
|
entry:
|
|
%x = alloca %Foo, align 4
|
|
%a = alloca i32, align 4
|
|
%a1 = alloca i32, align 4
|
|
%a3 = alloca i32, align 4
|
|
%.anon = alloca %Foo*, align 8
|
|
%.anon5 = alloca i32, align 4
|
|
%.anon6 = alloca i32, align 4
|
|
%i = alloca i32, align 4
|
|
%y = alloca i32, align 4
|
|
%a7 = alloca i32, align 4
|
|
%.anon9 = alloca i32, align 4
|
|
%.anon10 = alloca i32, align 4
|
|
%i14 = alloca i32, align 4
|
|
%y15 = alloca i32*, align 8
|
|
%a16 = alloca i32, align 4
|
|
%.anon21 = alloca i32, align 4
|
|
%.anon22 = alloca i32, align 4
|
|
%i26 = alloca i32, align 4
|
|
%y27 = alloca i32, align 4
|
|
%a28 = alloca i32, align 4
|
|
%.anon32 = alloca i32, align 4
|
|
%.anon33 = alloca i32, align 4
|
|
%i37 = alloca i32, align 4
|
|
%y38 = alloca i32, align 4
|
|
%a39 = alloca i32, align 4
|
|
%.anon43 = alloca i32, align 4
|
|
%.anon44 = alloca i32, align 4
|
|
%i48 = alloca i32, align 4
|
|
%y49 = alloca i32, align 4
|
|
%a50 = alloca i32, align 4
|
|
%.anon55 = alloca [5 x i32], align 16
|
|
%.anon56 = alloca i64, align 8
|
|
%i59 = alloca i64, align 8
|
|
%y60 = alloca i32, align 4
|
|
%.anon64 = alloca [5 x i32], align 16
|
|
%.anon65 = alloca i64, align 8
|
|
%i69 = alloca i64, align 8
|
|
%y70 = alloca i32, align 4
|
|
%.anon73 = alloca [5 x i32]*, align 8
|
|
%sretparam = alloca [5 x i32], align 4
|
|
%.anon74 = alloca i64, align 8
|
|
%i78 = alloca i64, align 8
|
|
%y79 = alloca i32, align 4
|
|
%a82 = alloca i32, align 4
|
|
%a84 = alloca i32, align 4
|
|
%y86 = alloca i32*, align 8
|
|
%a87 = alloca i32, align 4
|
|
%a90 = alloca i32, align 4
|
|
%a92 = alloca i32, align 4
|
|
%0 = bitcast %Foo* %x to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast (%Foo* @.__const to i8*), i32 12, i1 false)
|
|
store i32 0, i32* %a, align 4
|
|
%1 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%2 = load i32, i32* %a, align 4
|
|
%sisiext = sext i32 %2 to i64
|
|
%3 = getelementptr inbounds [3 x i32], [3 x i32]* %1, i64 0, i64 %sisiext
|
|
%4 = load i32, i32* %3, align 4
|
|
store i32 1, i32* %a1, align 4
|
|
%5 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%6 = load i32, i32* %a1, align 4
|
|
%sisiext2 = sext i32 %6 to i64
|
|
%7 = getelementptr inbounds [3 x i32], [3 x i32]* %5, i64 0, i64 %sisiext2
|
|
%8 = load i32, i32* %7, align 4
|
|
store i32 2, i32* %a3, align 4
|
|
%9 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%10 = load i32, i32* %a3, align 4
|
|
%sisiext4 = sext i32 %10 to i64
|
|
%11 = getelementptr inbounds [3 x i32], [3 x i32]* %9, i64 0, i64 %sisiext4
|
|
%12 = load i32, i32* %11, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i32 %4, i32 %8, i32 %12)
|
|
%13 = call %Foo* @foo_call(%Foo* %x)
|
|
store %Foo* %13, %Foo** %.anon, align 8
|
|
store i32 3, i32* %.anon5, align 4
|
|
store i32 0, i32* %.anon6, align 4
|
|
br label %loop.cond
|
|
|
|
loop.cond: ; preds = %loop.body, %entry
|
|
%14 = load i32, i32* %.anon6, align 4
|
|
%15 = load i32, i32* %.anon5, align 4
|
|
%lt = icmp slt i32 %14, %15
|
|
br i1 %lt, label %loop.body, label %loop.exit
|
|
|
|
loop.body: ; preds = %loop.cond
|
|
%16 = load i32, i32* %.anon6, align 4
|
|
store i32 %16, i32* %i, align 4
|
|
%17 = load %Foo*, %Foo** %.anon, align 8
|
|
%18 = load i32, i32* %.anon6, align 4
|
|
store i32 %18, i32* %a7, align 4
|
|
%19 = getelementptr inbounds %Foo, %Foo* %17, i32 0, i32 0
|
|
%20 = load i32, i32* %a7, align 4
|
|
%sisiext8 = sext i32 %20 to i64
|
|
%21 = getelementptr inbounds [3 x i32], [3 x i32]* %19, i64 0, i64 %sisiext8
|
|
%22 = load i32, i32* %21, align 4
|
|
store i32 %22, i32* %y, align 4
|
|
%23 = load i32, i32* %i, align 4
|
|
%24 = load i32, i32* %y, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i32 0, i32 0), i32 %23, i32 %24)
|
|
%25 = load i32, i32* %.anon6, align 4
|
|
%add = add i32 %25, 1
|
|
store i32 %add, i32* %.anon6, align 4
|
|
br label %loop.cond
|
|
|
|
loop.exit: ; preds = %loop.cond
|
|
store i32 3, i32* %.anon9, align 4
|
|
store i32 0, i32* %.anon10, align 4
|
|
br label %loop.cond11
|
|
|
|
loop.cond11: ; preds = %loop.body13, %loop.exit
|
|
%26 = load i32, i32* %.anon10, align 4
|
|
%27 = load i32, i32* %.anon9, align 4
|
|
%lt12 = icmp slt i32 %26, %27
|
|
br i1 %lt12, label %loop.body13, label %loop.exit20
|
|
|
|
loop.body13: ; preds = %loop.cond11
|
|
%28 = load i32, i32* %.anon10, align 4
|
|
store i32 %28, i32* %i14, align 4
|
|
%29 = load i32, i32* %.anon10, align 4
|
|
store i32 %29, i32* %a16, align 4
|
|
%30 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%31 = load i32, i32* %a16, align 4
|
|
%sisiext17 = sext i32 %31 to i64
|
|
%32 = getelementptr inbounds [3 x i32], [3 x i32]* %30, i64 0, i64 %sisiext17
|
|
store i32* %32, i32** %y15, align 8
|
|
%33 = load i32*, i32** %y15, align 8
|
|
%34 = load i32, i32* %33, align 8
|
|
%add18 = add i32 %34, 1
|
|
store i32 %add18, i32* %33, align 8
|
|
%35 = load i32, i32* %i14, align 4
|
|
%36 = load i32*, i32** %y15, align 8
|
|
%37 = load i32, i32* %36, align 8
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i32 %35, i32 %37)
|
|
%38 = load i32, i32* %.anon10, align 4
|
|
%add19 = add i32 %38, 1
|
|
store i32 %add19, i32* %.anon10, align 4
|
|
br label %loop.cond11
|
|
|
|
loop.exit20: ; preds = %loop.cond11
|
|
store i32 3, i32* %.anon21, align 4
|
|
store i32 0, i32* %.anon22, align 4
|
|
br label %loop.cond23
|
|
|
|
loop.cond23: ; preds = %loop.body25, %loop.exit20
|
|
%39 = load i32, i32* %.anon22, align 4
|
|
%40 = load i32, i32* %.anon21, align 4
|
|
%lt24 = icmp slt i32 %39, %40
|
|
br i1 %lt24, label %loop.body25, label %loop.exit31
|
|
|
|
loop.body25: ; preds = %loop.cond23
|
|
%41 = load i32, i32* %.anon22, align 4
|
|
store i32 %41, i32* %i26, align 4
|
|
%42 = load i32, i32* %.anon22, align 4
|
|
store i32 %42, i32* %a28, align 4
|
|
%43 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%44 = load i32, i32* %a28, align 4
|
|
%sisiext29 = sext i32 %44 to i64
|
|
%45 = getelementptr inbounds [3 x i32], [3 x i32]* %43, i64 0, i64 %sisiext29
|
|
%46 = load i32, i32* %45, align 4
|
|
store i32 %46, i32* %y27, align 4
|
|
%47 = load i32, i32* %i26, align 4
|
|
%48 = load i32, i32* %y27, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i32 0, i32 0), i32 %47, i32 %48)
|
|
%49 = load i32, i32* %.anon22, align 4
|
|
%add30 = add i32 %49, 1
|
|
store i32 %add30, i32* %.anon22, align 4
|
|
br label %loop.cond23
|
|
|
|
loop.exit31: ; preds = %loop.cond23
|
|
store i32 3, i32* %.anon32, align 4
|
|
store i32 0, i32* %.anon33, align 4
|
|
br label %loop.cond34
|
|
|
|
loop.cond34: ; preds = %loop.body36, %loop.exit31
|
|
%50 = load i32, i32* %.anon33, align 4
|
|
%51 = load i32, i32* %.anon32, align 4
|
|
%lt35 = icmp slt i32 %50, %51
|
|
br i1 %lt35, label %loop.body36, label %loop.exit42
|
|
|
|
loop.body36: ; preds = %loop.cond34
|
|
%52 = load i32, i32* %.anon33, align 4
|
|
store i32 %52, i32* %i37, align 4
|
|
%53 = load i32, i32* %.anon33, align 4
|
|
store i32 %53, i32* %a39, align 4
|
|
%54 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%55 = load i32, i32* %a39, align 4
|
|
%sisiext40 = sext i32 %55 to i64
|
|
%56 = getelementptr inbounds [3 x i32], [3 x i32]* %54, i64 0, i64 %sisiext40
|
|
%57 = load i32, i32* %56, align 4
|
|
store i32 %57, i32* %y38, align 4
|
|
%58 = load i32, i32* %i37, align 4
|
|
%59 = load i32, i32* %y38, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i32 0, i32 0), i32 %58, i32 %59)
|
|
%60 = load i32, i32* %.anon33, align 4
|
|
%add41 = add i32 %60, 1
|
|
store i32 %add41, i32* %.anon33, align 4
|
|
br label %loop.cond34
|
|
|
|
loop.exit42: ; preds = %loop.cond34
|
|
store i32 3, i32* %.anon43, align 4
|
|
store i32 0, i32* %.anon44, align 4
|
|
br label %loop.cond45
|
|
|
|
loop.cond45: ; preds = %loop.body47, %loop.exit42
|
|
%61 = load i32, i32* %.anon44, align 4
|
|
%62 = load i32, i32* %.anon43, align 4
|
|
%lt46 = icmp slt i32 %61, %62
|
|
br i1 %lt46, label %loop.body47, label %loop.exit54
|
|
|
|
loop.body47: ; preds = %loop.cond45
|
|
%63 = load i32, i32* %.anon44, align 4
|
|
store i32 %63, i32* %i48, align 4
|
|
%64 = load i32, i32* %.anon44, align 4
|
|
store i32 %64, i32* %a50, align 4
|
|
%65 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%66 = load i32, i32* %a50, align 4
|
|
%sisiext51 = sext i32 %66 to i64
|
|
%67 = getelementptr inbounds [3 x i32], [3 x i32]* %65, i64 0, i64 %sisiext51
|
|
%68 = load i32, i32* %67, align 4
|
|
store i32 %68, i32* %y49, align 4
|
|
%69 = load i32, i32* %i48, align 4
|
|
%70 = load i32, i32* %y49, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i32 0, i32 0), i32 %69, i32 %70)
|
|
%71 = load i32, i32* %i48, align 4
|
|
%add52 = add i32 %71, 1
|
|
store i32 %add52, i32* %i48, align 4
|
|
%72 = load i32, i32* %.anon44, align 4
|
|
%add53 = add i32 %72, 1
|
|
store i32 %add53, i32* %.anon44, align 4
|
|
br label %loop.cond45
|
|
|
|
loop.exit54: ; preds = %loop.cond45
|
|
%73 = bitcast [5 x i32]* %.anon55 to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %73, i8* align 16 bitcast ([5 x i32]* @.__const.8 to i8*), i32 20, i1 false)
|
|
store i64 0, i64* %.anon56, align 8
|
|
br label %loop.cond57
|
|
|
|
loop.cond57: ; preds = %loop.body58, %loop.exit54
|
|
%74 = load i64, i64* %.anon56, align 8
|
|
%gt = icmp ugt i64 5, %74
|
|
br i1 %gt, label %loop.body58, label %loop.exit63
|
|
|
|
loop.body58: ; preds = %loop.cond57
|
|
%75 = load i64, i64* %.anon56, align 8
|
|
store i64 %75, i64* %i59, align 8
|
|
%76 = load i64, i64* %.anon56, align 8
|
|
%77 = getelementptr inbounds [5 x i32], [5 x i32]* %.anon55, i64 0, i64 %76
|
|
%78 = load i32, i32* %77, align 4
|
|
store i32 %78, i32* %y60, align 4
|
|
%79 = load i64, i64* %i59, align 8
|
|
%80 = load i32, i32* %y60, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i32 0, i32 0), i64 %79, i32 %80)
|
|
%81 = load i64, i64* %i59, align 8
|
|
%add61 = add i64 %81, 1
|
|
store i64 %add61, i64* %i59, align 8
|
|
%82 = load i64, i64* %.anon56, align 8
|
|
%add62 = add i64 %82, 1
|
|
store i64 %add62, i64* %.anon56, align 8
|
|
br label %loop.cond57
|
|
|
|
loop.exit63: ; preds = %loop.cond57
|
|
call void @foo_getFields([5 x i32]* sret([5 x i32]) align 4 %.anon64)
|
|
store i64 0, i64* %.anon65, align 8
|
|
br label %loop.cond66
|
|
|
|
loop.cond66: ; preds = %loop.body68, %loop.exit63
|
|
%83 = load i64, i64* %.anon65, align 8
|
|
%gt67 = icmp ugt i64 5, %83
|
|
br i1 %gt67, label %loop.body68, label %loop.exit72
|
|
|
|
loop.body68: ; preds = %loop.cond66
|
|
%84 = load i64, i64* %.anon65, align 8
|
|
store i64 %84, i64* %i69, align 8
|
|
%85 = load i64, i64* %.anon65, align 8
|
|
%86 = getelementptr inbounds [5 x i32], [5 x i32]* %.anon64, i64 0, i64 %85
|
|
%87 = load i32, i32* %86, align 4
|
|
store i32 %87, i32* %y70, align 4
|
|
%88 = load i64, i64* %i69, align 8
|
|
%89 = load i32, i32* %y70, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i32 0, i32 0), i64 %88, i32 %89)
|
|
%90 = load i64, i64* %.anon65, align 8
|
|
%add71 = add i64 %90, 1
|
|
store i64 %add71, i64* %.anon65, align 8
|
|
br label %loop.cond66
|
|
|
|
loop.exit72: ; preds = %loop.cond66
|
|
call void @foo_getFields([5 x i32]* sret([5 x i32]) align 4 %sretparam)
|
|
store [5 x i32]* %sretparam, [5 x i32]** %.anon73, align 8
|
|
store i64 0, i64* %.anon74, align 8
|
|
br label %loop.cond75
|
|
|
|
loop.cond75: ; preds = %loop.body77, %loop.exit72
|
|
%91 = load i64, i64* %.anon74, align 8
|
|
%gt76 = icmp ugt i64 5, %91
|
|
br i1 %gt76, label %loop.body77, label %loop.exit81
|
|
|
|
loop.body77: ; preds = %loop.cond75
|
|
%92 = load i64, i64* %.anon74, align 8
|
|
store i64 %92, i64* %i78, align 8
|
|
%93 = load [5 x i32]*, [5 x i32]** %.anon73, align 8
|
|
%94 = load i64, i64* %.anon74, align 8
|
|
%95 = getelementptr inbounds [5 x i32], [5 x i32]* %93, i64 0, i64 %94
|
|
%96 = load i32, i32* %95, align 4
|
|
store i32 %96, i32* %y79, align 4
|
|
%97 = load i64, i64* %i78, align 8
|
|
%98 = load i32, i32* %y79, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i32 0, i32 0), i64 %97, i32 %98)
|
|
%99 = load i64, i64* %.anon74, align 8
|
|
%add80 = add i64 %99, 1
|
|
store i64 %add80, i64* %.anon74, align 8
|
|
br label %loop.cond75
|
|
|
|
loop.exit81: ; preds = %loop.cond75
|
|
store i32 0, i32* %a82, align 4
|
|
%100 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%101 = load i32, i32* %a82, align 4
|
|
%sisiext83 = sext i32 %101 to i64
|
|
%102 = getelementptr inbounds [3 x i32], [3 x i32]* %100, i64 0, i64 %sisiext83
|
|
%103 = load i32, i32* %102, align 4
|
|
store i32 1, i32* %a84, align 4
|
|
%104 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%105 = load i32, i32* %a84, align 4
|
|
%sisiext85 = sext i32 %105 to i64
|
|
%106 = getelementptr inbounds [3 x i32], [3 x i32]* %104, i64 0, i64 %sisiext85
|
|
%107 = load i32, i32* %106, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i32 0, i32 0), i32 %103, i32 %107)
|
|
store i32 1, i32* %a87, align 4
|
|
%108 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%109 = load i32, i32* %a87, align 4
|
|
%sisiext88 = sext i32 %109 to i64
|
|
%110 = getelementptr inbounds [3 x i32], [3 x i32]* %108, i64 0, i64 %sisiext88
|
|
store i32* %110, i32** %y86, align 8
|
|
%111 = load i32*, i32** %y86, align 8
|
|
%112 = load i32, i32* %111, align 8
|
|
%add89 = add i32 %112, 1
|
|
store i32 %add89, i32* %111, align 8
|
|
store i32 0, i32* %a90, align 4
|
|
%113 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%114 = load i32, i32* %a90, align 4
|
|
%sisiext91 = sext i32 %114 to i64
|
|
%115 = getelementptr inbounds [3 x i32], [3 x i32]* %113, i64 0, i64 %sisiext91
|
|
%116 = load i32, i32* %115, align 4
|
|
store i32 1, i32* %a92, align 4
|
|
%117 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
|
|
%118 = load i32, i32* %a92, align 4
|
|
%sisiext93 = sext i32 %118 to i64
|
|
%119 = getelementptr inbounds [3 x i32], [3 x i32]* %117, i64 0, i64 %sisiext93
|
|
%120 = load i32, i32* %119, align 4
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.13, i32 0, i32 0), i32 %116, i32 %120)
|
|
ret void
|
|
}
|