mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
629 lines
27 KiB
C
629 lines
27 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
|
|
fn int hell() { return 1; }
|
|
|
|
macro print_args($Type)
|
|
{
|
|
var $params = $Type.params;
|
|
$foreach ($param : $params):
|
|
io::println($param.nameof);
|
|
$endforeach;
|
|
}
|
|
|
|
bitstruct Bark : ulong
|
|
{
|
|
int x : 1..4;
|
|
short y : 6..10;
|
|
}
|
|
|
|
struct Foo
|
|
{
|
|
int x;
|
|
union test {
|
|
int y;
|
|
double z;
|
|
}
|
|
struct {
|
|
int abc;
|
|
int bcd;
|
|
}
|
|
double q;
|
|
}
|
|
macro print_fields($Type)
|
|
{
|
|
io::printfn("Type: %s", $Type.nameof);
|
|
var $params = $Type.membersof;
|
|
$foreach ($param : $params):
|
|
io::printfn("%s: %s", $param.nameof, $param.typeid.nameof);
|
|
$endforeach;
|
|
}
|
|
|
|
fn void hello(int a, double b, int[4] d, args...) {}
|
|
fn void test(int x)
|
|
{
|
|
print_args($typeof(&test));
|
|
print_args($typeof(&hell));
|
|
print_args($typeof(&hello));
|
|
io::println($typeof(&test).returns.nameof);
|
|
io::println($typeof(&hell).returns.nameof);
|
|
print_fields(Foo);
|
|
print_fields(Bar);
|
|
print_fields(Bark);
|
|
}
|
|
|
|
struct BarInner
|
|
{
|
|
char a;
|
|
char b;
|
|
}
|
|
|
|
struct Bar
|
|
{
|
|
char a;
|
|
short b;
|
|
struct
|
|
{
|
|
union
|
|
{
|
|
BarInner y;
|
|
char z;
|
|
struct {
|
|
char z1;
|
|
char z2;
|
|
}
|
|
}
|
|
}
|
|
struct baz
|
|
{
|
|
int foo;
|
|
}
|
|
}
|
|
fn void main()
|
|
{
|
|
var $x = Bar.a;
|
|
|
|
io::printfn("len: %d", Bar.membersof.len);
|
|
io::printfn("len: %d", Bar.baz.membersof.len);
|
|
io::printfn("a: %d %d", Bar.a.offsetof, Bar.a.alignof);
|
|
io::printfn("b: %d %d", Bar.b.offsetof, Bar.b.alignof);
|
|
io::printfn("y: %d %d", Bar.y.offsetof, Bar.y.alignof);
|
|
io::printfn("z: %d %d", Bar.z.offsetof, Bar.z.alignof);
|
|
io::printfn("z1: %d %d", Bar.z1.offsetof, Bar.z1.alignof);
|
|
io::printfn("z2: %d %d", Bar.z2.offsetof, Bar.z2.alignof);
|
|
io::printfn("baz: %d %d", Bar.baz.offsetof, Bar.baz.alignof);
|
|
io::printfn("Bar: %d", $x.alignof);
|
|
io::printfn("foo: %d %d", Bar.baz.foo.offsetof, Bar.baz.foo.alignof);
|
|
|
|
test(10);
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
define void @test_hello(i32 %0, double %1, i64 %2, i64 %3, ptr %4, i64 %5) #0 {
|
|
entry:
|
|
%d = alloca [4 x i32], align 4
|
|
%args = alloca %"variant[]", align 8
|
|
%6 = getelementptr inbounds { i64, i64 }, ptr %d, i32 0, i32 0
|
|
store i64 %2, ptr %6, align 4
|
|
%7 = getelementptr inbounds { i64, i64 }, ptr %d, i32 0, i32 1
|
|
store i64 %3, ptr %7, align 4
|
|
%8 = getelementptr inbounds { ptr, i64 }, ptr %args, i32 0, i32 0
|
|
store ptr %4, ptr %8, align 8
|
|
%9 = getelementptr inbounds { ptr, i64 }, ptr %args, i32 0, i32 1
|
|
store i64 %5, ptr %9, align 8
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define void @test_test(i32 %0) #0 {
|
|
entry:
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [1 x %variant], align 16
|
|
%taddr = alloca ptr, align 8
|
|
%retparam1 = alloca i64, align 8
|
|
%varargslots2 = alloca [2 x %variant], align 16
|
|
%taddr3 = alloca ptr, align 8
|
|
%taddr4 = alloca ptr, align 8
|
|
%retparam8 = alloca i64, align 8
|
|
%varargslots9 = alloca [2 x %variant], align 16
|
|
%taddr10 = alloca ptr, align 8
|
|
%taddr11 = alloca ptr, align 8
|
|
%retparam15 = alloca i64, align 8
|
|
%varargslots16 = alloca [2 x %variant], align 16
|
|
%taddr17 = alloca ptr, align 8
|
|
%taddr18 = alloca ptr, align 8
|
|
%retparam22 = alloca i64, align 8
|
|
%varargslots23 = alloca [2 x %variant], align 16
|
|
%taddr24 = alloca ptr, align 8
|
|
%taddr25 = alloca ptr, align 8
|
|
%retparam29 = alloca i64, align 8
|
|
%varargslots30 = alloca [1 x %variant], align 16
|
|
%taddr31 = alloca ptr, align 8
|
|
%retparam35 = alloca i64, align 8
|
|
%varargslots36 = alloca [2 x %variant], align 16
|
|
%taddr37 = alloca ptr, align 8
|
|
%taddr38 = alloca ptr, align 8
|
|
%retparam42 = alloca i64, align 8
|
|
%varargslots43 = alloca [2 x %variant], align 16
|
|
%taddr44 = alloca ptr, align 8
|
|
%taddr45 = alloca ptr, align 8
|
|
%retparam49 = alloca i64, align 8
|
|
%varargslots50 = alloca [2 x %variant], align 16
|
|
%taddr51 = alloca ptr, align 8
|
|
%taddr52 = alloca ptr, align 8
|
|
%retparam56 = alloca i64, align 8
|
|
%varargslots57 = alloca [2 x %variant], align 16
|
|
%taddr58 = alloca ptr, align 8
|
|
%taddr59 = alloca ptr, align 8
|
|
%retparam63 = alloca i64, align 8
|
|
%varargslots64 = alloca [1 x %variant], align 16
|
|
%taddr65 = alloca ptr, align 8
|
|
%retparam69 = alloca i64, align 8
|
|
%varargslots70 = alloca [2 x %variant], align 16
|
|
%taddr71 = alloca ptr, align 8
|
|
%taddr72 = alloca ptr, align 8
|
|
%retparam76 = alloca i64, align 8
|
|
%varargslots77 = alloca [2 x %variant], align 16
|
|
%taddr78 = alloca ptr, align 8
|
|
%taddr79 = alloca ptr, align 8
|
|
%1 = call i32 @std_io_println(ptr @.str) #1
|
|
%2 = call i32 @std_io_println(ptr @.str.10) #1
|
|
%3 = call i32 @std_io_println(ptr @.str.11) #1
|
|
%4 = call i32 @std_io_println(ptr @.str.12) #1
|
|
%5 = call i32 @std_io_println(ptr @.str.13) #1
|
|
%6 = call i32 @std_io_println(ptr @.str.14) #1
|
|
%7 = call i32 @std_io_println(ptr @.str.15) #1
|
|
store ptr @.str.17, ptr %taddr, align 8
|
|
%8 = insertvalue %variant undef, ptr %taddr, 0
|
|
%9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
|
|
%10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
|
|
store %variant %9, ptr %10, align 16
|
|
%11 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
|
|
%not_err = icmp eq i64 %11, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
store ptr @.str.19, ptr %taddr3, align 8
|
|
%12 = insertvalue %variant undef, ptr %taddr3, 0
|
|
%13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
|
|
%14 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 0
|
|
store %variant %13, ptr %14, align 16
|
|
store ptr @.str.20, ptr %taddr4, align 8
|
|
%15 = insertvalue %variant undef, ptr %taddr4, 0
|
|
%16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
|
|
%17 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 1
|
|
store %variant %16, ptr %17, align 16
|
|
%18 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.18, i64 6, ptr %varargslots2, i64 2)
|
|
%not_err5 = icmp eq i64 %18, 0
|
|
br i1 %not_err5, label %after_check6, label %voiderr7
|
|
|
|
after_check6: ; preds = %voiderr
|
|
br label %voiderr7
|
|
|
|
voiderr7: ; preds = %after_check6, %voiderr
|
|
store ptr @.str.22, ptr %taddr10, align 8
|
|
%19 = insertvalue %variant undef, ptr %taddr10, 0
|
|
%20 = insertvalue %variant %19, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
|
|
%21 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0
|
|
store %variant %20, ptr %21, align 16
|
|
store ptr @.str.23, ptr %taddr11, align 8
|
|
%22 = insertvalue %variant undef, ptr %taddr11, 0
|
|
%23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
|
|
%24 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
|
|
store %variant %23, ptr %24, align 16
|
|
%25 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.21, i64 6, ptr %varargslots9, i64 2)
|
|
%not_err12 = icmp eq i64 %25, 0
|
|
br i1 %not_err12, label %after_check13, label %voiderr14
|
|
|
|
after_check13: ; preds = %voiderr7
|
|
br label %voiderr14
|
|
|
|
voiderr14: ; preds = %after_check13, %voiderr7
|
|
store ptr @.str.25, ptr %taddr17, align 8
|
|
%26 = insertvalue %variant undef, ptr %taddr17, 0
|
|
%27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
|
|
%28 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 0
|
|
store %variant %27, ptr %28, align 16
|
|
store ptr @.str.26, ptr %taddr18, align 8
|
|
%29 = insertvalue %variant undef, ptr %taddr18, 0
|
|
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
|
|
%31 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 1
|
|
store %variant %30, ptr %31, align 16
|
|
%32 = call i64 @std_io_printfn(ptr %retparam15, ptr @.str.24, i64 6, ptr %varargslots16, i64 2)
|
|
%not_err19 = icmp eq i64 %32, 0
|
|
br i1 %not_err19, label %after_check20, label %voiderr21
|
|
|
|
after_check20: ; preds = %voiderr14
|
|
br label %voiderr21
|
|
|
|
voiderr21: ; preds = %after_check20, %voiderr14
|
|
store ptr @.str.28, ptr %taddr24, align 8
|
|
%33 = insertvalue %variant undef, ptr %taddr24, 0
|
|
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
|
|
%35 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 0
|
|
store %variant %34, ptr %35, align 16
|
|
store ptr @.str.29, ptr %taddr25, align 8
|
|
%36 = insertvalue %variant undef, ptr %taddr25, 0
|
|
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
|
|
%38 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 1
|
|
store %variant %37, ptr %38, align 16
|
|
%39 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.27, i64 6, ptr %varargslots23, i64 2)
|
|
%not_err26 = icmp eq i64 %39, 0
|
|
br i1 %not_err26, label %after_check27, label %voiderr28
|
|
|
|
after_check27: ; preds = %voiderr21
|
|
br label %voiderr28
|
|
|
|
voiderr28: ; preds = %after_check27, %voiderr21
|
|
store ptr @.str.31, ptr %taddr31, align 8
|
|
%40 = insertvalue %variant undef, ptr %taddr31, 0
|
|
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
|
|
%42 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
|
|
store %variant %41, ptr %42, align 16
|
|
%43 = call i64 @std_io_printfn(ptr %retparam29, ptr @.str.30, i64 8, ptr %varargslots30, i64 1)
|
|
%not_err32 = icmp eq i64 %43, 0
|
|
br i1 %not_err32, label %after_check33, label %voiderr34
|
|
|
|
after_check33: ; preds = %voiderr28
|
|
br label %voiderr34
|
|
|
|
voiderr34: ; preds = %after_check33, %voiderr28
|
|
store ptr @.str.33, ptr %taddr37, align 8
|
|
%44 = insertvalue %variant undef, ptr %taddr37, 0
|
|
%45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
|
|
%46 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
|
|
store %variant %45, ptr %46, align 16
|
|
store ptr @.str.34, ptr %taddr38, align 8
|
|
%47 = insertvalue %variant undef, ptr %taddr38, 0
|
|
%48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
|
|
%49 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
|
|
store %variant %48, ptr %49, align 16
|
|
%50 = call i64 @std_io_printfn(ptr %retparam35, ptr @.str.32, i64 6, ptr %varargslots36, i64 2)
|
|
%not_err39 = icmp eq i64 %50, 0
|
|
br i1 %not_err39, label %after_check40, label %voiderr41
|
|
|
|
after_check40: ; preds = %voiderr34
|
|
br label %voiderr41
|
|
|
|
voiderr41: ; preds = %after_check40, %voiderr34
|
|
store ptr @.str.36, ptr %taddr44, align 8
|
|
%51 = insertvalue %variant undef, ptr %taddr44, 0
|
|
%52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
|
|
%53 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0
|
|
store %variant %52, ptr %53, align 16
|
|
store ptr @.str.37, ptr %taddr45, align 8
|
|
%54 = insertvalue %variant undef, ptr %taddr45, 0
|
|
%55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
|
|
%56 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 1
|
|
store %variant %55, ptr %56, align 16
|
|
%57 = call i64 @std_io_printfn(ptr %retparam42, ptr @.str.35, i64 6, ptr %varargslots43, i64 2)
|
|
%not_err46 = icmp eq i64 %57, 0
|
|
br i1 %not_err46, label %after_check47, label %voiderr48
|
|
|
|
after_check47: ; preds = %voiderr41
|
|
br label %voiderr48
|
|
|
|
voiderr48: ; preds = %after_check47, %voiderr41
|
|
store ptr @.str.39, ptr %taddr51, align 8
|
|
%58 = insertvalue %variant undef, ptr %taddr51, 0
|
|
%59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
|
|
%60 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0
|
|
store %variant %59, ptr %60, align 16
|
|
store ptr @.str.40, ptr %taddr52, align 8
|
|
%61 = insertvalue %variant undef, ptr %taddr52, 0
|
|
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
|
|
%63 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 1
|
|
store %variant %62, ptr %63, align 16
|
|
%64 = call i64 @std_io_printfn(ptr %retparam49, ptr @.str.38, i64 6, ptr %varargslots50, i64 2)
|
|
%not_err53 = icmp eq i64 %64, 0
|
|
br i1 %not_err53, label %after_check54, label %voiderr55
|
|
|
|
after_check54: ; preds = %voiderr48
|
|
br label %voiderr55
|
|
|
|
voiderr55: ; preds = %after_check54, %voiderr48
|
|
store ptr @.str.42, ptr %taddr58, align 8
|
|
%65 = insertvalue %variant undef, ptr %taddr58, 0
|
|
%66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
|
|
%67 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 0
|
|
store %variant %66, ptr %67, align 16
|
|
store ptr @.str.43, ptr %taddr59, align 8
|
|
%68 = insertvalue %variant undef, ptr %taddr59, 0
|
|
%69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
|
|
%70 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 1
|
|
store %variant %69, ptr %70, align 16
|
|
%71 = call i64 @std_io_printfn(ptr %retparam56, ptr @.str.41, i64 6, ptr %varargslots57, i64 2)
|
|
%not_err60 = icmp eq i64 %71, 0
|
|
br i1 %not_err60, label %after_check61, label %voiderr62
|
|
|
|
after_check61: ; preds = %voiderr55
|
|
br label %voiderr62
|
|
|
|
voiderr62: ; preds = %after_check61, %voiderr55
|
|
store ptr @.str.45, ptr %taddr65, align 8
|
|
%72 = insertvalue %variant undef, ptr %taddr65, 0
|
|
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
|
|
%74 = getelementptr inbounds [1 x %variant], ptr %varargslots64, i64 0, i64 0
|
|
store %variant %73, ptr %74, align 16
|
|
%75 = call i64 @std_io_printfn(ptr %retparam63, ptr @.str.44, i64 8, ptr %varargslots64, i64 1)
|
|
%not_err66 = icmp eq i64 %75, 0
|
|
br i1 %not_err66, label %after_check67, label %voiderr68
|
|
|
|
after_check67: ; preds = %voiderr62
|
|
br label %voiderr68
|
|
|
|
voiderr68: ; preds = %after_check67, %voiderr62
|
|
store ptr @.str.47, ptr %taddr71, align 8
|
|
%76 = insertvalue %variant undef, ptr %taddr71, 0
|
|
%77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
|
|
%78 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0
|
|
store %variant %77, ptr %78, align 16
|
|
store ptr @.str.48, ptr %taddr72, align 8
|
|
%79 = insertvalue %variant undef, ptr %taddr72, 0
|
|
%80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
|
|
%81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1
|
|
store %variant %80, ptr %81, align 16
|
|
%82 = call i64 @std_io_printfn(ptr %retparam69, ptr @.str.46, i64 6, ptr %varargslots70, i64 2)
|
|
%not_err73 = icmp eq i64 %82, 0
|
|
br i1 %not_err73, label %after_check74, label %voiderr75
|
|
|
|
after_check74: ; preds = %voiderr68
|
|
br label %voiderr75
|
|
|
|
voiderr75: ; preds = %after_check74, %voiderr68
|
|
store ptr @.str.50, ptr %taddr78, align 8
|
|
%83 = insertvalue %variant undef, ptr %taddr78, 0
|
|
%84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
|
|
%85 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 0
|
|
store %variant %84, ptr %85, align 16
|
|
store ptr @.str.51, ptr %taddr79, align 8
|
|
%86 = insertvalue %variant undef, ptr %taddr79, 0
|
|
%87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
|
|
%88 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 1
|
|
store %variant %87, ptr %88, align 16
|
|
%89 = call i64 @std_io_printfn(ptr %retparam76, ptr @.str.49, i64 6, ptr %varargslots77, i64 2)
|
|
%not_err80 = icmp eq i64 %89, 0
|
|
br i1 %not_err80, label %after_check81, label %voiderr82
|
|
|
|
after_check81: ; preds = %voiderr75
|
|
br label %voiderr82
|
|
|
|
voiderr82: ; preds = %after_check81, %voiderr75
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define void @test_main() #0 {
|
|
entry:
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [1 x %variant], align 16
|
|
%taddr = alloca i64, align 8
|
|
%retparam1 = alloca i64, align 8
|
|
%varargslots2 = alloca [1 x %variant], align 16
|
|
%taddr3 = alloca i64, align 8
|
|
%retparam7 = alloca i64, align 8
|
|
%varargslots8 = alloca [2 x %variant], align 16
|
|
%taddr9 = alloca i64, align 8
|
|
%taddr10 = alloca i64, align 8
|
|
%retparam14 = alloca i64, align 8
|
|
%varargslots15 = alloca [2 x %variant], align 16
|
|
%taddr16 = alloca i64, align 8
|
|
%taddr17 = alloca i64, align 8
|
|
%retparam21 = alloca i64, align 8
|
|
%varargslots22 = alloca [2 x %variant], align 16
|
|
%taddr23 = alloca i64, align 8
|
|
%taddr24 = alloca i64, align 8
|
|
%retparam28 = alloca i64, align 8
|
|
%varargslots29 = alloca [2 x %variant], align 16
|
|
%taddr30 = alloca i64, align 8
|
|
%taddr31 = alloca i64, align 8
|
|
%retparam35 = alloca i64, align 8
|
|
%varargslots36 = alloca [2 x %variant], align 16
|
|
%taddr37 = alloca i64, align 8
|
|
%taddr38 = alloca i64, align 8
|
|
%retparam42 = alloca i64, align 8
|
|
%varargslots43 = alloca [2 x %variant], align 16
|
|
%taddr44 = alloca i64, align 8
|
|
%taddr45 = alloca i64, align 8
|
|
%retparam49 = alloca i64, align 8
|
|
%varargslots50 = alloca [2 x %variant], align 16
|
|
%taddr51 = alloca i64, align 8
|
|
%taddr52 = alloca i64, align 8
|
|
%retparam56 = alloca i64, align 8
|
|
%varargslots57 = alloca [1 x %variant], align 16
|
|
%taddr58 = alloca i64, align 8
|
|
%retparam62 = alloca i64, align 8
|
|
%varargslots63 = alloca [2 x %variant], align 16
|
|
%taddr64 = alloca i64, align 8
|
|
%taddr65 = alloca i64, align 8
|
|
store i64 4, ptr %taddr, align 8
|
|
%0 = insertvalue %variant undef, ptr %taddr, 0
|
|
%1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$long" to i64), 1
|
|
%2 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
|
|
store %variant %1, ptr %2, align 16
|
|
%3 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.52, i64 7, ptr %varargslots, i64 1)
|
|
%not_err = icmp eq i64 %3, 0
|
|
br i1 %not_err, label %after_check, label %voiderr
|
|
|
|
after_check: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after_check, %entry
|
|
store i64 1, ptr %taddr3, align 8
|
|
%4 = insertvalue %variant undef, ptr %taddr3, 0
|
|
%5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$long" to i64), 1
|
|
%6 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
|
|
store %variant %5, ptr %6, align 16
|
|
%7 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.53, i64 7, ptr %varargslots2, i64 1)
|
|
%not_err4 = icmp eq i64 %7, 0
|
|
br i1 %not_err4, label %after_check5, label %voiderr6
|
|
|
|
after_check5: ; preds = %voiderr
|
|
br label %voiderr6
|
|
|
|
voiderr6: ; preds = %after_check5, %voiderr
|
|
store i64 0, ptr %taddr9, align 8
|
|
%8 = insertvalue %variant undef, ptr %taddr9, 0
|
|
%9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%10 = getelementptr inbounds [2 x %variant], ptr %varargslots8, i64 0, i64 0
|
|
store %variant %9, ptr %10, align 16
|
|
store i64 4, ptr %taddr10, align 8
|
|
%11 = insertvalue %variant undef, ptr %taddr10, 0
|
|
%12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%13 = getelementptr inbounds [2 x %variant], ptr %varargslots8, i64 0, i64 1
|
|
store %variant %12, ptr %13, align 16
|
|
%14 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.54, i64 8, ptr %varargslots8, i64 2)
|
|
%not_err11 = icmp eq i64 %14, 0
|
|
br i1 %not_err11, label %after_check12, label %voiderr13
|
|
|
|
after_check12: ; preds = %voiderr6
|
|
br label %voiderr13
|
|
|
|
voiderr13: ; preds = %after_check12, %voiderr6
|
|
store i64 2, ptr %taddr16, align 8
|
|
%15 = insertvalue %variant undef, ptr %taddr16, 0
|
|
%16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%17 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 0
|
|
store %variant %16, ptr %17, align 16
|
|
store i64 2, ptr %taddr17, align 8
|
|
%18 = insertvalue %variant undef, ptr %taddr17, 0
|
|
%19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%20 = getelementptr inbounds [2 x %variant], ptr %varargslots15, i64 0, i64 1
|
|
store %variant %19, ptr %20, align 16
|
|
%21 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.55, i64 8, ptr %varargslots15, i64 2)
|
|
%not_err18 = icmp eq i64 %21, 0
|
|
br i1 %not_err18, label %after_check19, label %voiderr20
|
|
|
|
after_check19: ; preds = %voiderr13
|
|
br label %voiderr20
|
|
|
|
voiderr20: ; preds = %after_check19, %voiderr13
|
|
store i64 4, ptr %taddr23, align 8
|
|
%22 = insertvalue %variant undef, ptr %taddr23, 0
|
|
%23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%24 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 0
|
|
store %variant %23, ptr %24, align 16
|
|
store i64 4, ptr %taddr24, align 8
|
|
%25 = insertvalue %variant undef, ptr %taddr24, 0
|
|
%26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%27 = getelementptr inbounds [2 x %variant], ptr %varargslots22, i64 0, i64 1
|
|
store %variant %26, ptr %27, align 16
|
|
%28 = call i64 @std_io_printfn(ptr %retparam21, ptr @.str.56, i64 8, ptr %varargslots22, i64 2)
|
|
%not_err25 = icmp eq i64 %28, 0
|
|
br i1 %not_err25, label %after_check26, label %voiderr27
|
|
|
|
after_check26: ; preds = %voiderr20
|
|
br label %voiderr27
|
|
|
|
voiderr27: ; preds = %after_check26, %voiderr20
|
|
store i64 4, ptr %taddr30, align 8
|
|
%29 = insertvalue %variant undef, ptr %taddr30, 0
|
|
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%31 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0
|
|
store %variant %30, ptr %31, align 16
|
|
store i64 4, ptr %taddr31, align 8
|
|
%32 = insertvalue %variant undef, ptr %taddr31, 0
|
|
%33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%34 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1
|
|
store %variant %33, ptr %34, align 16
|
|
%35 = call i64 @std_io_printfn(ptr %retparam28, ptr @.str.57, i64 8, ptr %varargslots29, i64 2)
|
|
%not_err32 = icmp eq i64 %35, 0
|
|
br i1 %not_err32, label %after_check33, label %voiderr34
|
|
|
|
after_check33: ; preds = %voiderr27
|
|
br label %voiderr34
|
|
|
|
voiderr34: ; preds = %after_check33, %voiderr27
|
|
store i64 4, ptr %taddr37, align 8
|
|
%36 = insertvalue %variant undef, ptr %taddr37, 0
|
|
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%38 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
|
|
store %variant %37, ptr %38, align 16
|
|
store i64 4, ptr %taddr38, align 8
|
|
%39 = insertvalue %variant undef, ptr %taddr38, 0
|
|
%40 = insertvalue %variant %39, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%41 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
|
|
store %variant %40, ptr %41, align 16
|
|
%42 = call i64 @std_io_printfn(ptr %retparam35, ptr @.str.58, i64 9, ptr %varargslots36, i64 2)
|
|
%not_err39 = icmp eq i64 %42, 0
|
|
br i1 %not_err39, label %after_check40, label %voiderr41
|
|
|
|
after_check40: ; preds = %voiderr34
|
|
br label %voiderr41
|
|
|
|
voiderr41: ; preds = %after_check40, %voiderr34
|
|
store i64 5, ptr %taddr44, align 8
|
|
%43 = insertvalue %variant undef, ptr %taddr44, 0
|
|
%44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%45 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0
|
|
store %variant %44, ptr %45, align 16
|
|
store i64 1, ptr %taddr45, align 8
|
|
%46 = insertvalue %variant undef, ptr %taddr45, 0
|
|
%47 = insertvalue %variant %46, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%48 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 1
|
|
store %variant %47, ptr %48, align 16
|
|
%49 = call i64 @std_io_printfn(ptr %retparam42, ptr @.str.59, i64 9, ptr %varargslots43, i64 2)
|
|
%not_err46 = icmp eq i64 %49, 0
|
|
br i1 %not_err46, label %after_check47, label %voiderr48
|
|
|
|
after_check47: ; preds = %voiderr41
|
|
br label %voiderr48
|
|
|
|
voiderr48: ; preds = %after_check47, %voiderr41
|
|
store i64 8, ptr %taddr51, align 8
|
|
%50 = insertvalue %variant undef, ptr %taddr51, 0
|
|
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%52 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0
|
|
store %variant %51, ptr %52, align 16
|
|
store i64 4, ptr %taddr52, align 8
|
|
%53 = insertvalue %variant undef, ptr %taddr52, 0
|
|
%54 = insertvalue %variant %53, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%55 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 1
|
|
store %variant %54, ptr %55, align 16
|
|
%56 = call i64 @std_io_printfn(ptr %retparam49, ptr @.str.60, i64 10, ptr %varargslots50, i64 2)
|
|
%not_err53 = icmp eq i64 %56, 0
|
|
br i1 %not_err53, label %after_check54, label %voiderr55
|
|
|
|
after_check54: ; preds = %voiderr48
|
|
br label %voiderr55
|
|
|
|
voiderr55: ; preds = %after_check54, %voiderr48
|
|
store i64 4, ptr %taddr58, align 8
|
|
%57 = insertvalue %variant undef, ptr %taddr58, 0
|
|
%58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%59 = getelementptr inbounds [1 x %variant], ptr %varargslots57, i64 0, i64 0
|
|
store %variant %58, ptr %59, align 16
|
|
%60 = call i64 @std_io_printfn(ptr %retparam56, ptr @.str.61, i64 7, ptr %varargslots57, i64 1)
|
|
%not_err59 = icmp eq i64 %60, 0
|
|
br i1 %not_err59, label %after_check60, label %voiderr61
|
|
|
|
after_check60: ; preds = %voiderr55
|
|
br label %voiderr61
|
|
|
|
voiderr61: ; preds = %after_check60, %voiderr55
|
|
store i64 8, ptr %taddr64, align 8
|
|
%61 = insertvalue %variant undef, ptr %taddr64, 0
|
|
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%63 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0
|
|
store %variant %62, ptr %63, align 16
|
|
store i64 4, ptr %taddr65, align 8
|
|
%64 = insertvalue %variant undef, ptr %taddr65, 0
|
|
%65 = insertvalue %variant %64, i64 ptrtoint (ptr @"ct$ulong" to i64), 1
|
|
%66 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1
|
|
store %variant %65, ptr %66, align 16
|
|
%67 = call i64 @std_io_printfn(ptr %retparam62, ptr @.str.62, i64 10, ptr %varargslots63, i64 2)
|
|
%not_err66 = icmp eq i64 %67, 0
|
|
br i1 %not_err66, label %after_check67, label %voiderr68
|
|
|
|
after_check67: ; preds = %voiderr61
|
|
br label %voiderr68
|
|
|
|
voiderr68: ; preds = %after_check67, %voiderr61
|
|
call void @test_test(i32 10)
|
|
ret void
|
|
}
|