mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 20:11:17 +00:00
364 lines
17 KiB
C
364 lines
17 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
|
|
bitstruct Test : int @bigendian
|
|
{
|
|
ushort a : 0..15;
|
|
ushort b : 16..31;
|
|
}
|
|
|
|
bitstruct Test2 : char[4] @bigendian
|
|
{
|
|
ushort a : 0..15;
|
|
ushort b : 16..31;
|
|
}
|
|
|
|
fn void main()
|
|
{
|
|
IntBE x;
|
|
x.val = 123;
|
|
|
|
io::printf("BE 123 => %d (%d)\n", (int)x, x.val);
|
|
Test abc = { .a = 0x1234, .b = 0x5678 };
|
|
Test2 abc2 = { .a = 0x1234, .b = 0x5678 };
|
|
char[4]* z = (char[4]*)&abc;
|
|
char[4]* z2 = (char[4]*)&abc2;
|
|
foreach (d : z2) io::printf(" %x", d);
|
|
io::println("");
|
|
foreach (d : z) io::printf(" %x", d);
|
|
io::println("");
|
|
io::printfln("abc.a = %x", abc.a);
|
|
abc.a = 0x1234;
|
|
abc.b = 0x5678;
|
|
io::printfln("->abc.a = %x", abc.a);
|
|
foreach (d : z) io::printf(" %x", d);
|
|
io::println("");
|
|
|
|
IntLE y;
|
|
y.val = 123;
|
|
io::printf("LE 123 => %d (%d)\n", (int)y, y.val);
|
|
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
%0 = load i32, i32* %x, align 4
|
|
%1 = call i32 @llvm.bswap.i32(i32 %0)
|
|
store i32 2063597568, i32* %x, align 4
|
|
store %"char[]" { i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i64 18 }, %"char[]"* %taddr, align 8
|
|
%2 = bitcast %"char[]"* %taddr to { i8*, i64 }*
|
|
%3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0
|
|
%lo = load i8*, i8** %3, align 8
|
|
%4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1
|
|
%hi = load i64, i64* %4, align 8
|
|
%5 = bitcast i32* %x to i8*
|
|
%6 = insertvalue %variant undef, i8* %5, 0
|
|
%7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
|
|
%8 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0
|
|
store %variant %7, %variant* %8, align 16
|
|
%9 = load i32, i32* %x, align 4
|
|
%10 = call i32 @llvm.bswap.i32(i32 %9)
|
|
store i32 %10, i32* %taddr1, align 4
|
|
%11 = bitcast i32* %taddr1 to i8*
|
|
%12 = insertvalue %variant undef, i8* %11, 0
|
|
%13 = insertvalue %variant %12, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
|
|
%14 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1
|
|
store %variant %13, %variant* %14, align 16
|
|
%15 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
|
|
store i64 2, i64* %15, align 8
|
|
%16 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
|
|
%17 = bitcast [2 x %variant]* %varargslots to %variant*
|
|
store %variant* %17, %variant** %16, align 8
|
|
%18 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
|
|
%19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0
|
|
%lo2 = load i8*, i8** %19, align 8
|
|
%20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1
|
|
%hi3 = load i64, i64* %20, align 8
|
|
%21 = call i64 @std_io_printf(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3)
|
|
%not_err = icmp eq i64 %21, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
store i32 873625686, i32* %abc, align 4
|
|
store [4 x i8] c"\124Vx", [4 x i8]* %abc2, align 1
|
|
%ptrptr = bitcast i32* %abc to [4 x i8]*
|
|
store [4 x i8]* %ptrptr, [4 x i8]** %z, align 8
|
|
store [4 x i8]* %abc2, [4 x i8]** %z2, align 8
|
|
%22 = load [4 x i8]*, [4 x i8]** %z2, align 8
|
|
store [4 x i8]* %22, [4 x i8]** %.anon, align 8
|
|
store i64 0, i64* %.anon4, align 8
|
|
br label %loop.cond
|
|
|
|
loop.cond: ; preds = %voiderr15, %voiderr
|
|
%23 = load i64, i64* %.anon4, align 8
|
|
%gt = icmp ugt i64 4, %23
|
|
br i1 %gt, label %loop.body, label %loop.exit
|
|
|
|
loop.body: ; preds = %loop.cond
|
|
%24 = load [4 x i8]*, [4 x i8]** %.anon, align 8
|
|
%25 = load i64, i64* %.anon4, align 8
|
|
%26 = getelementptr inbounds [4 x i8], [4 x i8]* %24, i64 0, i64 %25
|
|
%27 = load i8, i8* %26, align 1
|
|
store i8 %27, i8* %d, align 1
|
|
store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3 }, %"char[]"* %taddr6, align 8
|
|
%28 = bitcast %"char[]"* %taddr6 to { i8*, i64 }*
|
|
%29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0
|
|
%lo7 = load i8*, i8** %29, align 8
|
|
%30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1
|
|
%hi8 = load i64, i64* %30, align 8
|
|
%31 = insertvalue %variant undef, i8* %d, 0
|
|
%32 = insertvalue %variant %31, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
|
|
%33 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots10, i64 0, i64 0
|
|
store %variant %32, %variant* %33, align 16
|
|
%34 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 1
|
|
store i64 1, i64* %34, align 8
|
|
%35 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg9, i32 0, i32 0
|
|
%36 = bitcast [1 x %variant]* %varargslots10 to %variant*
|
|
store %variant* %36, %variant** %35, align 8
|
|
%37 = bitcast %"variant[]"* %vararg9 to { i8*, i64 }*
|
|
%38 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 0
|
|
%lo11 = load i8*, i8** %38, align 8
|
|
%39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %37, i32 0, i32 1
|
|
%hi12 = load i64, i64* %39, align 8
|
|
%40 = call i64 @std_io_printf(i64* %retparam5, i8* %lo7, i64 %hi8, i8* %lo11, i64 %hi12)
|
|
%not_err13 = icmp eq i64 %40, 0
|
|
br i1 %not_err13, label %after_check14, label %voiderr15
|
|
|
|
after_check14: ; preds = %loop.body
|
|
br label %voiderr15
|
|
|
|
voiderr15: ; preds = %after_check14, %loop.body
|
|
%41 = load i64, i64* %.anon4, align 8
|
|
%add = add i64 %41, 1
|
|
store i64 %add, i64* %.anon4, align 8
|
|
br label %loop.cond
|
|
|
|
loop.exit: ; preds = %loop.cond
|
|
%42 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i32 0, i32 0)) #2
|
|
%43 = load [4 x i8]*, [4 x i8]** %z, align 8
|
|
store [4 x i8]* %43, [4 x i8]** %.anon16, align 8
|
|
store i64 0, i64* %.anon17, align 8
|
|
br label %loop.cond18
|
|
|
|
loop.cond18: ; preds = %voiderr32, %loop.exit
|
|
%44 = load i64, i64* %.anon17, align 8
|
|
%gt19 = icmp ugt i64 4, %44
|
|
br i1 %gt19, label %loop.body20, label %loop.exit34
|
|
|
|
loop.body20: ; preds = %loop.cond18
|
|
%45 = load [4 x i8]*, [4 x i8]** %.anon16, align 8
|
|
%46 = load i64, i64* %.anon17, align 8
|
|
%47 = getelementptr inbounds [4 x i8], [4 x i8]* %45, i64 0, i64 %46
|
|
%48 = load i8, i8* %47, align 1
|
|
store i8 %48, i8* %d21, align 1
|
|
store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i64 3 }, %"char[]"* %taddr23, align 8
|
|
%49 = bitcast %"char[]"* %taddr23 to { i8*, i64 }*
|
|
%50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 0
|
|
%lo24 = load i8*, i8** %50, align 8
|
|
%51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 1
|
|
%hi25 = load i64, i64* %51, align 8
|
|
%52 = insertvalue %variant undef, i8* %d21, 0
|
|
%53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
|
|
%54 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots27, i64 0, i64 0
|
|
store %variant %53, %variant* %54, align 16
|
|
%55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg26, i32 0, i32 1
|
|
store i64 1, i64* %55, align 8
|
|
%56 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg26, i32 0, i32 0
|
|
%57 = bitcast [1 x %variant]* %varargslots27 to %variant*
|
|
store %variant* %57, %variant** %56, align 8
|
|
%58 = bitcast %"variant[]"* %vararg26 to { i8*, i64 }*
|
|
%59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0
|
|
%lo28 = load i8*, i8** %59, align 8
|
|
%60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1
|
|
%hi29 = load i64, i64* %60, align 8
|
|
%61 = call i64 @std_io_printf(i64* %retparam22, i8* %lo24, i64 %hi25, i8* %lo28, i64 %hi29)
|
|
%not_err30 = icmp eq i64 %61, 0
|
|
br i1 %not_err30, label %after_check31, label %voiderr32
|
|
|
|
after_check31: ; preds = %loop.body20
|
|
br label %voiderr32
|
|
|
|
voiderr32: ; preds = %after_check31, %loop.body20
|
|
%62 = load i64, i64* %.anon17, align 8
|
|
%add33 = add i64 %62, 1
|
|
store i64 %add33, i64* %.anon17, align 8
|
|
br label %loop.cond18
|
|
|
|
loop.exit34: ; preds = %loop.cond18
|
|
%63 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i32 0, i32 0)) #2
|
|
store %"char[]" { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i64 10 }, %"char[]"* %taddr36, align 8
|
|
%64 = bitcast %"char[]"* %taddr36 to { i8*, i64 }*
|
|
%65 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 0
|
|
%lo37 = load i8*, i8** %65, align 8
|
|
%66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %64, i32 0, i32 1
|
|
%hi38 = load i64, i64* %66, align 8
|
|
%67 = load i32, i32* %abc, align 4
|
|
%68 = call i32 @llvm.bswap.i32(i32 %67)
|
|
%69 = and i32 65535, %68
|
|
%ztrunc = trunc i32 %69 to i16
|
|
store i16 %ztrunc, i16* %taddr41, align 2
|
|
%70 = bitcast i16* %taddr41 to i8*
|
|
%71 = insertvalue %variant undef, i8* %70, 0
|
|
%72 = insertvalue %variant %71, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1
|
|
%73 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots40, i64 0, i64 0
|
|
store %variant %72, %variant* %73, align 16
|
|
%74 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg39, i32 0, i32 1
|
|
store i64 1, i64* %74, align 8
|
|
%75 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg39, i32 0, i32 0
|
|
%76 = bitcast [1 x %variant]* %varargslots40 to %variant*
|
|
store %variant* %76, %variant** %75, align 8
|
|
%77 = bitcast %"variant[]"* %vararg39 to { i8*, i64 }*
|
|
%78 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %77, i32 0, i32 0
|
|
%lo42 = load i8*, i8** %78, align 8
|
|
%79 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %77, i32 0, i32 1
|
|
%hi43 = load i64, i64* %79, align 8
|
|
%80 = call i64 @std_io_printfln(i64* %retparam35, i8* %lo37, i64 %hi38, i8* %lo42, i64 %hi43)
|
|
%not_err44 = icmp eq i64 %80, 0
|
|
br i1 %not_err44, label %after_check45, label %voiderr46
|
|
|
|
after_check45: ; preds = %loop.exit34
|
|
br label %voiderr46
|
|
|
|
voiderr46: ; preds = %after_check45, %loop.exit34
|
|
%81 = load i32, i32* %abc, align 4
|
|
%82 = call i32 @llvm.bswap.i32(i32 %81)
|
|
%83 = and i32 %82, -65536
|
|
%84 = or i32 %83, 4660
|
|
%85 = call i32 @llvm.bswap.i32(i32 %84)
|
|
store i32 %85, i32* %abc, align 4
|
|
%86 = load i32, i32* %abc, align 4
|
|
%87 = call i32 @llvm.bswap.i32(i32 %86)
|
|
%88 = and i32 %87, 65535
|
|
%89 = or i32 %88, 1450704896
|
|
%90 = call i32 @llvm.bswap.i32(i32 %89)
|
|
store i32 %90, i32* %abc, align 4
|
|
store %"char[]" { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i64 12 }, %"char[]"* %taddr48, align 8
|
|
%91 = bitcast %"char[]"* %taddr48 to { i8*, i64 }*
|
|
%92 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %91, i32 0, i32 0
|
|
%lo49 = load i8*, i8** %92, align 8
|
|
%93 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %91, i32 0, i32 1
|
|
%hi50 = load i64, i64* %93, align 8
|
|
%94 = load i32, i32* %abc, align 4
|
|
%95 = call i32 @llvm.bswap.i32(i32 %94)
|
|
%96 = and i32 65535, %95
|
|
%ztrunc53 = trunc i32 %96 to i16
|
|
store i16 %ztrunc53, i16* %taddr54, align 2
|
|
%97 = bitcast i16* %taddr54 to i8*
|
|
%98 = insertvalue %variant undef, i8* %97, 0
|
|
%99 = insertvalue %variant %98, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1
|
|
%100 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots52, i64 0, i64 0
|
|
store %variant %99, %variant* %100, align 16
|
|
%101 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg51, i32 0, i32 1
|
|
store i64 1, i64* %101, align 8
|
|
%102 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg51, i32 0, i32 0
|
|
%103 = bitcast [1 x %variant]* %varargslots52 to %variant*
|
|
store %variant* %103, %variant** %102, align 8
|
|
%104 = bitcast %"variant[]"* %vararg51 to { i8*, i64 }*
|
|
%105 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %104, i32 0, i32 0
|
|
%lo55 = load i8*, i8** %105, align 8
|
|
%106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %104, i32 0, i32 1
|
|
%hi56 = load i64, i64* %106, align 8
|
|
%107 = call i64 @std_io_printfln(i64* %retparam47, i8* %lo49, i64 %hi50, i8* %lo55, i64 %hi56)
|
|
%not_err57 = icmp eq i64 %107, 0
|
|
br i1 %not_err57, label %after_check58, label %voiderr59
|
|
|
|
after_check58: ; preds = %voiderr46
|
|
br label %voiderr59
|
|
|
|
voiderr59: ; preds = %after_check58, %voiderr46
|
|
%108 = load [4 x i8]*, [4 x i8]** %z, align 8
|
|
store [4 x i8]* %108, [4 x i8]** %.anon60, align 8
|
|
store i64 0, i64* %.anon61, align 8
|
|
br label %loop.cond62
|
|
|
|
loop.cond62: ; preds = %voiderr76, %voiderr59
|
|
%109 = load i64, i64* %.anon61, align 8
|
|
%gt63 = icmp ugt i64 4, %109
|
|
br i1 %gt63, label %loop.body64, label %loop.exit78
|
|
|
|
loop.body64: ; preds = %loop.cond62
|
|
%110 = load [4 x i8]*, [4 x i8]** %.anon60, align 8
|
|
%111 = load i64, i64* %.anon61, align 8
|
|
%112 = getelementptr inbounds [4 x i8], [4 x i8]* %110, i64 0, i64 %111
|
|
%113 = load i8, i8* %112, align 1
|
|
store i8 %113, i8* %d65, align 1
|
|
store %"char[]" { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i32 0, i32 0), i64 3 }, %"char[]"* %taddr67, align 8
|
|
%114 = bitcast %"char[]"* %taddr67 to { i8*, i64 }*
|
|
%115 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %114, i32 0, i32 0
|
|
%lo68 = load i8*, i8** %115, align 8
|
|
%116 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %114, i32 0, i32 1
|
|
%hi69 = load i64, i64* %116, align 8
|
|
%117 = insertvalue %variant undef, i8* %d65, 0
|
|
%118 = insertvalue %variant %117, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
|
|
%119 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots71, i64 0, i64 0
|
|
store %variant %118, %variant* %119, align 16
|
|
%120 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg70, i32 0, i32 1
|
|
store i64 1, i64* %120, align 8
|
|
%121 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg70, i32 0, i32 0
|
|
%122 = bitcast [1 x %variant]* %varargslots71 to %variant*
|
|
store %variant* %122, %variant** %121, align 8
|
|
%123 = bitcast %"variant[]"* %vararg70 to { i8*, i64 }*
|
|
%124 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 0
|
|
%lo72 = load i8*, i8** %124, align 8
|
|
%125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %123, i32 0, i32 1
|
|
%hi73 = load i64, i64* %125, align 8
|
|
%126 = call i64 @std_io_printf(i64* %retparam66, i8* %lo68, i64 %hi69, i8* %lo72, i64 %hi73)
|
|
%not_err74 = icmp eq i64 %126, 0
|
|
br i1 %not_err74, label %after_check75, label %voiderr76
|
|
|
|
after_check75: ; preds = %loop.body64
|
|
br label %voiderr76
|
|
|
|
voiderr76: ; preds = %after_check75, %loop.body64
|
|
%127 = load i64, i64* %.anon61, align 8
|
|
%add77 = add i64 %127, 1
|
|
store i64 %add77, i64* %.anon61, align 8
|
|
br label %loop.cond62
|
|
|
|
loop.exit78: ; preds = %loop.cond62
|
|
%128 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.8, i32 0, i32 0)) #2
|
|
store i32 0, i32* %y, align 4
|
|
%129 = load i32, i32* %y, align 4
|
|
store i32 123, i32* %y, align 4
|
|
store %"char[]" { i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i32 0, i32 0), i64 18 }, %"char[]"* %taddr80, align 8
|
|
%130 = bitcast %"char[]"* %taddr80 to { i8*, i64 }*
|
|
%131 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %130, i32 0, i32 0
|
|
%lo81 = load i8*, i8** %131, align 8
|
|
%132 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %130, i32 0, i32 1
|
|
%hi82 = load i64, i64* %132, align 8
|
|
%133 = bitcast i32* %y to i8*
|
|
%134 = insertvalue %variant undef, i8* %133, 0
|
|
%135 = insertvalue %variant %134, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
|
|
%136 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots84, i64 0, i64 0
|
|
store %variant %135, %variant* %136, align 16
|
|
%137 = load i32, i32* %y, align 4
|
|
store i32 %137, i32* %taddr85, align 4
|
|
%138 = bitcast i32* %taddr85 to i8*
|
|
%139 = insertvalue %variant undef, i8* %138, 0
|
|
%140 = insertvalue %variant %139, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
|
|
%141 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots84, i64 0, i64 1
|
|
store %variant %140, %variant* %141, align 16
|
|
%142 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg83, i32 0, i32 1
|
|
store i64 2, i64* %142, align 8
|
|
%143 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg83, i32 0, i32 0
|
|
%144 = bitcast [2 x %variant]* %varargslots84 to %variant*
|
|
store %variant* %144, %variant** %143, align 8
|
|
%145 = bitcast %"variant[]"* %vararg83 to { i8*, i64 }*
|
|
%146 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 0
|
|
%lo86 = load i8*, i8** %146, align 8
|
|
%147 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %145, i32 0, i32 1
|
|
%hi87 = load i64, i64* %147, align 8
|
|
%148 = call i64 @std_io_printf(i64* %retparam79, i8* %lo81, i64 %hi82, i8* %lo86, i64 %hi87)
|
|
%not_err88 = icmp eq i64 %148, 0
|
|
br i1 %not_err88, label %after_check89, label %voiderr90
|
|
|
|
after_check89: ; preds = %loop.exit78
|
|
br label %voiderr90
|
|
|
|
voiderr90: ; preds = %after_check89, %loop.exit78
|
|
ret void
|
|
}
|