mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 20:11:17 +00:00
220 lines
8.5 KiB
C
220 lines
8.5 KiB
C
// #target: macos-x64
|
|
module test;
|
|
import std::io;
|
|
|
|
bitstruct Test : int @bigendian
|
|
{
|
|
ushort a : 0..15;
|
|
ushort b : 16..31;
|
|
}
|
|
|
|
bitstruct Test2 : char[4] @bigendian
|
|
{
|
|
ushort a : 0..15;
|
|
ushort b : 16..31;
|
|
}
|
|
|
|
fn void main()
|
|
{
|
|
IntBE x;
|
|
x.val = 123;
|
|
|
|
io::printf("BE 123 => %d (%d)\n", (int)x, x.val);
|
|
Test abc = { .a = 0x1234, .b = 0x5678 };
|
|
Test2 abc2 = { .a = 0x1234, .b = 0x5678 };
|
|
char[4]* z = (char[4]*)&abc;
|
|
char[4]* z2 = (char[4]*)&abc2;
|
|
foreach (d : z2) io::printf(" %x", d);
|
|
io::printn("");
|
|
foreach (d : z) io::printf(" %x", d);
|
|
io::printn("");
|
|
io::printfn("abc.a = %x", abc.a);
|
|
abc.a = 0x1234;
|
|
abc.b = 0x5678;
|
|
io::printfn("->abc.a = %x", abc.a);
|
|
foreach (d : z) io::printf(" %x", d);
|
|
io::printn("");
|
|
|
|
IntLE y;
|
|
y.val = 123;
|
|
io::printf("LE 123 => %d (%d)\n", (int)y, y.val);
|
|
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
%0 = load i32, ptr %x, align 4
|
|
%1 = call i32 @llvm.bswap.i32(i32 %0)
|
|
store i32 2063597568, ptr %x, align 4
|
|
%2 = insertvalue %any undef, ptr %x, 0
|
|
%3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%4 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 0
|
|
store %any %3, ptr %4, align 16
|
|
%5 = load i32, ptr %x, align 4
|
|
%6 = call i32 @llvm.bswap.i32(i32 %5)
|
|
store i32 %6, ptr %taddr, align 4
|
|
%7 = insertvalue %any undef, ptr %taddr, 0
|
|
%8 = insertvalue %any %7, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%9 = getelementptr inbounds [2 x %any], ptr %varargslots, i64 0, i64 1
|
|
store %any %8, ptr %9, align 16
|
|
%10 = call i64 @std.io.printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
|
|
store i32 873625686, ptr %abc, align 4
|
|
store [4 x i8] c"\124Vx", ptr %abc2, align 1
|
|
store ptr %abc, ptr %z, align 8
|
|
store ptr %abc2, ptr %z2, align 8
|
|
%11 = load ptr, ptr %z2, align 8
|
|
store ptr %11, ptr %.anon, align 8
|
|
store i64 0, ptr %.anon1, align 8
|
|
br label %loop.cond
|
|
|
|
loop.cond: ; preds = %loop.body, %entry
|
|
%12 = load i64, ptr %.anon1, align 8
|
|
%gt = icmp ugt i64 4, %12
|
|
br i1 %gt, label %loop.body, label %loop.exit
|
|
|
|
loop.body: ; preds = %loop.cond
|
|
%13 = load ptr, ptr %.anon, align 8
|
|
%14 = load i64, ptr %.anon1, align 8
|
|
%15 = getelementptr inbounds [4 x i8], ptr %13, i64 0, i64 %14
|
|
%16 = load i8, ptr %15, align 1
|
|
store i8 %16, ptr %d, align 1
|
|
%17 = insertvalue %any undef, ptr %d, 0
|
|
%18 = insertvalue %any %17, i64 ptrtoint (ptr @"$ct.char" to i64), 1
|
|
%19 = getelementptr inbounds [1 x %any], ptr %varargslots3, i64 0, i64 0
|
|
store %any %18, ptr %19, align 16
|
|
%20 = call i64 @std.io.printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
|
|
%21 = load i64, ptr %.anon1, align 8
|
|
%add = add i64 %21, 1
|
|
store i64 %add, ptr %.anon1, align 8
|
|
br label %loop.cond
|
|
|
|
loop.exit: ; preds = %loop.cond
|
|
store %"char[]" zeroinitializer, ptr %x4, align 8
|
|
%22 = call ptr @std.io.stdout()
|
|
store ptr %22, ptr %result, align 8
|
|
%23 = load ptr, ptr %result, align 8
|
|
%24 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 0
|
|
%lo = load ptr, ptr %24, align 8
|
|
%25 = getelementptr inbounds %"char[]", ptr %x4, i32 0, i32 1
|
|
%hi = load i64, ptr %25, align 8
|
|
%26 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr %lo, i64 %hi)
|
|
%27 = load ptr, ptr %z, align 8
|
|
store ptr %27, ptr %.anon6, align 8
|
|
store i64 0, ptr %.anon7, align 8
|
|
br label %loop.cond8
|
|
|
|
loop.cond8: ; preds = %loop.body10, %loop.exit
|
|
%28 = load i64, ptr %.anon7, align 8
|
|
%gt9 = icmp ugt i64 4, %28
|
|
br i1 %gt9, label %loop.body10, label %loop.exit15
|
|
|
|
loop.body10: ; preds = %loop.cond8
|
|
%29 = load ptr, ptr %.anon6, align 8
|
|
%30 = load i64, ptr %.anon7, align 8
|
|
%31 = getelementptr inbounds [4 x i8], ptr %29, i64 0, i64 %30
|
|
%32 = load i8, ptr %31, align 1
|
|
store i8 %32, ptr %d11, align 1
|
|
%33 = insertvalue %any undef, ptr %d11, 0
|
|
%34 = insertvalue %any %33, i64 ptrtoint (ptr @"$ct.char" to i64), 1
|
|
%35 = getelementptr inbounds [1 x %any], ptr %varargslots13, i64 0, i64 0
|
|
store %any %34, ptr %35, align 16
|
|
%36 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.2, i64 3, ptr %varargslots13, i64 1)
|
|
%37 = load i64, ptr %.anon7, align 8
|
|
%add14 = add i64 %37, 1
|
|
store i64 %add14, ptr %.anon7, align 8
|
|
br label %loop.cond8
|
|
|
|
loop.exit15: ; preds = %loop.cond8
|
|
store %"char[]" zeroinitializer, ptr %x16, align 8
|
|
%38 = call ptr @std.io.stdout()
|
|
store ptr %38, ptr %result18, align 8
|
|
%39 = load ptr, ptr %result18, align 8
|
|
%40 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 0
|
|
%lo19 = load ptr, ptr %40, align 8
|
|
%41 = getelementptr inbounds %"char[]", ptr %x16, i32 0, i32 1
|
|
%hi20 = load i64, ptr %41, align 8
|
|
%42 = call i64 @std.io.File.printn(ptr %retparam17, ptr %39, ptr %lo19, i64 %hi20)
|
|
%43 = load i32, ptr %abc, align 4
|
|
%44 = call i32 @llvm.bswap.i32(i32 %43)
|
|
%45 = and i32 65535, %44
|
|
%trunc = trunc i32 %45 to i16
|
|
store i16 %trunc, ptr %taddr23, align 2
|
|
%46 = insertvalue %any undef, ptr %taddr23, 0
|
|
%47 = insertvalue %any %46, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
|
|
%48 = getelementptr inbounds [1 x %any], ptr %varargslots22, i64 0, i64 0
|
|
store %any %47, ptr %48, align 16
|
|
%49 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.3, i64 10, ptr %varargslots22, i64 1)
|
|
%50 = load i32, ptr %abc, align 4
|
|
%51 = call i32 @llvm.bswap.i32(i32 %50)
|
|
%52 = and i32 %51, -65536
|
|
%53 = or i32 %52, 4660
|
|
%54 = call i32 @llvm.bswap.i32(i32 %53)
|
|
store i32 %54, ptr %abc, align 4
|
|
%55 = load i32, ptr %abc, align 4
|
|
%56 = call i32 @llvm.bswap.i32(i32 %55)
|
|
%57 = and i32 %56, 65535
|
|
%58 = or i32 %57, 1450704896
|
|
%59 = call i32 @llvm.bswap.i32(i32 %58)
|
|
store i32 %59, ptr %abc, align 4
|
|
%60 = load i32, ptr %abc, align 4
|
|
%61 = call i32 @llvm.bswap.i32(i32 %60)
|
|
%62 = and i32 65535, %61
|
|
%trunc26 = trunc i32 %62 to i16
|
|
store i16 %trunc26, ptr %taddr27, align 2
|
|
%63 = insertvalue %any undef, ptr %taddr27, 0
|
|
%64 = insertvalue %any %63, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
|
|
%65 = getelementptr inbounds [1 x %any], ptr %varargslots25, i64 0, i64 0
|
|
store %any %64, ptr %65, align 16
|
|
%66 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.4, i64 12, ptr %varargslots25, i64 1)
|
|
%67 = load ptr, ptr %z, align 8
|
|
store ptr %67, ptr %.anon28, align 8
|
|
store i64 0, ptr %.anon29, align 8
|
|
br label %loop.cond30
|
|
|
|
loop.cond30: ; preds = %loop.body32, %loop.exit15
|
|
%68 = load i64, ptr %.anon29, align 8
|
|
%gt31 = icmp ugt i64 4, %68
|
|
br i1 %gt31, label %loop.body32, label %loop.exit37
|
|
|
|
loop.body32: ; preds = %loop.cond30
|
|
%69 = load ptr, ptr %.anon28, align 8
|
|
%70 = load i64, ptr %.anon29, align 8
|
|
%71 = getelementptr inbounds [4 x i8], ptr %69, i64 0, i64 %70
|
|
%72 = load i8, ptr %71, align 1
|
|
store i8 %72, ptr %d33, align 1
|
|
%73 = insertvalue %any undef, ptr %d33, 0
|
|
%74 = insertvalue %any %73, i64 ptrtoint (ptr @"$ct.char" to i64), 1
|
|
%75 = getelementptr inbounds [1 x %any], ptr %varargslots35, i64 0, i64 0
|
|
store %any %74, ptr %75, align 16
|
|
%76 = call i64 @std.io.printf(ptr %retparam34, ptr @.str.5, i64 3, ptr %varargslots35, i64 1)
|
|
%77 = load i64, ptr %.anon29, align 8
|
|
%add36 = add i64 %77, 1
|
|
store i64 %add36, ptr %.anon29, align 8
|
|
br label %loop.cond30
|
|
|
|
loop.exit37: ; preds = %loop.cond30
|
|
store %"char[]" zeroinitializer, ptr %x38, align 8
|
|
%78 = call ptr @std.io.stdout()
|
|
store ptr %78, ptr %result40, align 8
|
|
%79 = load ptr, ptr %result40, align 8
|
|
%80 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 0
|
|
%lo41 = load ptr, ptr %80, align 8
|
|
%81 = getelementptr inbounds %"char[]", ptr %x38, i32 0, i32 1
|
|
%hi42 = load i64, ptr %81, align 8
|
|
%82 = call i64 @std.io.File.printn(ptr %retparam39, ptr %79, ptr %lo41, i64 %hi42)
|
|
store i32 0, ptr %y, align 4
|
|
%83 = load i32, ptr %y, align 4
|
|
store i32 123, ptr %y, align 4
|
|
%84 = insertvalue %any undef, ptr %y, 0
|
|
%85 = insertvalue %any %84, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%86 = getelementptr inbounds [2 x %any], ptr %varargslots44, i64 0, i64 0
|
|
store %any %85, ptr %86, align 16
|
|
%87 = load i32, ptr %y, align 4
|
|
store i32 %87, ptr %taddr45, align 4
|
|
%88 = insertvalue %any undef, ptr %taddr45, 0
|
|
%89 = insertvalue %any %88, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%90 = getelementptr inbounds [2 x %any], ptr %varargslots44, i64 0, i64 1
|
|
store %any %89, ptr %90, align 16
|
|
%91 = call i64 @std.io.printf(ptr %retparam43, ptr @.str.6, i64 18, ptr %varargslots44, i64 2)
|
|
ret void
|
|
}
|