mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
237 lines
9.3 KiB
C
237 lines
9.3 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
|
|
fault Foo { ABC, DEF }
|
|
|
|
fn void main()
|
|
{
|
|
io::printfn("1:%d", get_a(1) ?? get_b(4) ?? -1);
|
|
io::printfn("2:%d", get_a(2) ?? get_b(4) ?? -1);
|
|
io::printfn("3:%d", get_a(1) ?? get_b(5) ?? -1);
|
|
io::printfn("4:%s", catch(Foo.ABC! ?? Foo.DEF!));
|
|
io::printfn("5:%s", Foo.ABC! ?? 3);
|
|
io::printfn("6:%s", catch((3 > 2 ? Foo.ABC! : 4) ?? Foo.DEF!));
|
|
io::printfn("7:%s", catch((3 < 2 ? Foo.ABC! : 4) ?? Foo.DEF!));
|
|
long x = Foo.DEF! ?? 3;
|
|
io::printfn("8:%s", x);
|
|
int! xy = Foo.ABC! ?? Foo.DEF!;
|
|
}
|
|
|
|
fn int! get_a(int x)
|
|
{
|
|
if (x % 2) return Foo.ABC!;
|
|
return x * 2;
|
|
}
|
|
|
|
fn int! get_b(int x)
|
|
{
|
|
if (x % 2 == 0) return Foo.ABC!;
|
|
return x * 2;
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
define void @test_main() #0 {
|
|
entry:
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [1 x %variant], align 16
|
|
%retparam1 = alloca i32, align 4
|
|
%retparam2 = alloca i32, align 4
|
|
%taddr = alloca i32, align 4
|
|
%retparam10 = alloca i64, align 8
|
|
%varargslots11 = alloca [1 x %variant], align 16
|
|
%retparam12 = alloca i32, align 4
|
|
%retparam16 = alloca i32, align 4
|
|
%taddr24 = alloca i32, align 4
|
|
%retparam27 = alloca i64, align 8
|
|
%varargslots28 = alloca [1 x %variant], align 16
|
|
%retparam29 = alloca i32, align 4
|
|
%retparam33 = alloca i32, align 4
|
|
%taddr41 = alloca i32, align 4
|
|
%retparam44 = alloca i64, align 8
|
|
%varargslots45 = alloca [1 x %variant], align 16
|
|
%taddr46 = alloca i64, align 8
|
|
%retparam49 = alloca i64, align 8
|
|
%varargslots50 = alloca [1 x %variant], align 16
|
|
%taddr51 = alloca i32, align 4
|
|
%retparam54 = alloca i64, align 8
|
|
%varargslots55 = alloca [1 x %variant], align 16
|
|
%taddr56 = alloca i64, align 8
|
|
%retparam59 = alloca i64, align 8
|
|
%varargslots60 = alloca [1 x %variant], align 16
|
|
%error_var = alloca i64, align 8
|
|
%x = alloca i64, align 8
|
|
%retparam65 = alloca i64, align 8
|
|
%varargslots66 = alloca [1 x %variant], align 16
|
|
%xy = alloca i32, align 4
|
|
%xy.f = alloca i64, align 8
|
|
%0 = call i64 @test_get_a(ptr %retparam1, i32 1)
|
|
%not_err = icmp eq i64 %0, 0
|
|
br i1 %not_err, label %after_check, label %else_block
|
|
|
|
after_check: ; preds = %entry
|
|
%1 = load i32, ptr %retparam1, align 4
|
|
br label %phi_block
|
|
|
|
else_block: ; preds = %entry
|
|
%2 = call i64 @test_get_b(ptr %retparam2, i32 4)
|
|
%not_err3 = icmp eq i64 %2, 0
|
|
br i1 %not_err3, label %after_check4, label %else_block5
|
|
|
|
after_check4: ; preds = %else_block
|
|
%3 = load i32, ptr %retparam2, align 4
|
|
br label %phi_block
|
|
|
|
phi_block: ; preds = %after_check4, %after_check
|
|
%val = phi i32 [ %1, %after_check ], [ %3, %after_check4 ]
|
|
br label %phi_block6
|
|
|
|
else_block5: ; preds = %else_block
|
|
br label %phi_block6
|
|
|
|
phi_block6: ; preds = %else_block5, %phi_block
|
|
%val7 = phi i32 [ %val, %phi_block ], [ -1, %else_block5 ]
|
|
store i32 %val7, ptr %taddr, align 4
|
|
%4 = insertvalue %variant undef, ptr %taddr, 0
|
|
%5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$int" to i64), 1
|
|
%6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
|
|
store %variant %5, ptr %6, align 16
|
|
%7 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 4, ptr %varargslots, i64 1)
|
|
%8 = call i64 @test_get_a(ptr %retparam12, i32 2)
|
|
%not_err13 = icmp eq i64 %8, 0
|
|
br i1 %not_err13, label %after_check14, label %else_block15
|
|
|
|
after_check14: ; preds = %phi_block6
|
|
%9 = load i32, ptr %retparam12, align 4
|
|
br label %phi_block19
|
|
|
|
else_block15: ; preds = %phi_block6
|
|
%10 = call i64 @test_get_b(ptr %retparam16, i32 4)
|
|
%not_err17 = icmp eq i64 %10, 0
|
|
br i1 %not_err17, label %after_check18, label %else_block21
|
|
|
|
after_check18: ; preds = %else_block15
|
|
%11 = load i32, ptr %retparam16, align 4
|
|
br label %phi_block19
|
|
|
|
phi_block19: ; preds = %after_check18, %after_check14
|
|
%val20 = phi i32 [ %9, %after_check14 ], [ %11, %after_check18 ]
|
|
br label %phi_block22
|
|
|
|
else_block21: ; preds = %else_block15
|
|
br label %phi_block22
|
|
|
|
phi_block22: ; preds = %else_block21, %phi_block19
|
|
%val23 = phi i32 [ %val20, %phi_block19 ], [ -1, %else_block21 ]
|
|
store i32 %val23, ptr %taddr24, align 4
|
|
%12 = insertvalue %variant undef, ptr %taddr24, 0
|
|
%13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$int" to i64), 1
|
|
%14 = getelementptr inbounds [1 x %variant], ptr %varargslots11, i64 0, i64 0
|
|
store %variant %13, ptr %14, align 16
|
|
%15 = call i64 @std_io_printfn(ptr %retparam10, ptr @.str.2, i64 4, ptr %varargslots11, i64 1)
|
|
%16 = call i64 @test_get_a(ptr %retparam29, i32 1)
|
|
%not_err30 = icmp eq i64 %16, 0
|
|
br i1 %not_err30, label %after_check31, label %else_block32
|
|
|
|
after_check31: ; preds = %phi_block22
|
|
%17 = load i32, ptr %retparam29, align 4
|
|
br label %phi_block36
|
|
|
|
else_block32: ; preds = %phi_block22
|
|
%18 = call i64 @test_get_b(ptr %retparam33, i32 5)
|
|
%not_err34 = icmp eq i64 %18, 0
|
|
br i1 %not_err34, label %after_check35, label %else_block38
|
|
|
|
after_check35: ; preds = %else_block32
|
|
%19 = load i32, ptr %retparam33, align 4
|
|
br label %phi_block36
|
|
|
|
phi_block36: ; preds = %after_check35, %after_check31
|
|
%val37 = phi i32 [ %17, %after_check31 ], [ %19, %after_check35 ]
|
|
br label %phi_block39
|
|
|
|
else_block38: ; preds = %else_block32
|
|
br label %phi_block39
|
|
|
|
phi_block39: ; preds = %else_block38, %phi_block36
|
|
%val40 = phi i32 [ %val37, %phi_block36 ], [ -1, %else_block38 ]
|
|
store i32 %val40, ptr %taddr41, align 4
|
|
%20 = insertvalue %variant undef, ptr %taddr41, 0
|
|
%21 = insertvalue %variant %20, i64 ptrtoint (ptr @"ct$int" to i64), 1
|
|
%22 = getelementptr inbounds [1 x %variant], ptr %varargslots28, i64 0, i64 0
|
|
store %variant %21, ptr %22, align 16
|
|
%23 = call i64 @std_io_printfn(ptr %retparam27, ptr @.str.3, i64 4, ptr %varargslots28, i64 1)
|
|
store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr46, align 8
|
|
%24 = insertvalue %variant undef, ptr %taddr46, 0
|
|
%25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
|
|
%26 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
|
|
store %variant %25, ptr %26, align 16
|
|
%27 = call i64 @std_io_printfn(ptr %retparam44, ptr @.str.4, i64 4, ptr %varargslots45, i64 1)
|
|
store i32 3, ptr %taddr51, align 4
|
|
%28 = insertvalue %variant undef, ptr %taddr51, 0
|
|
%29 = insertvalue %variant %28, i64 ptrtoint (ptr @"ct$int" to i64), 1
|
|
%30 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0
|
|
store %variant %29, ptr %30, align 16
|
|
%31 = call i64 @std_io_printfn(ptr %retparam49, ptr @.str.5, i64 4, ptr %varargslots50, i64 1)
|
|
store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %taddr56, align 8
|
|
%32 = insertvalue %variant undef, ptr %taddr56, 0
|
|
%33 = insertvalue %variant %32, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
|
|
%34 = getelementptr inbounds [1 x %variant], ptr %varargslots55, i64 0, i64 0
|
|
store %variant %33, ptr %34, align 16
|
|
%35 = call i64 @std_io_printfn(ptr %retparam54, ptr @.str.6, i64 4, ptr %varargslots55, i64 1)
|
|
store i64 0, ptr %error_var, align 8
|
|
br label %phi_block62
|
|
|
|
phi_block62: ; preds = %phi_block39
|
|
br label %noerr_block
|
|
|
|
noerr_block: ; preds = %phi_block62
|
|
%36 = insertvalue %variant undef, ptr %error_var, 0
|
|
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
|
|
%38 = getelementptr inbounds [1 x %variant], ptr %varargslots60, i64 0, i64 0
|
|
store %variant %37, ptr %38, align 16
|
|
%39 = call i64 @std_io_printfn(ptr %retparam59, ptr @.str.7, i64 4, ptr %varargslots60, i64 1)
|
|
store i64 3, ptr %x, align 8
|
|
%40 = insertvalue %variant undef, ptr %x, 0
|
|
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$long" to i64), 1
|
|
%42 = getelementptr inbounds [1 x %variant], ptr %varargslots66, i64 0, i64 0
|
|
store %variant %41, ptr %42, align 16
|
|
%43 = call i64 @std_io_printfn(ptr %retparam65, ptr @.str.8, i64 4, ptr %varargslots66, i64 1)
|
|
store i64 ptrtoint (ptr @"test_Foo$DEF" to i64), ptr %xy.f, align 8
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define i64 @test_get_a(ptr %0, i32 %1) #0 {
|
|
entry:
|
|
%reterr = alloca i64, align 8
|
|
%smod = srem i32 %1, 2
|
|
%intbool = icmp ne i32 %smod, 0
|
|
br i1 %intbool, label %if.then, label %if.exit
|
|
|
|
if.then: ; preds = %entry
|
|
ret i64 ptrtoint (ptr @"test_Foo$ABC" to i64)
|
|
|
|
if.exit: ; preds = %entry
|
|
%mul = mul i32 %1, 2
|
|
store i32 %mul, ptr %0, align 4
|
|
ret i64 0
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define i64 @test_get_b(ptr %0, i32 %1) #0 {
|
|
entry:
|
|
%reterr = alloca i64, align 8
|
|
%smod = srem i32 %1, 2
|
|
%eq = icmp eq i32 %smod, 0
|
|
br i1 %eq, label %if.then, label %if.exit
|
|
|
|
if.then: ; preds = %entry
|
|
ret i64 ptrtoint (ptr @"test_Foo$ABC" to i64)
|
|
|
|
if.exit: ; preds = %entry
|
|
%mul = mul i32 %1, 2
|
|
store i32 %mul, ptr %0, align 4
|
|
ret i64 0
|
|
}
|