mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +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
|
|
%varargslots = alloca [2 x %"any*"], align 16
|
|
%taddr = alloca i8, align 1
|
|
%taddr2 = alloca i8, align 1
|
|
%retparam = alloca i64, align 8
|
|
%f4 = alloca i32, align 4
|
|
%varargslots3 = alloca [2 x %"any*"], align 16
|
|
%taddr5 = alloca i8, align 1
|
|
%taddr8 = alloca i8, align 1
|
|
%retparam9 = alloca i64, align 8
|
|
%f5 = alloca i32, align 4
|
|
%varargslots10 = alloca [2 x %"any*"], align 16
|
|
%taddr12 = alloca i8, align 1
|
|
%taddr15 = alloca i8, align 1
|
|
%retparam16 = alloca i64, align 8
|
|
%varargslots18 = alloca [2 x %"any*"], align 16
|
|
%taddr20 = alloca i8, align 1
|
|
%taddr23 = alloca i8, align 1
|
|
%retparam24 = alloca i64, align 8
|
|
%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
|
|
%varargslots26 = alloca [3 x %"any*"], align 16
|
|
%taddr27 = alloca i8, align 1
|
|
%taddr29 = alloca i8, align 1
|
|
%taddr31 = alloca i8, align 1
|
|
%retparam32 = alloca i64, align 8
|
|
%1 = alloca i104, align 1
|
|
%varargslots34 = alloca [3 x %"any*"], align 16
|
|
%taddr35 = alloca i8, align 1
|
|
%taddr37 = alloca i8, align 1
|
|
%taddr39 = alloca i8, align 1
|
|
%retparam40 = alloca i64, align 8
|
|
%taddr41 = alloca [13 x i8], align 1
|
|
%2 = alloca i104, align 1
|
|
%varargslots43 = alloca [3 x %"any*"], align 16
|
|
%taddr44 = alloca i8, align 1
|
|
%taddr46 = alloca i8, align 1
|
|
%taddr48 = alloca i8, align 1
|
|
%retparam49 = alloca i64, align 8
|
|
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
|
|
%trunc4 = trunc i32 %20 to i8
|
|
store i8 %trunc4, ptr %taddr5, align 1
|
|
%21 = insertvalue %"any*" undef, ptr %taddr5, 0
|
|
%22 = insertvalue %"any*" %21, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%23 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 0
|
|
store %"any*" %22, ptr %23, align 16
|
|
%24 = load i32, ptr %f4, align 4
|
|
%lshrl6 = lshr i32 %24, 1
|
|
%25 = and i32 1, %lshrl6
|
|
%trunc7 = trunc i32 %25 to i8
|
|
store i8 %trunc7, ptr %taddr8, align 1
|
|
%26 = insertvalue %"any*" undef, ptr %taddr8, 0
|
|
%27 = insertvalue %"any*" %26, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%28 = getelementptr inbounds [2 x %"any*"], ptr %varargslots3, i64 0, i64 1
|
|
store %"any*" %27, ptr %28, align 16
|
|
%29 = call i64 @std.io.printfn(ptr %retparam9, ptr @.str.1, i64 5, ptr %varargslots3, i64 2)
|
|
store i32 3, ptr %f5, align 4
|
|
%30 = load i32, ptr %f5, align 4
|
|
%31 = and i32 1, %30
|
|
%trunc11 = trunc i32 %31 to i8
|
|
store i8 %trunc11, ptr %taddr12, align 1
|
|
%32 = insertvalue %"any*" undef, ptr %taddr12, 0
|
|
%33 = insertvalue %"any*" %32, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%34 = getelementptr inbounds [2 x %"any*"], ptr %varargslots10, i64 0, i64 0
|
|
store %"any*" %33, ptr %34, align 16
|
|
%35 = load i32, ptr %f5, align 4
|
|
%lshrl13 = lshr i32 %35, 1
|
|
%36 = and i32 1, %lshrl13
|
|
%trunc14 = trunc i32 %36 to i8
|
|
store i8 %trunc14, ptr %taddr15, align 1
|
|
%37 = insertvalue %"any*" undef, ptr %taddr15, 0
|
|
%38 = insertvalue %"any*" %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%39 = getelementptr inbounds [2 x %"any*"], ptr %varargslots10, i64 0, i64 1
|
|
store %"any*" %38, ptr %39, align 16
|
|
%40 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.2, i64 5, ptr %varargslots10, 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
|
|
%trunc19 = trunc i32 %44 to i8
|
|
store i8 %trunc19, ptr %taddr20, align 1
|
|
%45 = insertvalue %"any*" undef, ptr %taddr20, 0
|
|
%46 = insertvalue %"any*" %45, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%47 = getelementptr inbounds [2 x %"any*"], ptr %varargslots18, i64 0, i64 0
|
|
store %"any*" %46, ptr %47, align 16
|
|
%48 = load i32, ptr %f5, align 4
|
|
%lshrl21 = lshr i32 %48, 1
|
|
%49 = and i32 1, %lshrl21
|
|
%trunc22 = trunc i32 %49 to i8
|
|
store i8 %trunc22, ptr %taddr23, align 1
|
|
%50 = insertvalue %"any*" undef, ptr %taddr23, 0
|
|
%51 = insertvalue %"any*" %50, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%52 = getelementptr inbounds [2 x %"any*"], ptr %varargslots18, i64 0, i64 1
|
|
store %"any*" %51, ptr %52, align 16
|
|
%53 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.3, i64 5, ptr %varargslots18, 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 %taddr27, align 1
|
|
%60 = insertvalue %"any*" undef, ptr %taddr27, 0
|
|
%61 = insertvalue %"any*" %60, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%62 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, 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
|
|
%lshrl28 = lshr i8 %64, 1
|
|
%65 = trunc i8 %lshrl28 to i1
|
|
%66 = zext i1 %65 to i8
|
|
store i8 %66, ptr %taddr29, align 1
|
|
%67 = insertvalue %"any*" undef, ptr %taddr29, 0
|
|
%68 = insertvalue %"any*" %67, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%69 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, 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
|
|
%lshrl30 = lshr i8 %71, 1
|
|
%72 = trunc i8 %lshrl30 to i1
|
|
%73 = zext i1 %72 to i8
|
|
store i8 %73, ptr %taddr31, align 1
|
|
%74 = insertvalue %"any*" undef, ptr %taddr31, 0
|
|
%75 = insertvalue %"any*" %74, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%76 = getelementptr inbounds [3 x %"any*"], ptr %varargslots26, i64 0, i64 2
|
|
store %"any*" %75, ptr %76, align 16
|
|
%77 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.4, i64 8, ptr %varargslots26, 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 %taddr35, align 1
|
|
%83 = insertvalue %"any*" undef, ptr %taddr35, 0
|
|
%84 = insertvalue %"any*" %83, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%85 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, 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
|
|
%lshrl36 = lshr i8 %87, 1
|
|
%88 = trunc i8 %lshrl36 to i1
|
|
%89 = zext i1 %88 to i8
|
|
store i8 %89, ptr %taddr37, align 1
|
|
%90 = insertvalue %"any*" undef, ptr %taddr37, 0
|
|
%91 = insertvalue %"any*" %90, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%92 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, 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
|
|
%lshrl38 = lshr i8 %94, 1
|
|
%95 = trunc i8 %lshrl38 to i1
|
|
%96 = zext i1 %95 to i8
|
|
store i8 %96, ptr %taddr39, align 1
|
|
%97 = insertvalue %"any*" undef, ptr %taddr39, 0
|
|
%98 = insertvalue %"any*" %97, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%99 = getelementptr inbounds [3 x %"any*"], ptr %varargslots34, i64 0, i64 2
|
|
store %"any*" %98, ptr %99, align 16
|
|
%100 = call i64 @std.io.printfn(ptr %retparam40, ptr @.str.5, i64 8, ptr %varargslots34, 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 %taddr44, align 1
|
|
%107 = insertvalue %"any*" undef, ptr %taddr44, 0
|
|
%108 = insertvalue %"any*" %107, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%109 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, 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
|
|
%lshrl45 = lshr i8 %111, 1
|
|
%112 = trunc i8 %lshrl45 to i1
|
|
%113 = zext i1 %112 to i8
|
|
store i8 %113, ptr %taddr46, align 1
|
|
%114 = insertvalue %"any*" undef, ptr %taddr46, 0
|
|
%115 = insertvalue %"any*" %114, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%116 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, 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
|
|
%lshrl47 = lshr i8 %118, 1
|
|
%119 = trunc i8 %lshrl47 to i1
|
|
%120 = zext i1 %119 to i8
|
|
store i8 %120, ptr %taddr48, align 1
|
|
%121 = insertvalue %"any*" undef, ptr %taddr48, 0
|
|
%122 = insertvalue %"any*" %121, i64 ptrtoint (ptr @"$ct.bool" to i64), 1
|
|
%123 = getelementptr inbounds [3 x %"any*"], ptr %varargslots43, i64 0, i64 2
|
|
store %"any*" %122, ptr %123, align 16
|
|
%124 = call i64 @std.io.printfn(ptr %retparam49, ptr @.str.6, i64 8, ptr %varargslots43, i64 3)
|
|
ret void
|
|
}
|