mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 20:11:17 +00:00
289 lines
11 KiB
C
289 lines
11 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
|
|
bitstruct Foo : int
|
|
{
|
|
bool a : 0;
|
|
bool b : 1;
|
|
}
|
|
|
|
bitstruct Bar : char[13]
|
|
{
|
|
bool z : 0;
|
|
bool w : 1;
|
|
bool gh : 25;
|
|
}
|
|
fn void main()
|
|
{
|
|
Foo f1 = { true, true };
|
|
Foo f2 = { true, false };
|
|
|
|
Foo f3 = f1 & f2;
|
|
io::printfn("%s %s", f3.a, f3.b);
|
|
Foo f4 = (f1 | ~f2) ^ f3;
|
|
io::printfn("%s %s", f4.a, f4.b);
|
|
Foo f5 = Foo { true, false } | Foo { false, true };
|
|
io::printfn("%s %s", f5.a, f5.b);
|
|
|
|
f5 &= f2;
|
|
io::printfn("%s %s", f5.a, f5.b);
|
|
|
|
Bar b1 = { true, true, true };
|
|
Bar b2 = { true, false, false };
|
|
|
|
Bar b3 = b1 & b2;
|
|
io::printfn("%s %s %s", b3.z, b3.w, b3.gh);
|
|
b3 = ~b3;
|
|
io::printfn("%s %s %s", b3.z, b3.w, b3.gh);
|
|
b3 ^= Bar { true, true, false };
|
|
io::printfn("%s %s %s", b3.z, b3.w, b3.gh);
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
define void @test.main() #0 {
|
|
entry:
|
|
%f1 = alloca i32, align 4
|
|
%f2 = alloca i32, align 4
|
|
%f3 = alloca i32, align 4
|
|
%retparam = alloca i64, align 8
|
|
%varargslots = alloca [2 x %any], align 16
|
|
%taddr = alloca i8, align 1
|
|
%taddr2 = alloca i8, align 1
|
|
%f4 = alloca i32, align 4
|
|
%retparam3 = alloca i64, align 8
|
|
%varargslots4 = alloca [2 x %any], align 16
|
|
%taddr6 = alloca i8, align 1
|
|
%taddr9 = alloca i8, align 1
|
|
%f5 = alloca i32, align 4
|
|
%retparam10 = alloca i64, align 8
|
|
%varargslots11 = alloca [2 x %any], align 16
|
|
%taddr13 = alloca i8, align 1
|
|
%taddr16 = alloca i8, align 1
|
|
%retparam18 = alloca i64, align 8
|
|
%varargslots19 = alloca [2 x %any], align 16
|
|
%taddr21 = alloca i8, align 1
|
|
%taddr24 = alloca i8, align 1
|
|
%b1 = alloca [13 x i8], align 1
|
|
%b2 = alloca [13 x i8], align 1
|
|
%b3 = alloca [13 x i8], align 1
|
|
%0 = alloca i104, align 1
|
|
%retparam26 = alloca i64, align 8
|
|
%varargslots27 = alloca [3 x %any], align 16
|
|
%taddr28 = alloca i8, align 1
|
|
%taddr30 = alloca i8, align 1
|
|
%taddr32 = alloca i8, align 1
|
|
%1 = alloca i104, align 1
|
|
%retparam34 = alloca i64, align 8
|
|
%varargslots35 = alloca [3 x %any], align 16
|
|
%taddr36 = alloca i8, align 1
|
|
%taddr38 = alloca i8, align 1
|
|
%taddr40 = alloca i8, align 1
|
|
%taddr41 = alloca [13 x i8], align 1
|
|
%2 = alloca i104, align 1
|
|
%retparam43 = alloca i64, align 8
|
|
%varargslots44 = alloca [3 x %any], align 16
|
|
%taddr45 = alloca i8, align 1
|
|
%taddr47 = alloca i8, align 1
|
|
%taddr49 = alloca i8, align 1
|
|
store i32 3, ptr %f1, align 4
|
|
store i32 1, ptr %f2, align 4
|
|
%3 = load i32, ptr %f1, align 4
|
|
%4 = load i32, ptr %f2, align 4
|
|
%and = and i32 %3, %4
|
|
store i32 %and, ptr %f3, align 4
|
|
%5 = load i32, ptr %f3, align 4
|
|
%6 = and i32 1, %5
|
|
%trunc = trunc i32 %6 to i8
|
|
store i8 %trunc, ptr %taddr, align 1
|
|
%7 = insertvalue %any undef, ptr %taddr, 0
|
|
%8 = insertvalue %any %7, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%9 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 0
|
|
store %any %8, ptr %9, align 16
|
|
%10 = load i32, ptr %f3, align 4
|
|
%lshrl = lshr i32 %10, 1
|
|
%11 = and i32 1, %lshrl
|
|
%trunc1 = trunc i32 %11 to i8
|
|
store i8 %trunc1, ptr %taddr2, align 1
|
|
%12 = insertvalue %any undef, ptr %taddr2, 0
|
|
%13 = insertvalue %any %12, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%14 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 1
|
|
store %any %13, ptr %14, align 16
|
|
%15 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
|
|
%16 = load i32, ptr %f1, align 4
|
|
%17 = load i32, ptr %f2, align 4
|
|
%bnot = xor i32 %17, -1
|
|
%or = or i32 %16, %bnot
|
|
%18 = load i32, ptr %f3, align 4
|
|
%xor = xor i32 %or, %18
|
|
store i32 %xor, ptr %f4, align 4
|
|
%19 = load i32, ptr %f4, align 4
|
|
%20 = and i32 1, %19
|
|
%trunc5 = trunc i32 %20 to i8
|
|
store i8 %trunc5, ptr %taddr6, align 1
|
|
%21 = insertvalue %any undef, ptr %taddr6, 0
|
|
%22 = insertvalue %any %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%23 = getelementptr inbounds [2 x %any], ptr %varargslots4, i64 0, i64 0
|
|
store %any %22, ptr %23, align 16
|
|
%24 = load i32, ptr %f4, align 4
|
|
%lshrl7 = lshr i32 %24, 1
|
|
%25 = and i32 1, %lshrl7
|
|
%trunc8 = trunc i32 %25 to i8
|
|
store i8 %trunc8, ptr %taddr9, align 1
|
|
%26 = insertvalue %any undef, ptr %taddr9, 0
|
|
%27 = insertvalue %any %26, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%28 = getelementptr inbounds [2 x %any], ptr %varargslots4, i64 0, i64 1
|
|
store %any %27, ptr %28, align 16
|
|
%29 = call i64 @std.io.printfn(ptr %retparam3, ptr @.str.1, i64 5, ptr %varargslots4, i64 2)
|
|
store i32 3, ptr %f5, align 4
|
|
%30 = load i32, ptr %f5, align 4
|
|
%31 = and i32 1, %30
|
|
%trunc12 = trunc i32 %31 to i8
|
|
store i8 %trunc12, ptr %taddr13, align 1
|
|
%32 = insertvalue %any undef, ptr %taddr13, 0
|
|
%33 = insertvalue %any %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%34 = getelementptr inbounds [2 x %any], ptr %varargslots11, i64 0, i64 0
|
|
store %any %33, ptr %34, align 16
|
|
%35 = load i32, ptr %f5, align 4
|
|
%lshrl14 = lshr i32 %35, 1
|
|
%36 = and i32 1, %lshrl14
|
|
%trunc15 = trunc i32 %36 to i8
|
|
store i8 %trunc15, ptr %taddr16, align 1
|
|
%37 = insertvalue %any undef, ptr %taddr16, 0
|
|
%38 = insertvalue %any %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%39 = getelementptr inbounds [2 x %any], ptr %varargslots11, i64 0, i64 1
|
|
store %any %38, ptr %39, align 16
|
|
%40 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.2, i64 5, ptr %varargslots11, i64 2)
|
|
%41 = load i32, ptr %f5, align 4
|
|
%42 = load i32, ptr %f2, align 4
|
|
%and17 = and i32 %41, %42
|
|
store i32 %and17, ptr %f5, align 4
|
|
%43 = load i32, ptr %f5, align 4
|
|
%44 = and i32 1, %43
|
|
%trunc20 = trunc i32 %44 to i8
|
|
store i8 %trunc20, ptr %taddr21, align 1
|
|
%45 = insertvalue %any undef, ptr %taddr21, 0
|
|
%46 = insertvalue %any %45, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%47 = getelementptr inbounds [2 x %any], ptr %varargslots19, i64 0, i64 0
|
|
store %any %46, ptr %47, align 16
|
|
%48 = load i32, ptr %f5, align 4
|
|
%lshrl22 = lshr i32 %48, 1
|
|
%49 = and i32 1, %lshrl22
|
|
%trunc23 = trunc i32 %49 to i8
|
|
store i8 %trunc23, ptr %taddr24, align 1
|
|
%50 = insertvalue %any undef, ptr %taddr24, 0
|
|
%51 = insertvalue %any %50, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%52 = getelementptr inbounds [2 x %any], ptr %varargslots19, i64 0, i64 1
|
|
store %any %51, ptr %52, align 16
|
|
%53 = call i64 @std.io.printfn(ptr %retparam18, ptr @.str.3, i64 5, ptr %varargslots19, i64 2)
|
|
store [13 x i8] c"\03\00\00\02\00\00\00\00\00\00\00\00\00", ptr %b1, align 1
|
|
store [13 x i8] c"\01\00\00\00\00\00\00\00\00\00\00\00\00", ptr %b2, align 1
|
|
%54 = load i104, ptr %b1, align 1
|
|
%55 = load i104, ptr %b2, align 1
|
|
%and25 = and i104 %54, %55
|
|
store i104 %and25, ptr %0, align 8
|
|
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b3, ptr align 1 %0, i32 13, i1 false)
|
|
%56 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
|
|
%57 = load i8, ptr %56, align 1
|
|
%58 = trunc i8 %57 to i1
|
|
%59 = zext i1 %58 to i8
|
|
store i8 %59, ptr %taddr28, align 1
|
|
%60 = insertvalue %any undef, ptr %taddr28, 0
|
|
%61 = insertvalue %any %60, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%62 = getelementptr inbounds [3 x %any], ptr %varargslots27, i64 0, i64 0
|
|
store %any %61, ptr %62, align 16
|
|
%63 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
|
|
%64 = load i8, ptr %63, align 1
|
|
%lshrl29 = lshr i8 %64, 1
|
|
%65 = trunc i8 %lshrl29 to i1
|
|
%66 = zext i1 %65 to i8
|
|
store i8 %66, ptr %taddr30, align 1
|
|
%67 = insertvalue %any undef, ptr %taddr30, 0
|
|
%68 = insertvalue %any %67, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%69 = getelementptr inbounds [3 x %any], ptr %varargslots27, i64 0, i64 1
|
|
store %any %68, ptr %69, align 16
|
|
%70 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
|
|
%71 = load i8, ptr %70, align 1
|
|
%lshrl31 = lshr i8 %71, 1
|
|
%72 = trunc i8 %lshrl31 to i1
|
|
%73 = zext i1 %72 to i8
|
|
store i8 %73, ptr %taddr32, align 1
|
|
%74 = insertvalue %any undef, ptr %taddr32, 0
|
|
%75 = insertvalue %any %74, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%76 = getelementptr inbounds [3 x %any], ptr %varargslots27, i64 0, i64 2
|
|
store %any %75, ptr %76, align 16
|
|
%77 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.4, i64 8, ptr %varargslots27, i64 3)
|
|
%78 = load i104, ptr %b3, align 1
|
|
%bnot33 = xor i104 %78, -1
|
|
store i104 %bnot33, ptr %1, align 8
|
|
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b3, ptr align 1 %1, i32 13, i1 false)
|
|
%79 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
|
|
%80 = load i8, ptr %79, align 1
|
|
%81 = trunc i8 %80 to i1
|
|
%82 = zext i1 %81 to i8
|
|
store i8 %82, ptr %taddr36, align 1
|
|
%83 = insertvalue %any undef, ptr %taddr36, 0
|
|
%84 = insertvalue %any %83, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%85 = getelementptr inbounds [3 x %any], ptr %varargslots35, i64 0, i64 0
|
|
store %any %84, ptr %85, align 16
|
|
%86 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
|
|
%87 = load i8, ptr %86, align 1
|
|
%lshrl37 = lshr i8 %87, 1
|
|
%88 = trunc i8 %lshrl37 to i1
|
|
%89 = zext i1 %88 to i8
|
|
store i8 %89, ptr %taddr38, align 1
|
|
%90 = insertvalue %any undef, ptr %taddr38, 0
|
|
%91 = insertvalue %any %90, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%92 = getelementptr inbounds [3 x %any], ptr %varargslots35, i64 0, i64 1
|
|
store %any %91, ptr %92, align 16
|
|
%93 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
|
|
%94 = load i8, ptr %93, align 1
|
|
%lshrl39 = lshr i8 %94, 1
|
|
%95 = trunc i8 %lshrl39 to i1
|
|
%96 = zext i1 %95 to i8
|
|
store i8 %96, ptr %taddr40, align 1
|
|
%97 = insertvalue %any undef, ptr %taddr40, 0
|
|
%98 = insertvalue %any %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%99 = getelementptr inbounds [3 x %any], ptr %varargslots35, i64 0, i64 2
|
|
store %any %98, ptr %99, align 16
|
|
%100 = call i64 @std.io.printfn(ptr %retparam34, ptr @.str.5, i64 8, ptr %varargslots35, i64 3)
|
|
store [13 x i8] c"\03\00\00\00\00\00\00\00\00\00\00\00\00", ptr %taddr41, align 1
|
|
%101 = load i104, ptr %b3, align 1
|
|
%102 = load i104, ptr %taddr41, align 1
|
|
%xor42 = xor i104 %101, %102
|
|
store i104 %xor42, ptr %2, align 8
|
|
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %b3, ptr align 1 %2, i32 13, i1 false)
|
|
%103 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
|
|
%104 = load i8, ptr %103, align 1
|
|
%105 = trunc i8 %104 to i1
|
|
%106 = zext i1 %105 to i8
|
|
store i8 %106, ptr %taddr45, align 1
|
|
%107 = insertvalue %any undef, ptr %taddr45, 0
|
|
%108 = insertvalue %any %107, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%109 = getelementptr inbounds [3 x %any], ptr %varargslots44, i64 0, i64 0
|
|
store %any %108, ptr %109, align 16
|
|
%110 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 0
|
|
%111 = load i8, ptr %110, align 1
|
|
%lshrl46 = lshr i8 %111, 1
|
|
%112 = trunc i8 %lshrl46 to i1
|
|
%113 = zext i1 %112 to i8
|
|
store i8 %113, ptr %taddr47, align 1
|
|
%114 = insertvalue %any undef, ptr %taddr47, 0
|
|
%115 = insertvalue %any %114, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%116 = getelementptr inbounds [3 x %any], ptr %varargslots44, i64 0, i64 1
|
|
store %any %115, ptr %116, align 16
|
|
%117 = getelementptr inbounds [13 x i8], ptr %b3, i64 0, i64 3
|
|
%118 = load i8, ptr %117, align 1
|
|
%lshrl48 = lshr i8 %118, 1
|
|
%119 = trunc i8 %lshrl48 to i1
|
|
%120 = zext i1 %119 to i8
|
|
store i8 %120, ptr %taddr49, align 1
|
|
%121 = insertvalue %any undef, ptr %taddr49, 0
|
|
%122 = insertvalue %any %121, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%123 = getelementptr inbounds [3 x %any], ptr %varargslots44, i64 0, i64 2
|
|
store %any %122, ptr %123, align 16
|
|
%124 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.6, i64 8, ptr %varargslots44, i64 3)
|
|
ret void
|
|
}
|