mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
219 lines
11 KiB
C
219 lines
11 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
import std::enumset;
|
|
|
|
define AbcEnumSet = EnumSet<Abc>;
|
|
|
|
enum Abc
|
|
{
|
|
HELLO,
|
|
WORLD
|
|
}
|
|
fn void main()
|
|
{
|
|
AbcEnumSet set;
|
|
io::printf("Has WORLD: %s\n", set.has(Abc.WORLD));
|
|
set.add(Abc.HELLO);
|
|
io::printf("Has WORLD: %s\n", set.has(Abc.WORLD));
|
|
set.add(Abc.WORLD);
|
|
io::printf("Has WORLD: %s\n", set.has(Abc.WORLD));
|
|
AbcEnumSet set2;
|
|
set2.add_all(set);
|
|
io::printf("Has WORLD: %s\n", set2.has(Abc.WORLD));
|
|
set.remove_all(set2);
|
|
io::printf("Has WORLD: %s\n", set.has(Abc.WORLD));
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
define void @test_main() #0 {
|
|
entry:
|
|
%set = alloca i32, align 4
|
|
%retparam = alloca i64, align 8
|
|
%taddr = alloca %"char[]", align 8
|
|
%vararg = alloca %"variant[]", align 8
|
|
%varargslots = alloca [1 x %variant], align 16
|
|
%taddr1 = alloca i8, align 1
|
|
%retparam4 = alloca i64, align 8
|
|
%taddr5 = alloca %"char[]", align 8
|
|
%vararg8 = alloca %"variant[]", align 8
|
|
%varargslots9 = alloca [1 x %variant], align 16
|
|
%taddr10 = alloca i8, align 1
|
|
%retparam16 = alloca i64, align 8
|
|
%taddr17 = alloca %"char[]", align 8
|
|
%vararg20 = alloca %"variant[]", align 8
|
|
%varargslots21 = alloca [1 x %variant], align 16
|
|
%taddr22 = alloca i8, align 1
|
|
%set2 = alloca i32, align 4
|
|
%retparam28 = alloca i64, align 8
|
|
%taddr29 = alloca %"char[]", align 8
|
|
%vararg32 = alloca %"variant[]", align 8
|
|
%varargslots33 = alloca [1 x %variant], align 16
|
|
%taddr34 = alloca i8, align 1
|
|
%retparam40 = alloca i64, align 8
|
|
%taddr41 = alloca %"char[]", align 8
|
|
%vararg44 = alloca %"variant[]", align 8
|
|
%varargslots45 = alloca [1 x %variant], align 16
|
|
%taddr46 = alloca i8, align 1
|
|
store i32 0, i32* %set, align 4
|
|
store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i32 0, i32 0), i64 14 }, %"char[]"* %taddr, align 8
|
|
%0 = bitcast %"char[]"* %taddr to { i8*, i64 }*
|
|
%1 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 0
|
|
%lo = load i8*, i8** %1, align 8
|
|
%2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %0, i32 0, i32 1
|
|
%hi = load i64, i64* %2, align 8
|
|
%3 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1)
|
|
store i8 %3, i8* %taddr1, align 1
|
|
%4 = insertvalue %variant undef, i8* %taddr1, 0
|
|
%5 = insertvalue %variant %4, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%6 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
|
|
store %variant %5, %variant* %6, align 16
|
|
%7 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1
|
|
store i64 1, i64* %7, align 8
|
|
%8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0
|
|
%9 = bitcast [1 x %variant]* %varargslots to %variant*
|
|
store %variant* %9, %variant** %8, align 8
|
|
%10 = bitcast %"variant[]"* %vararg to { i8*, i64 }*
|
|
%11 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %10, i32 0, i32 0
|
|
%lo2 = load i8*, i8** %11, align 8
|
|
%12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %10, i32 0, i32 1
|
|
%hi3 = load i64, i64* %12, align 8
|
|
%13 = call i64 @std_io_printf(i64* %retparam, i8* %lo, i64 %hi, i8* %lo2, i64 %hi3)
|
|
%not_err = icmp eq i64 %13, 0
|
|
br i1 %not_err, label %after.errcheck, label %voiderr
|
|
|
|
after.errcheck: ; preds = %entry
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %after.errcheck, %entry
|
|
call void @"std_enumset$$test_Abc_EnumSet_add"(i32* %set, i32 0)
|
|
store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0), i64 14 }, %"char[]"* %taddr5, align 8
|
|
%14 = bitcast %"char[]"* %taddr5 to { i8*, i64 }*
|
|
%15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0
|
|
%lo6 = load i8*, i8** %15, align 8
|
|
%16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1
|
|
%hi7 = load i64, i64* %16, align 8
|
|
%17 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1)
|
|
store i8 %17, i8* %taddr10, align 1
|
|
%18 = insertvalue %variant undef, i8* %taddr10, 0
|
|
%19 = insertvalue %variant %18, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%20 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots9, i64 0, i64 0
|
|
store %variant %19, %variant* %20, align 16
|
|
%21 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 1
|
|
store i64 1, i64* %21, align 8
|
|
%22 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg8, i32 0, i32 0
|
|
%23 = bitcast [1 x %variant]* %varargslots9 to %variant*
|
|
store %variant* %23, %variant** %22, align 8
|
|
%24 = bitcast %"variant[]"* %vararg8 to { i8*, i64 }*
|
|
%25 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 0
|
|
%lo11 = load i8*, i8** %25, align 8
|
|
%26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %24, i32 0, i32 1
|
|
%hi12 = load i64, i64* %26, align 8
|
|
%27 = call i64 @std_io_printf(i64* %retparam4, i8* %lo6, i64 %hi7, i8* %lo11, i64 %hi12)
|
|
%not_err13 = icmp eq i64 %27, 0
|
|
br i1 %not_err13, label %after.errcheck14, label %voiderr15
|
|
|
|
after.errcheck14: ; preds = %voiderr
|
|
br label %voiderr15
|
|
|
|
voiderr15: ; preds = %after.errcheck14, %voiderr
|
|
call void @"std_enumset$$test_Abc_EnumSet_add"(i32* %set, i32 1)
|
|
store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i32 0, i32 0), i64 14 }, %"char[]"* %taddr17, align 8
|
|
%28 = bitcast %"char[]"* %taddr17 to { i8*, i64 }*
|
|
%29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0
|
|
%lo18 = load i8*, i8** %29, align 8
|
|
%30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1
|
|
%hi19 = load i64, i64* %30, align 8
|
|
%31 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1)
|
|
store i8 %31, i8* %taddr22, align 1
|
|
%32 = insertvalue %variant undef, i8* %taddr22, 0
|
|
%33 = insertvalue %variant %32, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%34 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots21, i64 0, i64 0
|
|
store %variant %33, %variant* %34, align 16
|
|
%35 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 1
|
|
store i64 1, i64* %35, align 8
|
|
%36 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg20, i32 0, i32 0
|
|
%37 = bitcast [1 x %variant]* %varargslots21 to %variant*
|
|
store %variant* %37, %variant** %36, align 8
|
|
%38 = bitcast %"variant[]"* %vararg20 to { i8*, i64 }*
|
|
%39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 0
|
|
%lo23 = load i8*, i8** %39, align 8
|
|
%40 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 1
|
|
%hi24 = load i64, i64* %40, align 8
|
|
%41 = call i64 @std_io_printf(i64* %retparam16, i8* %lo18, i64 %hi19, i8* %lo23, i64 %hi24)
|
|
%not_err25 = icmp eq i64 %41, 0
|
|
br i1 %not_err25, label %after.errcheck26, label %voiderr27
|
|
|
|
after.errcheck26: ; preds = %voiderr15
|
|
br label %voiderr27
|
|
|
|
voiderr27: ; preds = %after.errcheck26, %voiderr15
|
|
store i32 0, i32* %set2, align 4
|
|
%42 = load i32, i32* %set, align 4
|
|
call void @"std_enumset$$test_Abc_EnumSet_add_all"(i32* %set2, i32 %42)
|
|
store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i32 0, i32 0), i64 14 }, %"char[]"* %taddr29, align 8
|
|
%43 = bitcast %"char[]"* %taddr29 to { i8*, i64 }*
|
|
%44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0
|
|
%lo30 = load i8*, i8** %44, align 8
|
|
%45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1
|
|
%hi31 = load i64, i64* %45, align 8
|
|
%46 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set2, i32 1)
|
|
store i8 %46, i8* %taddr34, align 1
|
|
%47 = insertvalue %variant undef, i8* %taddr34, 0
|
|
%48 = insertvalue %variant %47, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%49 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots33, i64 0, i64 0
|
|
store %variant %48, %variant* %49, align 16
|
|
%50 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 1
|
|
store i64 1, i64* %50, align 8
|
|
%51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg32, i32 0, i32 0
|
|
%52 = bitcast [1 x %variant]* %varargslots33 to %variant*
|
|
store %variant* %52, %variant** %51, align 8
|
|
%53 = bitcast %"variant[]"* %vararg32 to { i8*, i64 }*
|
|
%54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 0
|
|
%lo35 = load i8*, i8** %54, align 8
|
|
%55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 1
|
|
%hi36 = load i64, i64* %55, align 8
|
|
%56 = call i64 @std_io_printf(i64* %retparam28, i8* %lo30, i64 %hi31, i8* %lo35, i64 %hi36)
|
|
%not_err37 = icmp eq i64 %56, 0
|
|
br i1 %not_err37, label %after.errcheck38, label %voiderr39
|
|
|
|
after.errcheck38: ; preds = %voiderr27
|
|
br label %voiderr39
|
|
|
|
voiderr39: ; preds = %after.errcheck38, %voiderr27
|
|
%57 = load i32, i32* %set2, align 4
|
|
call void @"std_enumset$$test_Abc_EnumSet_remove_all"(i32* %set, i32 %57)
|
|
store %"char[]" { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i32 0, i32 0), i64 14 }, %"char[]"* %taddr41, align 8
|
|
%58 = bitcast %"char[]"* %taddr41 to { i8*, i64 }*
|
|
%59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0
|
|
%lo42 = load i8*, i8** %59, align 8
|
|
%60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1
|
|
%hi43 = load i64, i64* %60, align 8
|
|
%61 = call i8 @"std_enumset$$test_Abc_EnumSet_has"(i32* %set, i32 1)
|
|
store i8 %61, i8* %taddr46, align 1
|
|
%62 = insertvalue %variant undef, i8* %taddr46, 0
|
|
%63 = insertvalue %variant %62, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
|
|
%64 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0
|
|
store %variant %63, %variant* %64, align 16
|
|
%65 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1
|
|
store i64 1, i64* %65, align 8
|
|
%66 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0
|
|
%67 = bitcast [1 x %variant]* %varargslots45 to %variant*
|
|
store %variant* %67, %variant** %66, align 8
|
|
%68 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }*
|
|
%69 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %68, i32 0, i32 0
|
|
%lo47 = load i8*, i8** %69, align 8
|
|
%70 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %68, i32 0, i32 1
|
|
%hi48 = load i64, i64* %70, align 8
|
|
%71 = call i64 @std_io_printf(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo47, i64 %hi48)
|
|
%not_err49 = icmp eq i64 %71, 0
|
|
br i1 %not_err49, label %after.errcheck50, label %voiderr51
|
|
|
|
after.errcheck50: ; preds = %voiderr39
|
|
br label %voiderr51
|
|
|
|
voiderr51: ; preds = %after.errcheck50, %voiderr39
|
|
ret void
|
|
}
|