mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 20:11:17 +00:00
e293c435af
Upgrade of mingw in CI. Fix problems using reflection on interface types #1203. Improved debug information on defer. $foreach doesn't create an implicit syntactic scope. Error if `@if` depends on `@if`. Updated Linux stacktrace. Fix of default argument stacktrace. Allow linking libraries directly by file path. Improve inlining warning messages. Added `index_of_char_from`. Compiler crash using enum nameof from different module #1205. Removed unused fields in find_msvc. Use vswhere to find msvc. Update tests for LLVM 19
354 lines
13 KiB
C
354 lines
13 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
|
|
store %any %3, ptr %varargslots, align 16
|
|
%4 = load i32, ptr %x, align 4
|
|
%5 = call i32 @llvm.bswap.i32(i32 %4)
|
|
store i32 %5, ptr %taddr, align 4
|
|
%6 = insertvalue %any undef, ptr %taddr, 0
|
|
%7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%ptradd = getelementptr inbounds i8, ptr %varargslots, i64 16
|
|
store %any %7, ptr %ptradd, align 16
|
|
%8 = 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
|
|
%9 = load ptr, ptr %z2, align 8
|
|
store ptr %9, ptr %.anon, align 8
|
|
store i64 0, ptr %.anon1, align 8
|
|
br label %loop.cond
|
|
|
|
loop.cond: ; preds = %loop.body, %entry
|
|
%10 = load i64, ptr %.anon1, align 8
|
|
%gt = icmp ugt i64 4, %10
|
|
br i1 %gt, label %loop.body, label %loop.exit
|
|
|
|
loop.body: ; preds = %loop.cond
|
|
%11 = load ptr, ptr %.anon, align 8
|
|
%12 = load i64, ptr %.anon1, align 8
|
|
%ptradd2 = getelementptr inbounds i8, ptr %11, i64 %12
|
|
%13 = load i8, ptr %ptradd2, align 1
|
|
store i8 %13, ptr %d, align 1
|
|
%14 = insertvalue %any undef, ptr %d, 0
|
|
%15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.char" to i64), 1
|
|
store %any %15, ptr %varargslots3, align 16
|
|
%16 = call i64 @std.io.printf(ptr %retparam4, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
|
|
%17 = load i64, ptr %.anon1, align 8
|
|
%addnuw = add nuw i64 %17, 1
|
|
store i64 %addnuw, ptr %.anon1, align 8
|
|
br label %loop.cond
|
|
|
|
loop.exit: ; preds = %loop.cond
|
|
%18 = call ptr @std.io.stdout()
|
|
%19 = call i64 @std.io.File.write(ptr %retparam6, ptr %18, ptr null, i64 0)
|
|
%not_err = icmp eq i64 %19, 0
|
|
%20 = call i1 @llvm.expect.i1(i1 %not_err, i1 true)
|
|
br i1 %20, label %after_check, label %assign_optional
|
|
|
|
assign_optional: ; preds = %loop.exit
|
|
store i64 %19, ptr %error_var, align 8
|
|
br label %guard_block
|
|
|
|
after_check: ; preds = %loop.exit
|
|
br label %noerr_block
|
|
|
|
guard_block: ; preds = %assign_optional
|
|
br label %voiderr
|
|
|
|
noerr_block: ; preds = %after_check
|
|
%21 = load i64, ptr %retparam6, align 8
|
|
store i64 %21, ptr %len, align 8
|
|
%22 = call i64 @std.io.File.write_byte(ptr %18, i8 zeroext 10)
|
|
%not_err8 = icmp eq i64 %22, 0
|
|
%23 = call i1 @llvm.expect.i1(i1 %not_err8, i1 true)
|
|
br i1 %23, label %after_check10, label %assign_optional9
|
|
|
|
assign_optional9: ; preds = %noerr_block
|
|
store i64 %22, ptr %error_var7, align 8
|
|
br label %guard_block11
|
|
|
|
after_check10: ; preds = %noerr_block
|
|
br label %noerr_block12
|
|
|
|
guard_block11: ; preds = %assign_optional9
|
|
br label %voiderr
|
|
|
|
noerr_block12: ; preds = %after_check10
|
|
%24 = call i64 @std.io.File.flush(ptr %18)
|
|
%not_err14 = icmp eq i64 %24, 0
|
|
%25 = call i1 @llvm.expect.i1(i1 %not_err14, i1 true)
|
|
br i1 %25, label %after_check16, label %assign_optional15
|
|
|
|
assign_optional15: ; preds = %noerr_block12
|
|
store i64 %24, ptr %error_var13, align 8
|
|
br label %guard_block17
|
|
|
|
after_check16: ; preds = %noerr_block12
|
|
br label %noerr_block18
|
|
|
|
guard_block17: ; preds = %assign_optional15
|
|
br label %voiderr
|
|
|
|
noerr_block18: ; preds = %after_check16
|
|
%26 = load i64, ptr %len, align 8
|
|
%add = add i64 %26, 1
|
|
br label %voiderr
|
|
|
|
voiderr: ; preds = %noerr_block18, %guard_block17, %guard_block11, %guard_block
|
|
%27 = load ptr, ptr %z, align 8
|
|
store ptr %27, ptr %.anon19, align 8
|
|
store i64 0, ptr %.anon20, align 8
|
|
br label %loop.cond21
|
|
|
|
loop.cond21: ; preds = %loop.body23, %voiderr
|
|
%28 = load i64, ptr %.anon20, align 8
|
|
%gt22 = icmp ugt i64 4, %28
|
|
br i1 %gt22, label %loop.body23, label %loop.exit31
|
|
|
|
loop.body23: ; preds = %loop.cond21
|
|
%29 = load ptr, ptr %.anon19, align 8
|
|
%30 = load i64, ptr %.anon20, align 8
|
|
%ptradd25 = getelementptr inbounds i8, ptr %29, i64 %30
|
|
%31 = load i8, ptr %ptradd25, align 1
|
|
store i8 %31, ptr %d24, align 1
|
|
%32 = insertvalue %any undef, ptr %d24, 0
|
|
%33 = insertvalue %any %32, i64 ptrtoint (ptr @"$ct.char" to i64), 1
|
|
store %any %33, ptr %varargslots26, align 16
|
|
%34 = call i64 @std.io.printf(ptr %retparam27, ptr @.str.2, i64 3, ptr %varargslots26, i64 1)
|
|
%35 = load i64, ptr %.anon20, align 8
|
|
%addnuw30 = add nuw i64 %35, 1
|
|
store i64 %addnuw30, ptr %.anon20, align 8
|
|
br label %loop.cond21
|
|
|
|
loop.exit31: ; preds = %loop.cond21
|
|
%36 = call ptr @std.io.stdout()
|
|
%37 = call i64 @std.io.File.write(ptr %retparam35, ptr %36, ptr null, i64 0)
|
|
%not_err36 = icmp eq i64 %37, 0
|
|
%38 = call i1 @llvm.expect.i1(i1 %not_err36, i1 true)
|
|
br i1 %38, label %after_check38, label %assign_optional37
|
|
|
|
assign_optional37: ; preds = %loop.exit31
|
|
store i64 %37, ptr %error_var33, align 8
|
|
br label %guard_block39
|
|
|
|
after_check38: ; preds = %loop.exit31
|
|
br label %noerr_block40
|
|
|
|
guard_block39: ; preds = %assign_optional37
|
|
br label %voiderr54
|
|
|
|
noerr_block40: ; preds = %after_check38
|
|
%39 = load i64, ptr %retparam35, align 8
|
|
store i64 %39, ptr %len32, align 8
|
|
%40 = call i64 @std.io.File.write_byte(ptr %36, i8 zeroext 10)
|
|
%not_err42 = icmp eq i64 %40, 0
|
|
%41 = call i1 @llvm.expect.i1(i1 %not_err42, i1 true)
|
|
br i1 %41, label %after_check44, label %assign_optional43
|
|
|
|
assign_optional43: ; preds = %noerr_block40
|
|
store i64 %40, ptr %error_var41, align 8
|
|
br label %guard_block45
|
|
|
|
after_check44: ; preds = %noerr_block40
|
|
br label %noerr_block46
|
|
|
|
guard_block45: ; preds = %assign_optional43
|
|
br label %voiderr54
|
|
|
|
noerr_block46: ; preds = %after_check44
|
|
%42 = call i64 @std.io.File.flush(ptr %36)
|
|
%not_err48 = icmp eq i64 %42, 0
|
|
%43 = call i1 @llvm.expect.i1(i1 %not_err48, i1 true)
|
|
br i1 %43, label %after_check50, label %assign_optional49
|
|
|
|
assign_optional49: ; preds = %noerr_block46
|
|
store i64 %42, ptr %error_var47, align 8
|
|
br label %guard_block51
|
|
|
|
after_check50: ; preds = %noerr_block46
|
|
br label %noerr_block52
|
|
|
|
guard_block51: ; preds = %assign_optional49
|
|
br label %voiderr54
|
|
|
|
noerr_block52: ; preds = %after_check50
|
|
%44 = load i64, ptr %len32, align 8
|
|
%add53 = add i64 %44, 1
|
|
br label %voiderr54
|
|
|
|
voiderr54: ; preds = %noerr_block52, %guard_block51, %guard_block45, %guard_block39
|
|
%45 = load i32, ptr %abc, align 4
|
|
%46 = call i32 @llvm.bswap.i32(i32 %45)
|
|
%47 = and i32 65535, %46
|
|
%trunc = trunc i32 %47 to i16
|
|
store i16 %trunc, ptr %taddr56, align 2
|
|
%48 = insertvalue %any undef, ptr %taddr56, 0
|
|
%49 = insertvalue %any %48, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
|
|
store %any %49, ptr %varargslots55, align 16
|
|
%50 = call i64 @std.io.printfn(ptr %retparam57, ptr @.str.3, i64 10, ptr %varargslots55, i64 1)
|
|
%51 = load i32, ptr %abc, align 4
|
|
%52 = call i32 @llvm.bswap.i32(i32 %51)
|
|
%53 = and i32 %52, -65536
|
|
%54 = or i32 %53, 4660
|
|
%55 = call i32 @llvm.bswap.i32(i32 %54)
|
|
store i32 %55, ptr %abc, align 4
|
|
%56 = load i32, ptr %abc, align 4
|
|
%57 = call i32 @llvm.bswap.i32(i32 %56)
|
|
%58 = and i32 %57, 65535
|
|
%59 = or i32 %58, 1450704896
|
|
%60 = call i32 @llvm.bswap.i32(i32 %59)
|
|
store i32 %60, ptr %abc, align 4
|
|
%61 = load i32, ptr %abc, align 4
|
|
%62 = call i32 @llvm.bswap.i32(i32 %61)
|
|
%63 = and i32 65535, %62
|
|
%trunc61 = trunc i32 %63 to i16
|
|
store i16 %trunc61, ptr %taddr62, align 2
|
|
%64 = insertvalue %any undef, ptr %taddr62, 0
|
|
%65 = insertvalue %any %64, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1
|
|
store %any %65, ptr %varargslots60, align 16
|
|
%66 = call i64 @std.io.printfn(ptr %retparam63, ptr @.str.4, i64 12, ptr %varargslots60, i64 1)
|
|
%67 = load ptr, ptr %z, align 8
|
|
store ptr %67, ptr %.anon66, align 8
|
|
store i64 0, ptr %.anon67, align 8
|
|
br label %loop.cond68
|
|
|
|
loop.cond68: ; preds = %loop.body70, %voiderr54
|
|
%68 = load i64, ptr %.anon67, align 8
|
|
%gt69 = icmp ugt i64 4, %68
|
|
br i1 %gt69, label %loop.body70, label %loop.exit78
|
|
|
|
loop.body70: ; preds = %loop.cond68
|
|
%69 = load ptr, ptr %.anon66, align 8
|
|
%70 = load i64, ptr %.anon67, align 8
|
|
%ptradd72 = getelementptr inbounds i8, ptr %69, i64 %70
|
|
%71 = load i8, ptr %ptradd72, align 1
|
|
store i8 %71, ptr %d71, align 1
|
|
%72 = insertvalue %any undef, ptr %d71, 0
|
|
%73 = insertvalue %any %72, i64 ptrtoint (ptr @"$ct.char" to i64), 1
|
|
store %any %73, ptr %varargslots73, align 16
|
|
%74 = call i64 @std.io.printf(ptr %retparam74, ptr @.str.5, i64 3, ptr %varargslots73, i64 1)
|
|
%75 = load i64, ptr %.anon67, align 8
|
|
%addnuw77 = add nuw i64 %75, 1
|
|
store i64 %addnuw77, ptr %.anon67, align 8
|
|
br label %loop.cond68
|
|
|
|
loop.exit78: ; preds = %loop.cond68
|
|
%76 = call ptr @std.io.stdout()
|
|
%77 = call i64 @std.io.File.write(ptr %retparam82, ptr %76, ptr null, i64 0)
|
|
%not_err83 = icmp eq i64 %77, 0
|
|
%78 = call i1 @llvm.expect.i1(i1 %not_err83, i1 true)
|
|
br i1 %78, label %after_check85, label %assign_optional84
|
|
|
|
assign_optional84: ; preds = %loop.exit78
|
|
store i64 %77, ptr %error_var80, align 8
|
|
br label %guard_block86
|
|
|
|
after_check85: ; preds = %loop.exit78
|
|
br label %noerr_block87
|
|
|
|
guard_block86: ; preds = %assign_optional84
|
|
br label %voiderr101
|
|
|
|
noerr_block87: ; preds = %after_check85
|
|
%79 = load i64, ptr %retparam82, align 8
|
|
store i64 %79, ptr %len79, align 8
|
|
%80 = call i64 @std.io.File.write_byte(ptr %76, i8 zeroext 10)
|
|
%not_err89 = icmp eq i64 %80, 0
|
|
%81 = call i1 @llvm.expect.i1(i1 %not_err89, i1 true)
|
|
br i1 %81, label %after_check91, label %assign_optional90
|
|
|
|
assign_optional90: ; preds = %noerr_block87
|
|
store i64 %80, ptr %error_var88, align 8
|
|
br label %guard_block92
|
|
|
|
after_check91: ; preds = %noerr_block87
|
|
br label %noerr_block93
|
|
|
|
guard_block92: ; preds = %assign_optional90
|
|
br label %voiderr101
|
|
|
|
noerr_block93: ; preds = %after_check91
|
|
%82 = call i64 @std.io.File.flush(ptr %76)
|
|
%not_err95 = icmp eq i64 %82, 0
|
|
%83 = call i1 @llvm.expect.i1(i1 %not_err95, i1 true)
|
|
br i1 %83, label %after_check97, label %assign_optional96
|
|
|
|
assign_optional96: ; preds = %noerr_block93
|
|
store i64 %82, ptr %error_var94, align 8
|
|
br label %guard_block98
|
|
|
|
after_check97: ; preds = %noerr_block93
|
|
br label %noerr_block99
|
|
|
|
guard_block98: ; preds = %assign_optional96
|
|
br label %voiderr101
|
|
|
|
noerr_block99: ; preds = %after_check97
|
|
%84 = load i64, ptr %len79, align 8
|
|
%add100 = add i64 %84, 1
|
|
br label %voiderr101
|
|
|
|
voiderr101: ; preds = %noerr_block99, %guard_block98, %guard_block92, %guard_block86
|
|
store i32 0, ptr %y, align 4
|
|
%85 = load i32, ptr %y, align 4
|
|
store i32 123, ptr %y, align 4
|
|
%86 = insertvalue %any undef, ptr %y, 0
|
|
%87 = insertvalue %any %86, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
store %any %87, ptr %varargslots102, align 16
|
|
%88 = load i32, ptr %y, align 4
|
|
store i32 %88, ptr %taddr103, align 4
|
|
%89 = insertvalue %any undef, ptr %taddr103, 0
|
|
%90 = insertvalue %any %89, i64 ptrtoint (ptr @"$ct.int" to i64), 1
|
|
%ptradd104 = getelementptr inbounds i8, ptr %varargslots102, i64 16
|
|
store %any %90, ptr %ptradd104, align 16
|
|
%91 = call i64 @std.io.printf(ptr %retparam105, ptr @.str.6, i64 18, ptr %varargslots102, i64 2)
|
|
ret void
|
|
}
|