shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 12:01:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change printfln to printfn. Make LLVM 15 tests default.

Browse Source
This commit is contained in:
Christoffer Lerno
2023-01-11 17:27:54 +01:00
committed by Christoffer Lerno
parent 3298ff2e15
commit dc16f65c8e
971 changed files with 30632 additions and 30623 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
.github/workflows/main.yml vendored
View File

@@ -54,7 +54,7 @@ jobs:
- name: run compiler tests
run: |
cd test
python3.exe src/tester.py ..\build\${{ matrix.build_type }}\c3c.exe test_suite2/
python3.exe src/tester.py ..\build\${{ matrix.build_type }}\c3c.exe test_suite/
- name: Compile run unit tests
run: |
@@ -119,7 +119,7 @@ jobs:
- name: run compiler tests
run: |
cd test
python3 src/tester.py ../build/c3c.exe test_suite2/
python3 src/tester.py ../build/c3c.exe test_suite/
build-msys2-clang:
@@ -168,7 +168,7 @@ jobs:
- name: run compiler tests
run: |
cd test
python3 src/tester.py ../build/c3c.exe test_suite/
python3 src/tester.py ../build/c3c.exe test_suite14/
build-linux:
runs-on: ubuntu-latest
@@ -237,9 +237,9 @@ jobs:
run: |
cd test
if [[ "${{matrix.llvm_version}}" < 15 ]]; then
python3 src/tester.py ../build/c3c test_suite/
python3 src/tester.py ../build/c3c test_suite14/
else
python3 src/tester.py ../build/c3c test_suite2/
python3 src/tester.py ../build/c3c test_suite/
fi
- name: bundle_output
@@ -317,9 +317,9 @@ jobs:
run: |
cd test
if [[ "${{matrix.llvm_version}}" < 15 ]]; then
python3 src/tester.py ../build/c3c test_suite/
python3 src/tester.py ../build/c3c test_suite14/
else
python3 src/tester.py ../build/c3c test_suite2/
python3 src/tester.py ../build/c3c test_suite/
fi
- name: bundle_output

8
lib/std/io/io_printf.c3
View File

@@ -294,7 +294,9 @@ fn usz! printf(String format, args...) @maydiscard
return formatter.vprintf(format, args);
}
fn usz! printfln(String format, args...) @maydiscard
define printfln = printfn;
fn usz! printfn(String format, args...) @maydiscard
{
Formatter formatter;
formatter.init(&out_putchar_fn);
@@ -310,7 +312,7 @@ fn usz! VarString.printf(VarString* str, String format, args...) @maydiscard
return formatter.vprintf(format, args);
}
fn usz! VarString.printfln(VarString* str, String format, args...) @maydiscard
fn usz! VarString.printfn(VarString* str, String format, args...) @maydiscard
{
Formatter formatter;
formatter.init(&out_string_append_fn, str);
@@ -341,7 +343,7 @@ fn usz! File.printf(File file, String format, args...) @maydiscard
return formatter.vprintf(format, args)?;
}
fn usz! File.printfln(File file, String format, args...) @maydiscard
fn usz! File.printfn(File file, String format, args...) @maydiscard
{
Formatter formatter;
formatter.init(&out_putchar_fn, &file);

7
lib/std/math.c3
View File

@@ -412,6 +412,13 @@ macro int128 int128[<*>].xor(int128[<*>] x) = $$reduce_xor(x);
macro int128 int128[<*>].max(int128[<*>] x) = $$reduce_max(x);
macro int128 int128[<*>].min(int128[<*>] x) = $$reduce_min(x);
macro bool[<*>] bool[<*>].comp_lt(bool[<*>] x, bool[<*>] y) = $$veccomplt(x, y);
macro bool[<*>] bool[<*>].comp_le(bool[<*>] x, bool[<*>] y) = $$veccomple(x, y);
macro bool[<*>] bool[<*>].comp_eq(bool[<*>] x, bool[<*>] y) = $$veccompeq(x, y);
macro bool[<*>] bool[<*>].comp_gt(bool[<*>] x, bool[<*>] y) = $$veccompgt(x, y);
macro bool[<*>] bool[<*>].comp_ge(bool[<*>] x, bool[<*>] y) = $$veccompge(x, y);
macro bool[<*>] bool[<*>].comp_ne(bool[<*>] x, bool[<*>] y) = $$veccompne(x, y);
macro bool bool[<*>].sum(bool[<*>] x) = $$reduce_add(x);
macro bool bool[<*>].product(bool[<*>] x) = $$reduce_mul(x);
macro bool bool[<*>].and(bool[<*>] x) = $$reduce_and(x);

8
lib/std/runtime.c3
View File

@@ -51,8 +51,8 @@ private TestRunner* current_runner;
fn void test_panic(String message, String file, String function, uint line)
{
io::println("[error]");
io::printfln("\n Error: %s", message);
io::printfln(" - in %s %s:%s.\n", function, file, line);
io::printfn("\n Error: %s", message);
io::printfn(" - in %s %s:%s.\n", function, file, line);
libc::longjmp(&current_runner.buf, 1);
}
@@ -79,7 +79,7 @@ fn bool TestRunner.run(TestRunner* runner)
tests_passed++;
}
}
io::printfln("\n%d test(s) run.\n", tests);
io::printfn("\n%d test(s) run.\n", tests);
io::print("Test Result: ");
if (tests_passed < tests)
{
@@ -89,7 +89,7 @@ fn bool TestRunner.run(TestRunner* runner)
{
io::print("ok");
}
io::printfln(". %d passed, %d failed.", tests_passed, tests - tests_passed);
io::printfn(". %d passed, %d failed.", tests_passed, tests - tests_passed);
return tests == tests_passed;
}

2
resources/examples/brainfk.c3
View File

@@ -12,7 +12,7 @@ fault InterpretError
fn void! print_error(usz pos, String err)
{
io::printfln("Error at %s: %s", pos, err);
io::printfn("Error at %s: %s", pos, err);
return InterpretError.INTEPRET_FAILED!;
}

4
resources/examples/contextfree/dynscope.c3
View File

@@ -5,7 +5,7 @@ tlocal String context_user = "safe";
macro long reallyPerform(task)
{
io::printfln("%s: %s", context_user, task);
io::printfn("%s: %s", context_user, task);
return task.len;
}
@@ -28,5 +28,5 @@ fn void main()
long val1 = perform("something");
long val2 = @with_mode("faster", perform, "reliable");
long val3 = perform(String[] {"something"});
io::printfln("%d %d %d", val1, val2, val3);
io::printfn("%d %d %d", val1, val2, val3);
}

4
resources/examples/nbodies.c3
View File

@@ -155,6 +155,6 @@ fn void main(String[] args)
advance(bodies);
}
scale_bodies(bodies, RECIP_DT);
io::printfln("%.9f", start);
io::printfln("%.9f", energy(bodies));
io::printfn("%.9f", start);
io::printfn("%.9f", energy(bodies));
}

2
resources/examples/plus_minus.c3
View File

@@ -53,7 +53,7 @@ fn void main(String[] args)
return;
}
}
io::printfln("%d", val);
io::printfn("%d", val);
}
fn String! read_next(String* remaining)

2
resources/testfragments/allocators_testing.c3
View File

@@ -32,7 +32,7 @@ fn void testAllocator(Allocator* a, int val)
io::printf("Aligned with offset %p, align 16: %s offset align 128: %s\n", data, mem::ptr_is_aligned(data, 16), mem::ptr_is_aligned(data + 16, 128));
data = a.realloc_aligned(data, val + 1, 128, 0)!!;
io::printf("No offset %p, align 16: %s offset align 128: %s\n", data, mem::ptr_is_aligned(data, 16), mem::ptr_is_aligned(data + 16, 128));
io::printfln("Freeing %p", data);
io::printfn("Freeing %p", data);
a.free_aligned(data)!!;
}
fn void main()

2
src/version.h
View File

@@ -1 +1 @@
#define COMPILER_VERSION "0.4.10"
#define COMPILER_VERSION "0.4.11"

15
test/test_suite/abi/aarch64_args.c3t
View File

@@ -20,15 +20,10 @@ entry:
%l = alloca %Large, align 8
%indirectarg = alloca %Large, align 8
%indirectarg1 = alloca %Large, align 8
%0 = bitcast %Large* %l to i8*
call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 64, i1 false)
%1 = bitcast %Large* %indirectarg to i8*
%2 = bitcast %Large* %l to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %1, i8* align 8 %2, i32 64, i1 false)
call void @pass_large(%Large* align 8 %indirectarg)
%3 = bitcast %Large* %indirectarg1 to i8*
%4 = bitcast %Large* %l to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %3, i8* align 8 %4, i32 64, i1 false)
call void @pass_large(%Large* align 8 %indirectarg1)
call void @llvm.memset.p0.i64(ptr align 8 %l, i8 0, i64 64, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 8 %l, i32 64, i1 false)
call void @pass_large(ptr align 8 %indirectarg)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg1, ptr align 8 %l, i32 64, i1 false)
call void @pass_large(ptr align 8 %indirectarg1)
ret void
}

26
test/test_suite/abi/darwin64_avx.c3t
View File

@@ -111,13 +111,13 @@ fn void f61(SAtwo256 s) {
declare void @f38(<8 x float>)
declare void @f37(<8 x float>)
declare void @func40(%Two128* byval(%Two128) align 16)
define void @test_func41(%Two128* byval(%Two128) align 16 %0)
declare void @func40(ptr byval(%Two128) align 16)
define void @test_func41(ptr byval(%Two128) align 16 %0)
declare void @func42(%Sa* byval(%Sa) align 16)
define void @test_func43(%Sa* byval(%Sa) align 16 %0)
declare void @func42(ptr byval(%Sa) align 16)
define void @test_func43(ptr byval(%Sa) align 16 %0)
declare void @f46(double, double, double, double, double, double, double, double, <2 x float>* byval(<2 x float>) align 8, <2 x float>* byval(<2 x float>) align 8)
declare void @f46(double, double, double, double, double, double, double, double, ptr byval(<2 x float>) align 8, ptr byval(<2 x float>) align 8) #0
declare void @f47(i32, i32, i32, i32, i32, i32, i32)
declare void @test_test49_helper(double, ...)
@@ -127,15 +127,15 @@ entry:
ret void
call void (i32, ...) @test52_helper(i32 0, <8 x float> %0, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi)
call void (<8 x float>, ...) @test54_helper(<8 x float> %0, <8 x float> %1, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi)
call void (<8 x float>, ...) @test54_helper(<8 x float> %6, <8 x float> %7, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, %Complex* byval(%Complex) align 8 %literal1)
call void (<8 x float>, ...) @test54_helper(<8 x float> %6, <8 x float> %7, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, ptr byval(%Complex) align 8 %literal1)
declare void @f55(%St512* byval(%St512) align 64) #0
declare void @f56(<16 x float>* byval(<16 x float>) align 64) #0
declare void @f55(ptr byval(%St512) align 64)
declare void @f56(ptr byval(<16 x float>) align 64)
declare void @f58(%Two256* byval(%Two256) align 32) #0
define void @test_f59(%Two256* byval(%Two256) align 32 %0) #0 {
declare void @f58(ptr byval(%Two256) align 32)
define void @test_f59(ptr byval(%Two256) align 32 %0)
declare void @f60(%SAtwo256* byval(%SAtwo256) align 32) #0
define void @test_f61(%SAtwo256* byval(%SAtwo256) align 32 %0) #0 {
declare void @f60(ptr byval(%SAtwo256) align 32)
define void @test_f61(ptr byval(%SAtwo256) align 32 %0) #0 {

11
test/test_suite/abi/darwin64_avx512.c3t
View File

@@ -61,15 +61,14 @@ fn void f64() {
declare void @f55(<16 x float>) #0
declare void @f56(<16 x float>) #0
declare void @f58(%Two256* byval(%Two256) align 32) #0
define void @test_f59(%Two256* byval(%Two256) align 32 %0) #0 {
declare void @f60(%SAtwo256* byval(%SAtwo256) align 32) #0
define void @test_f61(%SAtwo256* byval(%SAtwo256) align 32 %0) #0 {
declare void @f58(ptr byval(%Two256) align 32) #0
define void @test_f59(ptr byval(%Two256) align 32 %0) #0 {
declare void @f60(ptr byval(%SAtwo256) align 32) #0
define void @test_f61(ptr byval(%SAtwo256) align 32 %0) #0 {
define void @test_f62() #0 {
call void (i32, ...) @test_f62_helper(i32 0, <16 x float> %0, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi)
define void @test_f64() #0 {
call void (<16 x float>, ...) @test_f64_helper(<16 x float> %0, <16 x float> %1, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double %lo, double %hi)
call void (<16 x float>, ...) @test_f64_helper(<16 x float> %6, <16 x float> %7, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, %Complex* byval(%Complex) align 8 %literal1)
call void (<16 x float>, ...) @test_f64_helper(<16 x float> %6, <16 x float> %7, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, ptr byval(%Complex) align 8 %literal1)

6
test/test_suite/abi/darwin64_sret.c3t
View File

@@ -12,10 +12,8 @@ fn SimdDouble4x4 ident(SimdDouble4x4 x) {
/* #expect: foo.ll
define void @foo_ident(%SimdDouble4x4* noalias sret(%SimdDouble4x4) align 32 %0, %SimdDouble4x4* byval(%SimdDouble4x4) align 32 %1) #0 {
define void @foo_ident(ptr noalias sret(%SimdDouble4x4) align 32 %0, ptr byval(%SimdDouble4x4) align 32 %1) #0 {
entry:
%2 = bitcast %SimdDouble4x4* %0 to i8*
%3 = bitcast %SimdDouble4x4* %1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 32 %2, i8* align 32 %3, i32 128, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 32 %0, ptr align 32 %1, i32 128, i1 false)
ret void
}

12
test/test_suite/abi/darwin64_sse.c3t
View File

@@ -46,11 +46,11 @@ fn void func43(Sa s) {
/* #expect: test.ll
declare void @f38(%St256* byval(%St256) align 32)
declare void @f37(<8 x float>* byval(<8 x float>) align 32)
declare void @f38(ptr byval(%St256) align 32)
declare void @f37(ptr byval(<8 x float>) align 32)
declare void @func40(%Two128* byval(%Two128) align 16)
define void @test_func41(%Two128* byval(%Two128) align 16 %0)
declare void @func40(ptr byval(%Two128) align 16)
define void @test_func41(ptr byval(%Two128) align 16 %0)
declare void @func42(%Sa* byval(%Sa) align 16)
define void @test_func43(%Sa* byval(%Sa) align 16 %0)
declare void @func42(ptr byval(%Sa) align 16)
define void @test_func43(ptr byval(%Sa) align 16 %0)

5
test/test_suite/abi/darwin_arg.c3t
View File

@@ -20,7 +20,6 @@ fn void f9122143()
declare void @d(i64, double) #0
%lo = load i64, i64* getelementptr inbounds ({ i64, double }, { i64, double }* bitcast (%Str* @test_ss to { i64, double }*), i32 0, i32 0), align 16
%hi = load double, double* getelementptr inbounds ({ i64, double }, { i64, double }* bitcast (%Str* @test_ss to { i64, double }*), i32 0, i32 1), align 8
%lo = load i64, ptr @test_ss, align 16
%hi = load double, ptr getelementptr inbounds ({ i64, double }, ptr @test_ss, i32 0, i32 1), align 8
call void @d(i64 %lo, double %hi)
ret void

2
test/test_suite/abi/darwinx64_1.c3t
View File

@@ -42,7 +42,7 @@ define signext i16 @test_f1()
define i32 @test_f2()
define float @test_f3()
define double @test_f4()
define void @test_f6(i8 zeroext %0, i16 signext %1, i32 %2, i64 %3, i8* %4)
define void @test_f6(i8 zeroext %0, i16 signext %1, i32 %2, i64 %3, ptr %4)
define void @test_f7(i32 %0)
define i64 @test_f8_1()
define void @test_f8_2(i64 %0) #0 {

12
test/test_suite/abi/darwinx64_2.c3t
View File

@@ -149,15 +149,15 @@ fn V2i32 f36(V2i32 arg) { return arg; }
define i32 @test_f12_0()
define void @test_f12_1(i32 %0)
define void @test_f13(%St13_0* noalias sret(%St13_0) align 8 %0, i32 %1, i32 %2, i32 %3, i32 %4, %St13_1* byval(%St13_1) align 8 %5, i32 %6) #0 {
define void @test_f13(ptr noalias sret(%St13_0) align 8 %0, i32 %1, i32 %2, i32 %3, i32 %4, ptr byval(%St13_1) align 8 %5, i32 %6) #0 {
define void @test_f14(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i8 signext %6) #0 {
define void @test_f15(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i8* %6)
define void @test_f15(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, ptr %6)
define void @test_f16(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8)
define void @test_fl18(i32 %0, i32 %1)
define void @test_f20(%St20* byval(%St20) align 32 %0)
define i8* @test_f21(i64 %0, i8* %1)
define void @test_f20(ptr byval(%St20) align 32 %0)
define ptr @test_f21(i64 %0, ptr %1)
define void @test_f22(i64 %0, i64 %1, i64 %2, i64 %3)
entry:
@@ -165,7 +165,7 @@ entry:
%y = alloca %St22s, align 16
define void @test_f23(i32 %0, i64 %1, i32 %2)
define { i64, i32 } @test_f24(%St23S* %0, %St24s* %1)
define { i64, i32 } @test_f24(ptr %0, ptr %1)
define <4 x float> @test_f25(<4 x float> %0) #0 {
entry:
@@ -173,7 +173,7 @@ entry:
ret <4 x float> %fadd
}
define { i32*, float* } @test_f26(%Foo26* %0)
define { ptr, ptr } @test_f26(ptr %0)
define <4 x float> @test_f27(<4 x float> %0)
define <8 x float> @test_f27a(<8 x float> %0)
define <8 x float> @test_f27b(<8 x float> %0)

23
test/test_suite/abi/literal_load.c3t
View File

@@ -15,17 +15,18 @@ fn Test creator()
return Test{};
}
// #expect: literal_load.ll
/* #expect: literal_load.ll
define i32 @literal_load_creator() #0 {
entry:
%literal = alloca %Test, align 4
%literal1 = alloca %Test, align 4
%0 = bitcast %Test* %literal to i32*
store i32 0, i32* %0, align 4
%1 = getelementptr inbounds %Test, %Test* %literal, i32 0, i32 0
%2 = load i32, i32* %1, align 4
call void @blorg(i32 %2)
%3 = bitcast %Test* %literal1 to i32*
store i32 0, i32* %3, align 4
%4 = getelementptr inbounds %Test, %Test* %literal1, i32 0, i32 0
%5 = load i32, i32* %4, align 4
ret i32 %5
store i32 0, ptr %literal, align 4
%0 = getelementptr inbounds %Test, ptr %literal, i32 0, i32 0
%1 = load i32, ptr %0, align 4
call void @blorg(i32 %1)
store i32 0, ptr %literal1, align 4
%2 = getelementptr inbounds %Test, ptr %literal1, i32 0, i32 0
%3 = load i32, ptr %2, align 4
ret i32 %3
}

22
test/test_suite/abi/literal_load_aarch64.c3t
View File

@@ -16,7 +16,7 @@ fn Test creator()
return Test{};
}
// #expect: literal_load.ll
/* #expect: literal_load.ll
declare void @blorg(i64) #0
@@ -24,15 +24,13 @@ define i32 @literal_load_creator() #0 {
entry:
%literal = alloca %Test, align 4
%literal1 = alloca %Test, align 4
%0 = bitcast %Test* %literal to i32*
store i32 0, i32* %0, align 4
%1 = getelementptr inbounds %Test, %Test* %literal, i32 0, i32 0
%2 = load i32, i32* %1, align 4
%3 = zext i32 %2 to i64
call void @blorg(i64 %3)
%4 = bitcast %Test* %literal1 to i32*
store i32 0, i32* %4, align 4
%5 = getelementptr inbounds %Test, %Test* %literal1, i32 0, i32 0
%6 = load i32, i32* %5, align 4
ret i32 %6
store i32 0, ptr %literal, align 4
%0 = getelementptr inbounds %Test, ptr %literal, i32 0, i32 0
%1 = load i32, ptr %0, align 4
%2 = zext i32 %1 to i64
call void @blorg(i64 %2)
store i32 0, ptr %literal1, align 4
%3 = getelementptr inbounds %Test, ptr %literal1, i32 0, i32 0
%4 = load i32, ptr %3, align 4
ret i32 %4
}

23
test/test_suite/abi/literal_load_mingw.c3t
View File

@@ -16,17 +16,18 @@ fn Test creator()
return Test{};
}
// #expect: literal_load.ll
/* #expect: literal_load.ll
define i32 @literal_load_creator() #0 {
entry:
%literal = alloca %Test, align 4
%literal1 = alloca %Test, align 4
%0 = bitcast %Test* %literal to i32*
store i32 0, i32* %0, align 4
%1 = getelementptr inbounds %Test, %Test* %literal, i32 0, i32 0
%2 = load i32, i32* %1, align 4
call void @blorg(i32 %2)
%3 = bitcast %Test* %literal1 to i32*
store i32 0, i32* %3, align 4
%4 = getelementptr inbounds %Test, %Test* %literal1, i32 0, i32 0
%5 = load i32, i32* %4, align 4
ret i32 %5
store i32 0, ptr %literal, align 4
%0 = getelementptr inbounds %Test, ptr %literal, i32 0, i32 0
%1 = load i32, ptr %0, align 4
call void @blorg(i32 %1)
store i32 0, ptr %literal1, align 4
%2 = getelementptr inbounds %Test, ptr %literal1, i32 0, i32 0
%3 = load i32, ptr %2, align 4
ret i32 %3
}

15
test/test_suite/abi/pass_large_aarch.c3t
View File

@@ -24,14 +24,9 @@ entry:
%l = alloca %Large, align 8
%indirectarg = alloca %Large, align 8
%indirectarg1 = alloca %Large, align 8
%0 = bitcast %Large* %l to i8*
call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 64, i1 false)
%1 = bitcast %Large* %indirectarg to i8*
%2 = bitcast %Large* %l to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %1, i8* align 8 %2, i32 64, i1 false)
call void @pass_large(%Large* align 8 %indirectarg)
%3 = bitcast %Large* %indirectarg1 to i8*
%4 = bitcast %Large* %l to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %3, i8* align 8 %4, i32 64, i1 false)
call void @pass_large(%Large* align 8 %indirectarg1)
call void @llvm.memset.p0.i64(ptr align 8 %l, i8 0, i64 64, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 8 %l, i32 64, i1 false)
call void @pass_large(ptr align 8 %indirectarg)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg1, ptr align 8 %l, i32 64, i1 false)
call void @pass_large(ptr align 8 %indirectarg1)
ret void

32
test/test_suite/abi/regcall_expand.c3t
View File

@@ -25,14 +25,16 @@ $"ct$test_Foo" = comdat any
@"ct$test_Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 1, [0 x i64] zeroinitializer }, comdat, align 8
declare void @printf(ptr, ...) #0
define x86_regcallcc void @test_test(float %0, float %1) #0 {
entry:
%x = alloca %Foo, align 4
%2 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0
%3 = getelementptr inbounds [2 x float], [2 x float]* %2, i64 0, i64 0
store float %0, float* %3, align 4
%4 = getelementptr inbounds [2 x float], [2 x float]* %2, i64 0, i64 1
store float %1, float* %4, align 4
%2 = getelementptr inbounds %Foo, ptr %x, i32 0, i32 0
%3 = getelementptr inbounds [2 x float], ptr %2, i64 0, i64 0
store float %0, ptr %3, align 4
%4 = getelementptr inbounds [2 x float], ptr %2, i64 0, i64 1
store float %1, ptr %4, align 4
ret void
}
@@ -40,16 +42,16 @@ entry:
define i32 @main() #0 {
entry:
%literal = alloca %Foo, align 4
%0 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
%1 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 0
store float 0.000000e+00, float* %1, align 4
%2 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 1
store float 0.000000e+00, float* %2, align 4
%3 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
%4 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 0
%loadexpanded = load float, float* %4, align 4
%5 = getelementptr inbounds [2 x float], [2 x float]* %3, i64 0, i64 1
%loadexpanded1 = load float, float* %5, align 4
%0 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
%1 = getelementptr inbounds [2 x float], ptr %0, i64 0, i64 0
store float 0.000000e+00, ptr %1, align 4
%2 = getelementptr inbounds [2 x float], ptr %0, i64 0, i64 1
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
%4 = getelementptr inbounds [2 x float], ptr %3, i64 0, i64 0
%loadexpanded = load float, ptr %4, align 4
%5 = getelementptr inbounds [2 x float], ptr %3, i64 0, i64 1
%loadexpanded1 = load float, ptr %5, align 4
call x86_regcallcc void @test_test(float %loadexpanded, float %loadexpanded1)
ret i32 0
}

25
test/test_suite/abi/riscv64-lp64-abi.c3t
View File

@@ -19,30 +19,29 @@ fn Large f_scalar_stack_2(double a, int128 b, float128 c, V32i8 d,
/* #expect: test.ll
define signext i32 @test_f_scalar_stack_1(i32 signext %0, i128 %1, float %2, fp128 %3, <32 x i8>* align 32 %4, i8 zeroext %5, i8 %6, i8 %7) #0 {
define signext i32 @test_f_scalar_stack_1(i32 signext %0, i128 %1, float %2, fp128 %3, ptr align 32 %4, i8 zeroext %5, i8 %6, i8 %7) #0 {
entry:
%uisiext = zext i8 %6 to i32
%uisiext1 = zext i8 %7 to i32
%add = add i32 %uisiext, %uisiext1
ret i32 %add
}
define void @test_f_scalar_stack_2(%Large* noalias sret(%Large) align 8 %0, double %1, i128 %2, fp128 %3, <32 x i8>* align 32 %4, i8 zeroext %5, i8 %6, i8 %7) #0 {
define void @test_f_scalar_stack_2(ptr noalias sret(%Large) align 8 %0, double %1, i128 %2, fp128 %3, ptr align 32 %4, i8 zeroext %5, i8 %6, i8 %7) #0 {
entry:
%literal = alloca %Large, align 8
%8 = getelementptr inbounds %Large, %Large* %literal, i32 0, i32 0
%8 = getelementptr inbounds %Large, ptr %literal, i32 0, i32 0
%fpsi = fptosi double %1 to i64
store i64 %fpsi, i64* %8, align 8
%9 = getelementptr inbounds %Large, %Large* %literal, i32 0, i32 1
store i64 %fpsi, ptr %8, align 8
%9 = getelementptr inbounds %Large, ptr %literal, i32 0, i32 1
%uisiext = zext i8 %5 to i64
store i64 %uisiext, i64* %9, align 8
%10 = getelementptr inbounds %Large, %Large* %literal, i32 0, i32 2
store i64 %uisiext, ptr %9, align 8
%10 = getelementptr inbounds %Large, ptr %literal, i32 0, i32 2
%sisiext = sext i8 %6 to i64
store i64 %sisiext, i64* %10, align 8
%11 = getelementptr inbounds %Large, %Large* %literal, i32 0, i32 3
store i64 %sisiext, ptr %10, align 8
%11 = getelementptr inbounds %Large, ptr %literal, i32 0, i32 3
%uisiext1 = zext i8 %7 to i64
store i64 %uisiext1, i64* %11, align 8
%12 = bitcast %Large* %0 to i8*
%13 = bitcast %Large* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %12, i8* align 8 %13, i32 32, i1 false)
store i64 %uisiext1, ptr %11, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal, i32 32, i1 false)
ret void
}

77
test/test_suite/abi/small_struct_x64.c3t
View File

@@ -20,6 +20,12 @@ fn Foo getFoo(Foo f)
/* #expect: test.ll
%.introspect = type { i8, i64, i64, i64, [0 x i64] }
%Foo = type { i8, i8, i8 }
@"ct$test_Foo" = linkonce constant %.introspect { i8 10, i64 3, i64 0, i64 3, [0 x i64] zeroinitializer }, align 8
; Function Attrs: nounwind
define i32 @test_testing() #0 {
entry:
%y = alloca %Foo, align 1
@@ -27,30 +33,24 @@ entry:
%tempcoerce = alloca i24, align 4
%result = alloca %Foo, align 1
%tempcoerce1 = alloca i24, align 4
%0 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
store i8 4, i8* %0, align 1
%1 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
store i8 5, i8* %1, align 1
%2 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 2
store i8 6, i8* %2, align 1
%3 = bitcast i24* %tempcoerce to i8*
%4 = bitcast %Foo* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %3, i8* align 1 %4, i32 3, i1 false)
%5 = load i24, i24* %tempcoerce, align 4
%6 = call i24 @test_getFoo(i24 %5)
store i24 %6, i24* %tempcoerce1, align 4
%7 = bitcast %Foo* %result to i8*
%8 = bitcast i24* %tempcoerce1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %7, i8* align 4 %8, i32 3, i1 false)
%9 = bitcast %Foo* %y to i8*
%10 = bitcast %Foo* %result to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %9, i8* align 1 %10, i32 3, i1 false)
%11 = getelementptr inbounds %Foo, %Foo* %y, i32 0, i32 0
%12 = load i8, i8* %11, align 1
%uisiext = zext i8 %12 to i32
%13 = getelementptr inbounds %Foo, %Foo* %y, i32 0, i32 2
%14 = load i8, i8* %13, align 1
%uisiext2 = zext i8 %14 to i32
%0 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
store i8 4, ptr %0, align 1
%1 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
store i8 5, ptr %1, align 1
%2 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 2
store i8 6, ptr %2, align 1
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %tempcoerce, ptr align 1 %literal, i32 3, i1 false)
%3 = load i24, ptr %tempcoerce, align 4
%4 = call i24 @test_getFoo(i24 %3)
store i24 %4, ptr %tempcoerce1, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %result, ptr align 4 %tempcoerce1, i32 3, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %y, ptr align 1 %result, i32 3, i1 false)
%5 = getelementptr inbounds %Foo, ptr %y, i32 0, i32 0
%6 = load i8, ptr %5, align 1
%uisiext = zext i8 %6 to i32
%7 = getelementptr inbounds %Foo, ptr %y, i32 0, i32 2
%8 = load i8, ptr %7, align 1
%uisiext2 = zext i8 %8 to i32
%add = add i32 %uisiext, %uisiext2
ret i32 %add
}
@@ -62,19 +62,18 @@ entry:
%tempcoerce = alloca i24, align 4
%literal = alloca %Foo, align 1
%tempcoerce1 = alloca i24, align 4
store i24 %0, i24* %tempcoerce, align 4
%1 = bitcast %Foo* %f to i8*
%2 = bitcast i24* %tempcoerce to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %1, i8* align 4 %2, i32 3, i1 false)
%3 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
store i8 1, i8* %3, align 1
%4 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
store i8 2, i8* %4, align 1
%5 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 2
store i8 3, i8* %5, align 1
%6 = bitcast i24* %tempcoerce1 to i8*
%7 = bitcast %Foo* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %6, i8* align 1 %7, i32 3, i1 false)
%8 = load i24, i24* %tempcoerce1, align 4
ret i24 %8
store i24 %0, ptr %tempcoerce, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %f, ptr align 4 %tempcoerce, i32 3, i1 false)
%1 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
store i8 1, ptr %1, align 1
%2 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
store i8 2, ptr %2, align 1
%3 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 2
store i8 3, ptr %3, align 1
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %tempcoerce1, ptr align 1 %literal, i32 3, i1 false)
%4 = load i24, ptr %tempcoerce1, align 4
ret i24 %4
}
declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg) #1

4
test/test_suite/abi/sysv_abi_avx.c3t
View File

@@ -31,8 +31,8 @@ fn void use_vectors()
/* #expect: foo.ll
declare void @take_stringref(i8*, i64) #0
call void @take_stringref(i8* %lo, i64 %hi)
declare void @take_stringref(ptr, i64) #0
call void @take_stringref(ptr %lo, i64 %hi)
define void @foo_use_vectors() #0 {
entry:

9
test/test_suite/abi/sysv_abi_noavx.c3t
View File

@@ -31,12 +31,11 @@ fn void use_vectors()
/* #expect: foo.ll
declare void @take_stringref(i8*, i64) #0
call void @take_stringref(i8* %lo, i64 %hi)
declare void @take_stringref(ptr, i64) #0
call void @take_stringref(ptr %lo, i64 %hi)
define void @foo_use_vectors() #0 {
entry:
%0 = call <8 x float> @get_m256()
call void @take_m256(<8 x float>* byval(<8 x float>) align 32 %v1)
call void @take_m256(ptr byval(<8 x float>) align 32 %v1)
%1 = call <16 x float> @get_m512()
call void @take_m512(<16 x float>* byval(<16 x float>) align 64 %v2)
call void @take_m512(ptr byval(<16 x float>) align 64 %v2)

38
test/test_suite/abi/sysv_direct_coerce.c3t
View File

@@ -21,27 +21,23 @@ entry:
%r = alloca %Rectangle, align 4
%literal = alloca %Rectangle, align 4
%coerce = alloca %Rectangle, align 8
%pair = bitcast %Rectangle* %r to { <2 x float>, <2 x float> }*
%2 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %pair, i32 0, i32 0
store <2 x float> %0, <2 x float>* %2, align 4
%3 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %pair, i32 0, i32 1
store <2 x float> %1, <2 x float>* %3, align 4
%4 = getelementptr inbounds %Rectangle, %Rectangle* %literal, i32 0, i32 0
store float 1.000000e+00, float* %4, align 4
%5 = getelementptr inbounds %Rectangle, %Rectangle* %literal, i32 0, i32 1
store float 2.000000e+00, float* %5, align 4
%6 = getelementptr inbounds %Rectangle, %Rectangle* %literal, i32 0, i32 2
store float 3.000000e+00, float* %6, align 4
%7 = getelementptr inbounds %Rectangle, %Rectangle* %literal, i32 0, i32 3
store float 4.000000e+00, float* %7, align 4
%8 = bitcast %Rectangle* %coerce to { <2 x float>, <2 x float> }*
%9 = bitcast { <2 x float>, <2 x float> }* %8 to i8*
%10 = bitcast %Rectangle* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %9, i8* align 4 %10, i32 16, i1 false)
%11 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %8, i32 0, i32 0
%lo = load <2 x float>, <2 x float>* %11, align 8
%12 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %8, i32 0, i32 1
%hi = load <2 x float>, <2 x float>* %12, align 8
%2 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %r, i32 0, i32 0
store <2 x float> %0, ptr %2, align 4
%3 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %r, i32 0, i32 1
store <2 x float> %1, ptr %3, align 4
%4 = getelementptr inbounds %Rectangle, ptr %literal, i32 0, i32 0
store float 1.000000e+00, ptr %4, align 4
%5 = getelementptr inbounds %Rectangle, ptr %literal, i32 0, i32 1
store float 2.000000e+00, ptr %5, align 4
%6 = getelementptr inbounds %Rectangle, ptr %literal, i32 0, i32 2
store float 3.000000e+00, ptr %6, align 4
%7 = getelementptr inbounds %Rectangle, ptr %literal, i32 0, i32 3
store float 4.000000e+00, ptr %7, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %coerce, ptr align 4 %literal, i32 16, i1 false)
%8 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %coerce, i32 0, i32 0
%lo = load <2 x float>, ptr %8, align 8
%9 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %coerce, i32 0, i32 1
%hi = load <2 x float>, ptr %9, align 8
call void @foo_test(<2 x float> %lo, <2 x float> %hi)
ret void
}

15
test/test_suite/abi/test_sret.c3t
View File

@@ -16,16 +16,17 @@ fn void bar() {
Abc dummy2 = foo2();
}
// Cleanup for this result, since it's creating an unnecessary sret.
/* #expect: test_sret.ll
// #expect: test_sret.ll
declare void @foo1(ptr noalias sret(%Abc) align 8) #0
declare void @foo1(%Abc* noalias sret(%Abc) align 8)
declare void @foo2(%Abc* noalias sret(%Abc) align 8)
declare void @foo2(ptr noalias sret(%Abc) align 8) #0
define void @test_sret_bar() #0 {
entry:
%dummy1 = alloca %Abc, align 8
%dummy2 = alloca %Abc, align 8
call void @foo1(%Abc* sret(%Abc) align 8 %dummy1)
call void @foo2(%Abc* sret(%Abc) align 8 %dummy2)
call void @foo1(ptr sret(%Abc) align 8 %dummy1)
call void @foo2(ptr sret(%Abc) align 8 %dummy2)
ret void
}

19
test/test_suite/abi/union_x64.c3t
View File

@@ -23,16 +23,15 @@ declare void @hello2(i64, i64) #0
define void @unionx64_hello(i64 %0, i64 %1) #0 {
entry:
%f = alloca %Foo, align 8
%pair = bitcast %Foo* %f to { i64, i64 }*
%2 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %pair, i32 0, i32 0
store i64 %0, i64* %2, align 8
%3 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %pair, i32 0, i32 1
store i64 %1, i64* %3, align 8
%4 = bitcast %Foo* %f to { i64, i64 }*
%5 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %4, i32 0, i32 0
%lo = load i64, i64* %5, align 8
%6 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %4, i32 0, i32 1
%hi = load i64, i64* %6, align 8
%2 = getelementptr inbounds { i64, i64 }, ptr %f, i32 0, i32 0
store i64 %0, ptr %2, align 8
%3 = getelementptr inbounds { i64, i64 }, ptr %f, i32 0, i32 1
store i64 %1, ptr %3, align 8
%4 = getelementptr inbounds { i64, i64 }, ptr %f, i32 0, i32 0
%lo = load i64, ptr %4, align 8
%5 = getelementptr inbounds { i64, i64 }, ptr %f, i32 0, i32 1
%hi = load i64, ptr %5, align 8
call void @hello2(i64 %lo, i64 %hi)
ret void
}

89
test/test_suite/abi/vec2_aarch64.c3t
View File

@@ -12,28 +12,29 @@ extern fn Vector2 vector2_add_value(Vector2 v, float add) { return Vector2 {}; }
extern fn Vector2 vector2_subtract(Vector2 v1, Vector2 v2) { return Vector2 {}; }
extern fn Vector2 vector2_subtract_value(Vector2 v, float sub) { return Vector2 {}; }
// #expect: abi.ll
/* #expect: abi.ll
%Vector2 = type { float, float }
define %Vector2 @vector2_zero() #0 {
entry:
%literal = alloca %Vector2, align 4
%0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %0, align 4
%1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %1, align 4
%2 = load %Vector2, %Vector2* %literal, align 4
%0 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %0, align 4
%1 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %1, align 4
%2 = load %Vector2, ptr %literal, align 4
ret %Vector2 %2
}
define %Vector2 @vector2_one() #0 {
entry:
%literal = alloca %Vector2, align 4
%0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %0, align 4
%1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %1, align 4
%2 = load %Vector2, %Vector2* %literal, align 4
%0 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %0, align 4
%1 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %1, align 4
%2 = load %Vector2, ptr %literal, align 4
ret %Vector2 %2
}
@@ -42,30 +43,27 @@ entry:
%v1 = alloca %Vector2, align 4
%v2 = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v1 to [2 x float]*
store [2 x float] %0, [2 x float]* %2, align 4
%3 = bitcast %Vector2* %v2 to [2 x float]*
store [2 x float] %1, [2 x float]* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %4, align 4
%5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %5, align 4
%6 = load %Vector2, %Vector2* %literal, align 4
ret %Vector2 %6
store [2 x float] %0, ptr %v1, align 4
store [2 x float] %1, ptr %v2, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load %Vector2, ptr %literal, align 4
ret %Vector2 %4
}
define %Vector2 @vector2_add_value([2 x float] %0, float %1) #0 {
entry:
%v = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v to [2 x float]*
store [2 x float] %0, [2 x float]* %2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = load %Vector2, %Vector2* %literal, align 4
ret %Vector2 %5
store [2 x float] %0, ptr %v, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load %Vector2, ptr %literal, align 4
ret %Vector2 %4
}
define %Vector2 @vector2_subtract([2 x float] %0, [2 x float] %1) #0 {
@@ -73,28 +71,25 @@ entry:
%v1 = alloca %Vector2, align 4
%v2 = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v1 to [2 x float]*
store [2 x float] %0, [2 x float]* %2, align 4
%3 = bitcast %Vector2* %v2 to [2 x float]*
store [2 x float] %1, [2 x float]* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %4, align 4
%5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %5, align 4
%6 = load %Vector2, %Vector2* %literal, align 4
ret %Vector2 %6
store [2 x float] %0, ptr %v1, align 4
store [2 x float] %1, ptr %v2, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load %Vector2, ptr %literal, align 4
ret %Vector2 %4
}
define %Vector2 @vector2_subtract_value([2 x float] %0, float %1) #0 {
entry:
%v = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v to [2 x float]*
store [2 x float] %0, [2 x float]* %2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = load %Vector2, %Vector2* %literal, align 4
ret %Vector2 %5
store [2 x float] %0, ptr %v, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load %Vector2, ptr %literal, align 4
ret %Vector2 %4
}

108
test/test_suite/abi/vec2_wasm.c3t
View File

@@ -12,88 +12,76 @@ extern fn Vector2 vector2_add_value(Vector2 v, float add) { return Vector2 {}; }
extern fn Vector2 vector2_subtract(Vector2 v1, Vector2 v2) { return Vector2 {}; }
extern fn Vector2 vector2_subtract_value(Vector2 v, float sub) { return Vector2 {}; }
// #expect: abi.ll
/* #expect: abi.ll
target triple = "wasm32-unknown-unknown"
%Vector2 = type { float, float }
define void @vector2_zero(%Vector2* noalias sret(%Vector2) align 4 %0) #0 {
define void @vector2_zero(ptr noalias sret(%Vector2) align 4 %0) #0 {
entry:
%literal = alloca %Vector2, align 4
%1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %1, align 4
%2 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %2, align 4
%3 = bitcast %Vector2* %0 to i8*
%4 = bitcast %Vector2* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %3, i8* align 4 %4, i32 8, i1 false)
%1 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %1, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %2, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 8, i1 false)
ret void
}
define void @vector2_one(%Vector2* noalias sret(%Vector2) align 4 %0) #0 {
define void @vector2_one(ptr noalias sret(%Vector2) align 4 %0) #0 {
entry:
%literal = alloca %Vector2, align 4
%1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %1, align 4
%2 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %2, align 4
%3 = bitcast %Vector2* %0 to i8*
%4 = bitcast %Vector2* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %3, i8* align 4 %4, i32 8, i1 false)
%1 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %1, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %2, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 8, i1 false)
ret void
}
define void @vector2_add(%Vector2* noalias sret(%Vector2) align 4 %0, %Vector2* byval(%Vector2) align 4 %1, %Vector2* byval(%Vector2) align 4 %2) #0 {
define void @vector2_add(ptr noalias sret(%Vector2) align 4 %0, ptr byval(%Vector2) align 4 %1, ptr byval(%Vector2) align 4 %2) #0 {
entry:
%literal = alloca %Vector2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = bitcast %Vector2* %0 to i8*
%6 = bitcast %Vector2* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %5, i8* align 4 %6, i32 8, i1 false)
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %3, align 4
%4 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %4, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 8, i1 false)
ret void
}
define void @vector2_add_value(ptr noalias sret(%Vector2) align 4 %0, ptr byval(%Vector2) align 4 %1, float %2) #0 {
entry:
%literal = alloca %Vector2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %3, align 4
%4 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %4, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 8, i1 false)
ret void
}
define void @vector2_subtract(ptr noalias sret(%Vector2) align 4 %0, ptr byval(%Vector2) align 4 %1, ptr byval(%Vector2) align 4 %2) #0 {
entry:
%literal = alloca %Vector2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %3, align 4
%4 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %4, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 8, i1 false)
ret void
}
; Function Attrs: nounwind
define void @vector2_add_value(%Vector2* noalias sret(%Vector2) align 4 %0, %Vector2* byval(%Vector2) align 4 %1, float %2) #0 {
define void @vector2_subtract_value(ptr noalias sret(%Vector2) align 4 %0, ptr byval(%Vector2) align 4 %1, float %2) #0 {
entry:
%literal = alloca %Vector2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = bitcast %Vector2* %0 to i8*
%6 = bitcast %Vector2* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %5, i8* align 4 %6, i32 8, i1 false)
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %3, align 4
%4 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %4, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 %literal, i32 8, i1 false)
ret void
}
; Function Attrs: nounwind
define void @vector2_subtract(%Vector2* noalias sret(%Vector2) align 4 %0, %Vector2* byval(%Vector2) align 4 %1, %Vector2* byval(%Vector2) align 4 %2) #0 {
entry:
%literal = alloca %Vector2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = bitcast %Vector2* %0 to i8*
%6 = bitcast %Vector2* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %5, i8* align 4 %6, i32 8, i1 false)
ret void
}
; Function Attrs: nounwind
define void @vector2_subtract_value(%Vector2* noalias sret(%Vector2) align 4 %0, %Vector2* byval(%Vector2) align 4 %1, float %2) #0 {
entry:
%literal = alloca %Vector2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = bitcast %Vector2* %0 to i8*
%6 = bitcast %Vector2* %literal to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %5, i8* align 4 %6, i32 8, i1 false)
ret void
}

99
test/test_suite/abi/vec2_x64.c3t
View File

@@ -19,25 +19,23 @@ extern fn Vector2 vector2_subtract_value(Vector2 v, float sub) { return Vector2
define <2 x float> @vector2_zero() #0 {
entry:
%literal = alloca %Vector2, align 4
%0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %0, align 4
%1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %1, align 4
%2 = bitcast %Vector2* %literal to <2 x float>*
%3 = load <2 x float>, <2 x float>* %2, align 4
ret <2 x float> %3
%0 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %0, align 4
%1 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %1, align 4
%2 = load <2 x float>, ptr %literal, align 4
ret <2 x float> %2
}
define <2 x float> @vector2_one() #0 {
entry:
%literal = alloca %Vector2, align 4
%0 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %0, align 4
%1 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %1, align 4
%2 = bitcast %Vector2* %literal to <2 x float>*
%3 = load <2 x float>, <2 x float>* %2, align 4
ret <2 x float> %3
%0 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %0, align 4
%1 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %1, align 4
%2 = load <2 x float>, ptr %literal, align 4
ret <2 x float> %2
}
define <2 x float> @vector2_add(<2 x float> %0, <2 x float> %1) #0 {
@@ -45,66 +43,53 @@ entry:
%v1 = alloca %Vector2, align 4
%v2 = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v1 to <2 x float>*
store <2 x float> %0, <2 x float>* %2, align 4
%3 = bitcast %Vector2* %v2 to <2 x float>*
store <2 x float> %1, <2 x float>* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %4, align 4
%5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %5, align 4
%6 = bitcast %Vector2* %literal to <2 x float>*
%7 = load <2 x float>, <2 x float>* %6, align 4
ret <2 x float> %7
store <2 x float> %0, ptr %v1, align 4
store <2 x float> %1, ptr %v2, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load <2 x float>, ptr %literal, align 4
ret <2 x float> %4
}
; Function Attrs: nounwind
define <2 x float> @vector2_add_value(<2 x float> %0, float %1) #0 {
entry:
%v = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v to <2 x float>*
store <2 x float> %0, <2 x float>* %2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = bitcast %Vector2* %literal to <2 x float>*
%6 = load <2 x float>, <2 x float>* %5, align 4
ret <2 x float> %6
store <2 x float> %0, ptr %v, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load <2 x float>, ptr %literal, align 4
ret <2 x float> %4
}
; Function Attrs: nounwind
define <2 x float> @vector2_subtract(<2 x float> %0, <2 x float> %1) #0 {
entry:
%v1 = alloca %Vector2, align 4
%v2 = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v1 to <2 x float>*
store <2 x float> %0, <2 x float>* %2, align 4
%3 = bitcast %Vector2* %v2 to <2 x float>*
store <2 x float> %1, <2 x float>* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %4, align 4
%5 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %5, align 4
%6 = bitcast %Vector2* %literal to <2 x float>*
%7 = load <2 x float>, <2 x float>* %6, align 4
ret <2 x float> %7
store <2 x float> %0, ptr %v1, align 4
store <2 x float> %1, ptr %v2, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load <2 x float>, ptr %literal, align 4
ret <2 x float> %4
}
; Function Attrs: nounwind
define <2 x float> @vector2_subtract_value(<2 x float> %0, float %1) #0 {
entry:
%v = alloca %Vector2, align 4
%literal = alloca %Vector2, align 4
%2 = bitcast %Vector2* %v to <2 x float>*
store <2 x float> %0, <2 x float>* %2, align 4
%3 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 0
store float 0.000000e+00, float* %3, align 4
%4 = getelementptr inbounds %Vector2, %Vector2* %literal, i32 0, i32 1
store float 0.000000e+00, float* %4, align 4
%5 = bitcast %Vector2* %literal to <2 x float>*
%6 = load <2 x float>, <2 x float>* %5, align 4
ret <2 x float> %6
store <2 x float> %0, ptr %v, align 4
%2 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Vector2, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %3, align 4
%4 = load <2 x float>, ptr %literal, align 4
ret <2 x float> %4
}

19
test/test_suite/abi/x64alignarray.c3t
View File

@@ -14,15 +14,14 @@ fn void test1_g()
define void @test_test1_g() #0 {
entry:
%x = alloca [4 x float], align 16
%0 = getelementptr inbounds [4 x float], [4 x float]* %x, i64 0, i64 0
store float 0.000000e+00, float* %0, align 4
%1 = getelementptr inbounds [4 x float], [4 x float]* %x, i64 0, i64 1
store float 0.000000e+00, float* %1, align 4
%2 = getelementptr inbounds [4 x float], [4 x float]* %x, i64 0, i64 2
store float 0.000000e+00, float* %2, align 4
%3 = getelementptr inbounds [4 x float], [4 x float]* %x, i64 0, i64 3
store float 0.000000e+00, float* %3, align 4
%ptrptr = bitcast [4 x float]* %x to i8*
call void @test1_f(i8* %ptrptr)
%0 = getelementptr inbounds [4 x float], ptr %x, i64 0, i64 0
store float 0.000000e+00, ptr %0, align 4
%1 = getelementptr inbounds [4 x float], ptr %x, i64 0, i64 1
store float 0.000000e+00, ptr %1, align 4
%2 = getelementptr inbounds [4 x float], ptr %x, i64 0, i64 2
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds [4 x float], ptr %x, i64 0, i64 3
store float 0.000000e+00, ptr %3, align 4
call void @test1_f(ptr %x)
ret void
}

28
test/test_suite/arrays/array_casts.c3t
View File

@@ -9,26 +9,24 @@ fn void test()
int[] z = &x;
}
// #expect: array_casts.ll
/* #expect: array_casts.ll
%"int[]" = type { i32*, i64 }
%"int[]" = type { ptr, i64 }
define void @array_casts_test() #0 {
entry:
%x = alloca [3 x i32], align 4
%y = alloca i32*, align 8
%y = alloca ptr, align 8
%z = alloca %"int[]", align 8
%0 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 0
store i32 0, i32* %0, align 4
%1 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 1
store i32 0, i32* %1, align 4
%2 = getelementptr inbounds [3 x i32], [3 x i32]* %x, i64 0, i64 2
store i32 0, i32* %2, align 4
%ptrptr = bitcast [3 x i32]* %x to i32*
store i32* %ptrptr, i32** %y, align 8
%3 = bitcast [3 x i32]* %x to i32*
%4 = insertvalue %"int[]" undef, i32* %3, 0
%5 = insertvalue %"int[]" %4, i64 3, 1
store %"int[]" %5, %"int[]"* %z, align 8
%0 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 0
store i32 0, ptr %0, align 4
%1 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 1
store i32 0, ptr %1, align 4
%2 = getelementptr inbounds [3 x i32], ptr %x, i64 0, i64 2
store i32 0, ptr %2, align 4
store ptr %x, ptr %y, align 8
%3 = insertvalue %"int[]" undef, ptr %x, 0
%4 = insertvalue %"int[]" %3, i64 3, 1
store %"int[]" %4, ptr %z, align 8
ret void
}

9
test/test_suite/arrays/array_literal.c3t
View File

@@ -19,10 +19,9 @@ fn double test(uint x)
define double @array_literal_test(i32 %0) #0 {
entry:
%student_t = alloca [30 x double], align 16
%1 = bitcast [30 x double]* %student_t to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %1, i8* align 16 bitcast ([30 x double]* @.__const to i8*), i32 240, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %student_t, ptr align 16 @.__const, i32 240, i1 false)
%zext = zext i32 %0 to i64
%2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %zext
%3 = load double, double* %2, align 8
ret double %3
%1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %zext
%2 = load double, ptr %1, align 8
ret double %2
}

5
test/test_suite/arrays/complex_array_const.c3t
View File

@@ -13,9 +13,10 @@ private Connection[3] link
{2, "link2", 20},
{3, "link3", 30} };
// #expect: test.ll
/* #expect: test.ll
@"ct$test_Connection" = linkonce constant %.introspect { i8 10, i64 24, i64 0, i64 3, [0 x i64] zeroinitializer }, align 8
@.str = private unnamed_addr constant [6 x i8] c"link1\00", align 1
@.str.1 = private unnamed_addr constant [6 x i8] c"link2\00", align 1
@.str.2 = private unnamed_addr constant [6 x i8] c"link3\00", align 1
@test_link = protected unnamed_addr global [3 x %Connection] [%Connection { i64 1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0), i64 10 }, %Connection { i64 2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i64 20 }, %Connection { i64 3, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i32 0, i32 0), i64 30 }], align 16
@test_link = protected unnamed_addr global [3 x %Connection] [%Connection { i64 1, ptr @.str, i64 10 }, %Connection { i64 2, ptr @.str.1, i64 20 }, %Connection { i64 3, ptr @.str.2, i64 30 }], align 16

59
test/test_suite/arrays/global_init.c3t
View File

@@ -21,51 +21,42 @@ fn void main() {
/* #expect: test.ll
@.taddr = private global i32 3, align 4
@test_foo = local_unnamed_addr global i32* @.taddr, align 8
@test_foo = local_unnamed_addr global ptr @.taddr, align 8
@test_a = global i32 0, align 4
@test_c = local_unnamed_addr global i32 0, align 4
@test_d = local_unnamed_addr global i32 0, align 4
@test_abc = local_unnamed_addr global [3 x i32] zeroinitializer, align 4
@test_b = local_unnamed_addr global i32* getelementptr (i32, i32* @test_a, i64 7), align 8
@test_bf = local_unnamed_addr global i32* getelementptr ([3 x i32], [3 x i32]* @test_abc, i64 1, i64 1), align 8
@test_bf2 = local_unnamed_addr global i32* getelementptr inbounds ([3 x i32], [3 x i32]* @test_abc, i64 0, i64 2), align 8
@test_bf3 = local_unnamed_addr global i32* getelementptr ([3 x i32], [3 x i32]* @test_abc, i64 1, i64 1), align 8
@test_b = local_unnamed_addr global ptr getelementptr (i32, ptr @test_a, i64 7), align 8
@test_bf = local_unnamed_addr global ptr getelementptr ([3 x i32], ptr @test_abc, i64 1, i64 1), align 8
@test_bf2 = local_unnamed_addr global ptr getelementptr inbounds ([3 x i32], ptr @test_abc, i64 0, i64 2), align 8
@test_bf3 = local_unnamed_addr global ptr getelementptr ([3 x i32], ptr @test_abc, i64 1, i64 1), align 8
@.taddr.9 = private global i32 42, align 4
@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
@.taddr.10 = private global i8 99, align 1
@"ct$char" = linkonce constant %.introspect { i8 3, i64 1, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
@.str = private unnamed_addr constant [4 x i8] c"for\00", align 1
@.taddr.11 = private global [3 x i8]* bitcast ([4 x i8]* @.str to [3 x i8]*), align 8
@"ct$a3$char" = linkonce constant %.introspect { i8 15, i64 3, i64 ptrtoint (%.introspect* @"ct$char" to i64), i64 3, [0 x i64] zeroinitializer }, align 8
@"ct$p$a3$char" = linkonce constant %.introspect { i8 19, i64 8, i64 ptrtoint (%.introspect* @"ct$a3$char" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { i8* bitcast (i32* @.taddr.9 to i8*), i64 ptrtoint (%.introspect* @"ct$int" to i64) }, %variant { i8* @.taddr.10, i64 ptrtoint (%.introspect* @"ct$char" to i64) }, %variant { i8* bitcast ([3 x i8]** @.taddr.11 to i8*), i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64) }], align 16
@.str.12 = private unnamed_addr constant [4 x i8] c"for\00", align 1
@.taddr.11 = private global ptr @.str, align 8
@"main$x" = internal unnamed_addr global [3 x %variant] [%variant { ptr @.taddr.9, i64 ptrtoint (ptr @"ct$int" to i64) }, %variant { ptr @.taddr.10, i64 ptrtoint (ptr @"ct$char" to i64) }, %variant { ptr @.taddr.11, i64 ptrtoint (ptr @"ct$p$a3$char" to i64) }], align 16
; Function Attrs: nounwind
define void @test_main() #0 {
entry:
%bf34 = alloca i32*, align 8
%bf34 = alloca ptr, align 8
%y = alloca [3 x %variant], align 16
%taddr = alloca i32, align 4
%taddr1 = alloca i8, align 1
%taddr2 = alloca [3 x i8]*, align 8
store i32* getelementptr
%0 = getelementptr inbounds [3 x %variant], [3 x %variant]* %y, i64 0, i64 0
store i32 42, i32* %taddr, align 4
%1 = bitcast i32* %taddr to i8*
%2 = insertvalue %variant undef, i8* %1, 0
%3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
store %variant %3, %variant* %0, align 16
%4 = getelementptr inbounds [3 x %variant], [3 x %variant]* %y, i64 0, i64 1
store i8 99, i8* %taddr1, align 1
%5 = insertvalue %variant undef, i8* %taddr1, 0
%6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
store %variant %6, %variant* %4, align 16
%7 = getelementptr inbounds [3 x %variant], [3 x %variant]* %y, i64 0, i64 2
store [3 x i8]* bitcast ([4 x i8]* @.str.12 to [3 x i8]*), [3 x i8]** %taddr2, align 8
%8 = bitcast [3 x i8]** %taddr2 to i8*
%9 = insertvalue %variant undef, i8* %8, 0
%10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$p$a3$char" to i64), 1
store %variant %10, %variant* %7, align 16
%taddr2 = alloca ptr, align 8
store ptr getelementptr ([3 x i32], ptr @test_abc, i64 2, i64 1), ptr %bf34, align 8
%0 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 0
store i32 42, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
%2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
store %variant %2, ptr %0, align 16
%3 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 1
store i8 99, ptr %taddr1, align 1
%4 = insertvalue %variant undef, ptr %taddr1, 0
%5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$char" to i64), 1
store %variant %5, ptr %3, align 16
%6 = getelementptr inbounds [3 x %variant], ptr %y, i64 0, i64 2
store ptr @.str.12, ptr %taddr2, align 8
%7 = insertvalue %variant undef, ptr %taddr2, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
store %variant %8, ptr %6, align 16
ret void
}

38
test/test_suite/arrays/index_from_back.c3t
View File

@@ -15,7 +15,7 @@ fn void test(int[10] x, int[<10>] y)
/* #expect: test.ll
define void @test_test([10 x i32]* byval([10 x i32]) align 8 %0, <10 x i32>* byval(<10 x i32>) align 64 %1) #0 {
define void @test_test(ptr byval([10 x i32]) align 8 %0, ptr byval(<10 x i32>) align 64 %1) #0 {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
@@ -24,30 +24,30 @@ entry:
%j = alloca i32, align 4
%e = alloca i32, align 4
%f = alloca i32, align 4
%2 = getelementptr inbounds [10 x i32], [10 x i32]* %0, i64 0, i64 4
%3 = load i32, i32* %2, align 4
store i32 %3, i32* %a, align 4
%4 = getelementptr inbounds [10 x i32], [10 x i32]* %0, i64 0, i64 8
%5 = load i32, i32* %4, align 4
store i32 %5, i32* %b, align 4
%6 = load <10 x i32>, <10 x i32>* %1, align 64
%2 = getelementptr inbounds [10 x i32], ptr %0, i64 0, i64 4
%3 = load i32, ptr %2, align 4
store i32 %3, ptr %a, align 4
%4 = getelementptr inbounds [10 x i32], ptr %0, i64 0, i64 8
%5 = load i32, ptr %4, align 4
store i32 %5, ptr %b, align 4
%6 = load <10 x i32>, ptr %1, align 64
%7 = extractelement <10 x i32> %6, i64 4
store i32 %7, i32* %c, align 4
%8 = load <10 x i32>, <10 x i32>* %1, align 64
store i32 %7, ptr %c, align 4
%8 = load <10 x i32>, ptr %1, align 64
%9 = extractelement <10 x i32> %8, i64 8
store i32 %9, i32* %d, align 4
store i32 3, i32* %j, align 4
%10 = load <10 x i32>, <10 x i32>* %1, align 64
%11 = load i32, i32* %j, align 4
store i32 %9, ptr %d, align 4
store i32 3, ptr %j, align 4
%10 = load <10 x i32>, ptr %1, align 64
%11 = load i32, ptr %j, align 4
%sisiext = sext i32 %11 to i64
%12 = sub nuw i64 10, %sisiext
%13 = extractelement <10 x i32> %10, i64 %12
store i32 %13, i32* %e, align 4
%14 = load i32, i32* %j, align 4
store i32 %13, ptr %e, align 4
%14 = load i32, ptr %j, align 4
%sisiext1 = sext i32 %14 to i64
%15 = sub nuw i64 10, %sisiext1
%16 = getelementptr inbounds [10 x i32], [10 x i32]* %0, i64 0, i64 %15
%17 = load i32, i32* %16, align 4
store i32 %17, i32* %f, align 4
%16 = getelementptr inbounds [10 x i32], ptr %0, i64 0, i64 %15
%17 = load i32, ptr %16, align 4
store i32 %17, ptr %f, align 4
ret void
}

8
test/test_suite/arrays/index_into_global.c3t
View File

@@ -25,9 +25,9 @@ fn void test_bar(int idx)
define void @foo_test_bar(i32 %0) #0 {
entry:
%sisiext = sext i32 %0 to i64
%1 = getelementptr inbounds [6 x %Bar], [6 x %Bar]* @foo_bar, i64 0, i64 %sisiext
%2 = getelementptr inbounds %Bar, %Bar* %1, i32 0, i32 0
store i32 0, i32* %2, align 4
store i32 %0, i32* getelementptr inbounds ([6 x %Bar], [6 x %Bar]* @foo_bar, i64 0, i64 0, i32 0), align 4
%1 = getelementptr inbounds [6 x %Bar], ptr @foo_bar, i64 0, i64 %sisiext
%2 = getelementptr inbounds %Bar, ptr %1, i32 0, i32 0
store i32 0, ptr %2, align 4
store i32 %0, ptr @foo_bar, align 4
ret void
}

32
test/test_suite/asm/asm_regression.c3t
View File

@@ -27,24 +27,24 @@ fn void main()
movq [&z], 33;
addl aa, 22;
}
io::printfln("aa: %d", aa);
io::printfln("Z: %d", z);
io::printfln("x: %d", x);
io::printfln("G was: %d", g);
foreach(int abc : a) io::printfln("%d", abc);
io::printfn("aa: %d", aa);
io::printfn("Z: %d", z);
io::printfn("x: %d", x);
io::printfn("G was: %d", g);
foreach(int abc : a) io::printfn("%d", abc);
}
/* #expect: test.ll
%5 = load i32*, i32** %gp, align 8
%6 = load i32*, i32** %xa, align 8
%7 = load i64, i64* %asf, align 8
%8 = load i32, i32* %x, align 4
%add3 = add i32 23, %8
%9 = load i32, i32* %aa, align 4
%10 = call { i32, i32 } asm alignstack "movl $$4, $0\0Amovl $0, ($3)\0Amovl $$1, $0\0Amovl $0, 4($4,$5,4)\0Amovl $6, %eax\0Amovl %eax, $0\0Amovq $$33, $1\0Aaddl $$22, $2\0A", "=&r,=*&m,=r,r,r,r,r,2,~{cc},~{rax},~{flags},~{dirflag},~{fspr}"
%11 = extractvalue { i32, i32 } %10, 0
store i32 %11, i32* %x, align 4
%12 = extractvalue { i32, i32 } %10, 1
store i32 %12, i32* %aa, align 4
%4 = load ptr, ptr %gp, align 8
%5 = load ptr, ptr %xa, align 8
%6 = load i64, ptr %asf, align 8
%7 = load i32, ptr %x, align 4
%add3 = add i32 23, %7
%8 = load i32, ptr %aa, align 4
%9 = call { i32, i32 } asm alignstack "movl $$4, $0\0Amovl $0, ($3)\0Amovl $$1, $0\0Amovl $0, 4($4,$5,4)\0Amovl $6, %eax\0Amovl %eax, $0\0Amovq $$33, $1\0Aaddl $$22, $2\0A", "=&r,=*&m,=r,r,r,r,r,2,~{cc},~{rax},~{flags},~{dirflag},~{fspr}"(ptr elementtype(i64) %z, ptr %4, ptr %5, i64 %6, i32 %add3, i32 %8)
%10 = extractvalue { i32, i32 } %9, 0
store i32 %10, ptr %x, align 4
%11 = extractvalue { i32, i32 } %9, 1
store i32 %11, ptr %aa, align 4

24
test/test_suite/assert/assert_variants.c3t
View File

@@ -25,37 +25,37 @@ fn void test()
%y = alloca i32, align 4
%z = alloca i32, align 4
%0 = call i32 @assert_variants_foo()
store i32 %0, i32* %x, align 4
store i32 %0, ptr %x, align 4
%1 = call i32 @assert_variants_foo()
store i32 %1, i32* %y, align 4
store i32 %1, ptr %y, align 4
%2 = call i32 @assert_variants_foo()
store i32 %2, i32* %z, align 4
%3 = load i32, i32* %x, align 4
store i32 %2, ptr %z, align 4
%3 = load i32, ptr %x, align 4
%gt = icmp sgt i32 %3, 0
call void @llvm.assume(i1 %gt)
%4 = load i32, i32* %y, align 4
%4 = load i32, ptr %y, align 4
%gt1 = icmp sgt i32 %4, 0
call void @llvm.assume(i1 %gt1)
%5 = load i32, i32* %z, align 4
%5 = load i32, ptr %z, align 4
%gt2 = icmp sgt i32 %5, 0
call void @llvm.assume(i1 %gt2)
%6 = load i32, i32* %x, align 4
%6 = load i32, ptr %x, align 4
%gt3 = icmp sgt i32 %6, 0
call void @llvm.assume(i1 %gt3)
%7 = load i32, i32* %y, align 4
%7 = load i32, ptr %y, align 4
%gt4 = icmp sgt i32 %7, 0
call void @llvm.assume(i1 %gt4)
%8 = load i32, i32* %z, align 4
%8 = load i32, ptr %z, align 4
%gt5 = icmp sgt i32 %8, 0
call void @llvm.assume(i1 %gt5)
%9 = load i32, i32* %x, align 4
%9 = load i32, ptr %x, align 4
%gt6 = icmp sgt i32 %9, 0
call void @llvm.assume(i1 %gt6)
%10 = load i32, i32* %x, align 4
%10 = load i32, ptr %x, align 4
%lt = icmp slt i32 %10, 1
%not = xor i1 %lt, true
call void @llvm.assume(i1 %not)
%11 = load i32, i32* %y, align 4
%11 = load i32, ptr %y, align 4
%lt7 = icmp slt i32 %11, 1
%not8 = xor i1 %lt7, true
call void @llvm.assume(i1 %not8)

13
test/test_suite/assert/unreachable.c3t
View File

@@ -19,8 +19,8 @@ define void @unreachable_test() #0 {
entry:
%x = alloca i32, align 4
%0 = call i32 @unreachable_foo()
store i32 %0, i32* %x, align 4
%1 = load i32, i32* %x, align 4
store i32 %0, ptr %x, align 4
%1 = load i32, ptr %x, align 4
%gt = icmp sgt i32 %1, 0
br i1 %gt, label %if.then, label %if.exit
@@ -28,13 +28,14 @@ if.then: ; preds = %entry
ret void
if.exit: ; preds = %entry
%2 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
call void %2(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i32 0, i32 0), i64 30, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i32 0, i32 0), i64 14, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i64 4, i32 10)
%2 = load ptr, ptr @std_core_builtin_panic, align 8
call void %2(ptr @.str, i64 30, ptr @.str.1, i64 14, ptr @.str.2, i64 4, i32 10)
unreachable
after.unreachable: ; No predecessors!
%3 = load i32, i32* %x, align 4
%3 = load i32, ptr %x, align 4
%add = add i32 %3, 1
store i32 %add, i32* %x, align 4
store i32 %add, ptr %x, align 4
ret void
}

66
test/test_suite/assignment/int_assign.c3t
View File

@@ -22,48 +22,48 @@ fn int foo()
%x = alloca i32, align 4
%y = alloca i32, align 4
store i32 0, i32* %x, align 4
store i32 0, i32* %y, align 4
%0 = load i32, i32* %x, align 4
%1 = load i32, i32* %y, align 4
store i32 0, ptr %x, align 4
store i32 0, ptr %y, align 4
%0 = load i32, ptr %x, align 4
%1 = load i32, ptr %y, align 4
%add = add i32 %0, %1
store i32 %add, i32* %x, align 4
%2 = load i32, i32* %x, align 4
%3 = load i32, i32* %y, align 4
store i32 %add, ptr %x, align 4
%2 = load i32, ptr %x, align 4
%3 = load i32, ptr %y, align 4
%sub = sub i32 %2, %3
store i32 %sub, i32* %x, align 4
%4 = load i32, i32* %x, align 4
%5 = load i32, i32* %y, align 4
store i32 %sub, ptr %x, align 4
%4 = load i32, ptr %x, align 4
%5 = load i32, ptr %y, align 4
%smod = srem i32 %4, %5
store i32 %smod, i32* %x, align 4
%6 = load i32, i32* %x, align 4
%7 = load i32, i32* %y, align 4
store i32 %smod, ptr %x, align 4
%6 = load i32, ptr %x, align 4
%7 = load i32, ptr %y, align 4
%sdiv = sdiv i32 %6, %7
store i32 %sdiv, i32* %x, align 4
%8 = load i32, i32* %x, align 4
%9 = load i32, i32* %y, align 4
store i32 %sdiv, ptr %x, align 4
%8 = load i32, ptr %x, align 4
%9 = load i32, ptr %y, align 4
%mul = mul i32 %8, %9
store i32 %mul, i32* %x, align 4
%10 = load i32, i32* %x, align 4
%11 = load i32, i32* %y, align 4
store i32 %mul, ptr %x, align 4
%10 = load i32, ptr %x, align 4
%11 = load i32, ptr %y, align 4
%shl = shl i32 %10, %11
%12 = freeze i32 %shl
store i32 %12, i32* %x, align 4
%13 = load i32, i32* %x, align 4
%14 = load i32, i32* %y, align 4
store i32 %12, ptr %x, align 4
%13 = load i32, ptr %x, align 4
%14 = load i32, ptr %y, align 4
%ashr = ashr i32 %13, %14
%15 = freeze i32 %ashr
store i32 %15, i32* %x, align 4
%16 = load i32, i32* %x, align 4
%17 = load i32, i32* %y, align 4
store i32 %15, ptr %x, align 4
%16 = load i32, ptr %x, align 4
%17 = load i32, ptr %y, align 4
%xor = xor i32 %16, %17
store i32 %xor, i32* %x, align 4
%18 = load i32, i32* %x, align 4
%19 = load i32, i32* %y, align 4
store i32 %xor, ptr %x, align 4
%18 = load i32, ptr %x, align 4
%19 = load i32, ptr %y, align 4
%or = or i32 %18, %19
store i32 %or, i32* %x, align 4
%20 = load i32, i32* %x, align 4
%21 = load i32, i32* %y, align 4
store i32 %or, ptr %x, align 4
%20 = load i32, ptr %x, align 4
%21 = load i32, ptr %y, align 4
%and = and i32 %20, %21
store i32 %and, i32* %x, align 4
%22 = load i32, i32* %x, align 4
store i32 %and, ptr %x, align 4
%22 = load i32, ptr %x, align 4

8
test/test_suite/attributes/recursive_attributes.c3
View File

@@ -1,10 +1,7 @@
module test;
define @Align(y) = @Align16(y / 2);
// This one is directly recursive
define @Align16(x) = @align(4), @Align(8 * x); // #error: Recursive declaration of attribute
// This one uses a recursive attribute
define @AlignIndirect(x) = @Align16(x); // #error: Recursive declaration of attribute
define @Test = @noinline;
struct Foo
{
@@ -18,8 +15,3 @@ fn void testme() @Test
{
int x;
}
struct Bar
{
int abc @AlignIndirect(8);
}

2
test/test_suite/attributes/user_defined_attributes.c3t
View File

@@ -34,7 +34,7 @@ fn void main() @TestZero
define void @test_testme() #0 {
entry:
%x = alloca i32, align 4
store i32 0, i32* %x, align 4
store i32 0, ptr %x, align 4
ret void
}

34
test/test_suite/bitstruct/array_with_boolean.c3t
View File

@@ -27,45 +27,45 @@ define void @foo_main() #0 {
entry:
%xx = alloca [3 x i8], align 1
%xy = alloca [3 x i8], align 1
store [3 x i8] c"\1A\1E\08", [3 x i8]* %xx, align 1
store [3 x i8] c"\1A\1E\10", [3 x i8]* %xy, align 1
%0 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
%1 = load i8, i8* %0, align 1
store [3 x i8] c"\1A\1E\08", ptr %xx, align 1
store [3 x i8] c"\1A\1E\10", ptr %xy, align 1
%0 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
%1 = load i8, ptr %0, align 1
%zext = zext i8 %1 to i32
%shl = shl i32 %zext, 29
%ashr = ashr i32 %shl, 29
%2 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
%3 = load i8, i8* %2, align 1
%2 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
%3 = load i8, ptr %2, align 1
%zext1 = zext i8 %3 to i32
%lshrl = lshr i32 %zext1, 3
%4 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
%5 = load i8, i8* %4, align 1
%4 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
%5 = load i8, ptr %4, align 1
%zext2 = zext i8 %5 to i32
%shl3 = shl i32 %zext2, 5
%6 = or i32 %shl3, %lshrl
%shl4 = shl i32 %6, 26
%ashr5 = ashr i32 %shl4, 26
%7 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
%8 = load i8, i8* %7, align 1
%7 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
%8 = load i8, ptr %7, align 1
%zext6 = zext i8 %8 to i32
%lshrl7 = lshr i32 %zext6, 1
%9 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
%10 = load i8, i8* %9, align 1
%9 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
%10 = load i8, ptr %9, align 1
%zext8 = zext i8 %10 to i32
%shl9 = shl i32 %zext8, 7
%11 = or i32 %shl9, %lshrl7
%shl10 = shl i32 %11, 22
%ashr11 = ashr i32 %shl10, 22
%12 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
%13 = load i8, i8* %12, align 1
%12 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
%13 = load i8, ptr %12, align 1
%lshrl12 = lshr i8 %13, 3
%14 = trunc i8 %lshrl12 to i1
%boolsi = zext i1 %14 to i32
%15 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
%16 = load i8, i8* %15, align 1
%15 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
%16 = load i8, ptr %15, align 1
%lshrl13 = lshr i8 %16, 4
%17 = trunc i8 %lshrl13 to i1
%boolsi14 = zext i1 %17 to i32
call void (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i32 0, i32 0), i32 %ashr, i32 %ashr5, i32 %ashr11, i32 %boolsi, i32 %boolsi14)
call void (ptr, ...) @printf(ptr @.str, i32 %ashr, i32 %ashr5, i32 %ashr11, i32 %boolsi, i32 %boolsi14)
ret void
}

82
test/test_suite/bitstruct/bitfield_access.c3t
View File

@@ -111,70 +111,70 @@ entry:
%z2 = alloca [3 x i8], align 1
%z3 = alloca [3 x i8], align 1
%xx = alloca [5 x i8], align 1
store i8 115, i8* %b, align 1
store i16 5, i16* %c1, align 2
store i16 96, i16* %c2, align 2
store i16 18432, i16* %c3, align 2
store i16 18683, i16* %c4, align 2
store i16 27, i16* %c5, align 2
store i16 5, i16* %c6, align 2
store i16 10240, i16* %c7, align 2
store [3 x i8] c"\0B\06 ", [3 x i8]* %e1, align 1
store [3 x i8] c"\09\06 ", [3 x i8]* %e2, align 1
store [3 x i8] c"\0A\06 ", [3 x i8]* %e3, align 1
store i8 0, i8* %d, align 1
%0 = getelementptr inbounds [3 x i8], [3 x i8]* %e1, i64 0, i64 0
%1 = load i8, i8* %0, align 1
store i8 115, ptr %b, align 1
store i16 5, ptr %c1, align 2
store i16 96, ptr %c2, align 2
store i16 18432, ptr %c3, align 2
store i16 18683, ptr %c4, align 2
store i16 27, ptr %c5, align 2
store i16 5, ptr %c6, align 2
store i16 10240, ptr %c7, align 2
store [3 x i8] c"\0B\06 ", ptr %e1, align 1
store [3 x i8] c"\09\06 ", ptr %e2, align 1
store [3 x i8] c"\0A\06 ", ptr %e3, align 1
store i8 0, ptr %d, align 1
%0 = getelementptr inbounds [3 x i8], ptr %e1, i64 0, i64 0
%1 = load i8, ptr %0, align 1
%zext = zext i8 %1 to i32
%shl = shl i32 %zext, 29
%ashr = ashr i32 %shl, 29
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
%2 = getelementptr inbounds [3 x i8], [3 x i8]* %e2, i64 0, i64 0
%3 = load i8, i8* %2, align 1
call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
%2 = getelementptr inbounds [3 x i8], ptr %e2, i64 0, i64 0
%3 = load i8, ptr %2, align 1
%zext1 = zext i8 %3 to i32
%shl2 = shl i32 %zext1, 29
%ashr3 = ashr i32 %shl2, 29
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %ashr3)
%4 = getelementptr inbounds [3 x i8], [3 x i8]* %e3, i64 0, i64 0
%5 = load i8, i8* %4, align 1
call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr3)
%4 = getelementptr inbounds [3 x i8], ptr %e3, i64 0, i64 0
%5 = load i8, ptr %4, align 1
%zext4 = zext i8 %5 to i32
%shl5 = shl i32 %zext4, 29
%ashr6 = ashr i32 %shl5, 29
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %ashr6)
store [3 x i8] c"\0B\06 ", [3 x i8]* %z1, align 1
store [3 x i8] c"\0C\06 ", [3 x i8]* %z2, align 1
store [3 x i8] c"\0F\06 ", [3 x i8]* %z3, align 1
%6 = getelementptr inbounds [3 x i8], [3 x i8]* %z1, i64 0, i64 0
%7 = load i8, i8* %6, align 1
call void (ptr, ...) @printf(ptr @.str.2, i32 %ashr6)
store [3 x i8] c"\0B\06 ", ptr %z1, align 1
store [3 x i8] c"\0C\06 ", ptr %z2, align 1
store [3 x i8] c"\0F\06 ", ptr %z3, align 1
%6 = getelementptr inbounds [3 x i8], ptr %z1, i64 0, i64 0
%7 = load i8, ptr %6, align 1
%zext7 = zext i8 %7 to i32
%8 = and i32 7, %zext7
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i32 %8)
%9 = getelementptr inbounds [3 x i8], [3 x i8]* %z2, i64 0, i64 0
%10 = load i8, i8* %9, align 1
call void (ptr, ...) @printf(ptr @.str.3, i32 %8)
%9 = getelementptr inbounds [3 x i8], ptr %z2, i64 0, i64 0
%10 = load i8, ptr %9, align 1
%zext8 = zext i8 %10 to i32
%11 = and i32 7, %zext8
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), i32 %11)
%12 = getelementptr inbounds [3 x i8], [3 x i8]* %z3, i64 0, i64 0
%13 = load i8, i8* %12, align 1
call void (ptr, ...) @printf(ptr @.str.4, i32 %11)
%12 = getelementptr inbounds [3 x i8], ptr %z3, i64 0, i64 0
%13 = load i8, ptr %12, align 1
%zext9 = zext i8 %13 to i32
%14 = and i32 7, %zext9
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i32 0, i32 0), i32 %14)
store [5 x i8] c"\00G\02\00\00", [5 x i8]* %xx, align 1
%15 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 0
%16 = load i8, i8* %15, align 1
call void (ptr, ...) @printf(ptr @.str.5, i32 %14)
store [5 x i8] c"\00G\02\00\00", ptr %xx, align 1
%15 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 0
%16 = load i8, ptr %15, align 1
%zext10 = zext i8 %16 to i32
%lshrl = lshr i32 %zext10, 5
%17 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 1
%18 = load i8, i8* %17, align 1
%17 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 1
%18 = load i8, ptr %17, align 1
%zext11 = zext i8 %18 to i32
%shl12 = shl i32 %zext11, 3
%19 = or i32 %shl12, %lshrl
%20 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 2
%21 = load i8, i8* %20, align 1
%20 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 2
%21 = load i8, ptr %20, align 1
%zext13 = zext i8 %21 to i32
%shl14 = shl i32 %zext13, 11
%22 = or i32 %shl14, %19
%23 = and i32 262143, %22
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0), i32 %23)
call void (ptr, ...) @printf(ptr @.str.6, i32 %23)
ret void
}

48
test/test_suite/bitstruct/bitstruct_access_signed.c3t
View File

@@ -34,58 +34,58 @@ define void @foo_main() #0 {
entry:
%xx = alloca [3 x i8], align 1
%xxu = alloca [3 x i8], align 1
store [3 x i8] c"\E0\FD\7F", [3 x i8]* %xx, align 1
%0 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
%1 = load i8, i8* %0, align 1
store [3 x i8] c"\E0\FD\7F", ptr %xx, align 1
%0 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
%1 = load i8, ptr %0, align 1
%zext = zext i8 %1 to i32
%lshrl = lshr i32 %zext, 5
%2 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
%3 = load i8, i8* %2, align 1
%2 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
%3 = load i8, ptr %2, align 1
%zext1 = zext i8 %3 to i32
%shl = shl i32 %zext1, 3
%4 = or i32 %shl, %lshrl
%5 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
%6 = load i8, i8* %5, align 1
%5 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
%6 = load i8, ptr %5, align 1
%zext2 = zext i8 %6 to i32
%shl3 = shl i32 %zext2, 11
%7 = or i32 %shl3, %4
%shl4 = shl i32 %7, 14
%ashr = ashr i32 %shl4, 14
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
store [3 x i8] c"\FF\FD\FF", [3 x i8]* %xx, align 1
%8 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
%9 = load i8, i8* %8, align 1
call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
store [3 x i8] c"\FF\FD\FF", ptr %xx, align 1
%8 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
%9 = load i8, ptr %8, align 1
%zext5 = zext i8 %9 to i32
%lshrl6 = lshr i32 %zext5, 5
%10 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
%11 = load i8, i8* %10, align 1
%10 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
%11 = load i8, ptr %10, align 1
%zext7 = zext i8 %11 to i32
%shl8 = shl i32 %zext7, 3
%12 = or i32 %shl8, %lshrl6
%13 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
%14 = load i8, i8* %13, align 1
%13 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
%14 = load i8, ptr %13, align 1
%zext9 = zext i8 %14 to i32
%shl10 = shl i32 %zext9, 11
%15 = or i32 %shl10, %12
%shl11 = shl i32 %15, 14
%ashr12 = ashr i32 %shl11, 14
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %ashr12)
store [3 x i8] c"\1F\CF\AA", [3 x i8]* %xxu, align 1
%16 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 0
%17 = load i8, i8* %16, align 1
call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr12)
store [3 x i8] c"\1F\CF\AA", ptr %xxu, align 1
%16 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 0
%17 = load i8, ptr %16, align 1
%zext13 = zext i8 %17 to i32
%lshrl14 = lshr i32 %zext13, 5
%18 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 1
%19 = load i8, i8* %18, align 1
%18 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 1
%19 = load i8, ptr %18, align 1
%zext15 = zext i8 %19 to i32
%shl16 = shl i32 %zext15, 3
%20 = or i32 %shl16, %lshrl14
%21 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 2
%22 = load i8, i8* %21, align 1
%21 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 2
%22 = load i8, ptr %21, align 1
%zext17 = zext i8 %22 to i32
%shl18 = shl i32 %zext17, 11
%23 = or i32 %shl18, %20
%24 = and i32 262143, %23
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %24)
call void (ptr, ...) @printf(ptr @.str.2, i32 %24)
ret void
}

761
test/test_suite/bitstruct/bitstruct_arrays.c3t
View File

File diff suppressed because it is too large Load Diff

156
test/test_suite/bitstruct/bitstruct_arrays_be.c3t
View File

@@ -41,106 +41,104 @@ define void @foo_test3() #0 {
entry:
%xx = alloca [4 x i8], align 1
%xy = alloca [4 x i8], align 1
%abc = alloca i8*, align 8
%z = alloca [4 x i8]*, align 8
store [4 x i8] c"\E0\FB\0A\00", [4 x i8]* %xx, align 1
%0 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
%1 = load i8, i8* %0, align 1
%abc = alloca ptr, align 8
%z = alloca ptr, align 8
store [4 x i8] c"\E0\FB\0A\00", ptr %xx, align 1
%0 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
%1 = load i8, ptr %0, align 1
%zext = zext i8 %1 to i32
%lshrl = lshr i32 %zext, 4
%2 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
%3 = load i8, i8* %2, align 1
%2 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
%3 = load i8, ptr %2, align 1
%zext1 = zext i8 %3 to i32
%shl = shl i32 %zext1, 4
%4 = or i32 %shl, %lshrl
%5 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
%6 = load i8, i8* %5, align 1
%5 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
%6 = load i8, ptr %5, align 1
%zext2 = zext i8 %6 to i32
%shl3 = shl i32 %zext2, 12
%7 = or i32 %shl3, %4
%shl4 = shl i32 %7, 16
%8 = call i32 @llvm.bswap.i32(i32 %shl4)
%9 = and i32 65535, %8
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), i32 %9)
store [4 x i8] c"\F0\EA\0B\00", [4 x i8]* %xy, align 1
%ptrptr = bitcast [4 x i8]* %xy to i8*
store i8* %ptrptr, i8** %abc, align 8
%10 = load i8*, i8** %abc, align 8
%ptrptr5 = bitcast i8* %10 to [4 x i8]*
store [4 x i8]* %ptrptr5, [4 x i8]** %z, align 8
%11 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
%12 = load i8, i8* %11, align 1
%zext6 = zext i8 %12 to i32
%lshrl7 = lshr i32 %zext6, 4
%13 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
%14 = load i8, i8* %13, align 1
%zext8 = zext i8 %14 to i32
%shl9 = shl i32 %zext8, 4
%15 = or i32 %shl9, %lshrl7
%16 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
%17 = load i8, i8* %16, align 1
%zext10 = zext i8 %17 to i32
%shl11 = shl i32 %zext10, 12
%18 = or i32 %shl11, %15
call void (ptr, ...) @printf(ptr @.str, i32 %9)
store [4 x i8] c"\F0\EA\0B\00", ptr %xy, align 1
store ptr %xy, ptr %abc, align 8
%10 = load ptr, ptr %abc, align 8
store ptr %10, ptr %z, align 8
%11 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
%12 = load i8, ptr %11, align 1
%zext5 = zext i8 %12 to i32
%lshrl6 = lshr i32 %zext5, 4
%13 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
%14 = load i8, ptr %13, align 1
%zext7 = zext i8 %14 to i32
%shl8 = shl i32 %zext7, 4
%15 = or i32 %shl8, %lshrl6
%16 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
%17 = load i8, ptr %16, align 1
%zext9 = zext i8 %17 to i32
%shl10 = shl i32 %zext9, 12
%18 = or i32 %shl10, %15
%19 = and i32 65535, %18
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %19)
%20 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
%21 = load i8, i8* %20, align 1
call void (ptr, ...) @printf(ptr @.str.1, i32 %19)
%20 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
%21 = load i8, ptr %20, align 1
%22 = and i8 %21, 15
%23 = or i8 %22, -16
store i8 %23, i8* %20, align 1
%24 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
store i8 -18, i8* %24, align 1
%25 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
%26 = load i8, i8* %25, align 1
store i8 %23, ptr %20, align 1
%24 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
store i8 -18, ptr %24, align 1
%25 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
%26 = load i8, ptr %25, align 1
%27 = and i8 %26, -16
%28 = or i8 %27, 11
store i8 %27, i8* %25, align 1
%29 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
%30 = load i8, i8* %29, align 1
%zext12 = zext i8 %30 to i32
%lshrl13 = lshr i32 %zext12, 4
%31 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
%32 = load i8, i8* %31, align 1
%zext14 = zext i8 %32 to i32
%shl15 = shl i32 %zext14, 4
%33 = or i32 %shl15, %lshrl13
%34 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
%35 = load i8, i8* %34, align 1
%zext16 = zext i8 %35 to i32
%shl17 = shl i32 %zext16, 12
%36 = or i32 %shl17, %33
store i8 %27, ptr %25, align 1
%29 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
%30 = load i8, ptr %29, align 1
%zext11 = zext i8 %30 to i32
%lshrl12 = lshr i32 %zext11, 4
%31 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
%32 = load i8, ptr %31, align 1
%zext13 = zext i8 %32 to i32
%shl14 = shl i32 %zext13, 4
%33 = or i32 %shl14, %lshrl12
%34 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
%35 = load i8, ptr %34, align 1
%zext15 = zext i8 %35 to i32
%shl16 = shl i32 %zext15, 12
%36 = or i32 %shl16, %33
%37 = and i32 65535, %36
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), i32 %37)
%38 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
%39 = load i8, i8* %38, align 1
call void (ptr, ...) @printf(ptr @.str.2, i32 %37)
%38 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
%39 = load i8, ptr %38, align 1
%40 = and i8 %39, 15
%41 = or i8 %40, -32
store i8 %41, i8* %38, align 1
%42 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
store i8 -5, i8* %42, align 1
%43 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
%44 = load i8, i8* %43, align 1
store i8 %41, ptr %38, align 1
%42 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
store i8 -5, ptr %42, align 1
%43 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
%44 = load i8, ptr %43, align 1
%45 = and i8 %44, -16
%46 = or i8 %45, 14
store i8 %45, i8* %43, align 1
%47 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
%48 = load i8, i8* %47, align 1
%zext18 = zext i8 %48 to i32
%lshrl19 = lshr i32 %zext18, 4
%49 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
%50 = load i8, i8* %49, align 1
%zext20 = zext i8 %50 to i32
%shl21 = shl i32 %zext20, 4
%51 = or i32 %shl21, %lshrl19
%52 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
%53 = load i8, i8* %52, align 1
%zext22 = zext i8 %53 to i32
%shl23 = shl i32 %zext22, 12
%54 = or i32 %shl23, %51
%shl24 = shl i32 %54, 16
%55 = call i32 @llvm.bswap.i32(i32 %shl24)
store i8 %45, ptr %43, align 1
%47 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
%48 = load i8, ptr %47, align 1
%zext17 = zext i8 %48 to i32
%lshrl18 = lshr i32 %zext17, 4
%49 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
%50 = load i8, ptr %49, align 1
%zext19 = zext i8 %50 to i32
%shl20 = shl i32 %zext19, 4
%51 = or i32 %shl20, %lshrl18
%52 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
%53 = load i8, ptr %52, align 1
%zext21 = zext i8 %53 to i32
%shl22 = shl i32 %zext21, 12
%54 = or i32 %shl22, %51
%shl23 = shl i32 %54, 16
%55 = call i32 @llvm.bswap.i32(i32 %shl23)
%56 = and i32 65535, %55
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i32 %56)
call void (ptr, ...) @printf(ptr @.str.3, i32 %56)
ret void
}

404
test/test_suite/bitstruct/bitstruct_be.c3t
View File

@@ -28,10 +28,10 @@ fn void main()
io::println("");
foreach (d : z) io::printf(" %x", d);
io::println("");
io::printfln("abc.a = %x", abc.a);
io::printfn("abc.a = %x", abc.a);
abc.a = 0x1234;
abc.b = 0x5678;
io::printfln("->abc.a = %x", abc.a);
io::printfn("->abc.a = %x", abc.a);
foreach (d : z) io::printf(" %x", d);
io::println("");
@@ -43,273 +43,203 @@ fn void main()
/* #expect: test.ll
%0 = load i32, i32* %x, align 4
%0 = load i32, ptr %x, align 4
%1 = call i32 @llvm.bswap.i32(i32 %0)
store i32 2063597568, i32* %x, align 4
%2 = bitcast i32* %x to i8*
%3 = insertvalue %variant undef, i8* %2, 0
%4 = insertvalue %variant %3, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%5 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 0
store %variant %4, %variant* %5, align 16
%6 = load i32, i32* %x, align 4
%7 = call i32 @llvm.bswap.i32(i32 %6)
store i32 %7, i32* %taddr, align 4
%8 = bitcast i32* %taddr to i8*
%9 = insertvalue %variant undef, i8* %8, 0
%10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%11 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots, i64 0, i64 1
store %variant %10, %variant* %11, align 16
%12 = bitcast [2 x %variant]* %varargslots to %variant*
%13 = insertvalue %"variant[]" undef, %variant* %12, 0
%14 = insertvalue %"variant[]" %13, i64 2, 1
store %"variant[]" %14, %"variant[]"* %taddr1, align 8
%15 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }*
%16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 0
%lo = load i8*, i8** %16, align 8
%17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %15, i32 0, i32 1
%hi = load i64, i64* %17, align 8
%18 = call i64 @std_io_printf(i64* %retparam, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i64 18, i8* %lo, i64 %hi)
%not_err = icmp eq i64 %18, 0
store i32 2063597568, ptr %x, align 4
%2 = insertvalue %variant undef, ptr %x, 0
%3 = insertvalue %variant %2, i64 ptrtoint (ptr @"ct$int" to i64), 1
%4 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %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 %variant undef, ptr %taddr, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
%9 = getelementptr inbounds [2 x %variant], ptr %varargslots, i64 0, i64 1
store %variant %8, ptr %9, align 16
%10 = call i64 @std_io_printf(ptr %retparam, ptr @.str, i64 18, ptr %varargslots, i64 2)
%not_err = icmp eq i64 %10, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
store i32 873625686, i32* %abc, align 4
store [4 x i8] c"\124Vx", [4 x i8]* %abc2, align 1
%ptrptr = bitcast i32* %abc to [4 x i8]*
store [4 x i8]* %ptrptr, [4 x i8]** %z, align 8
store [4 x i8]* %abc2, [4 x i8]** %z2, align 8
%19 = load [4 x i8]*, [4 x i8]** %z2, align 8
store [4 x i8]* %19, [4 x i8]** %.anon, align 8
store i64 0, i64* %.anon2, align 8
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 = %voiderr10, %voiderr
%20 = load i64, i64* %.anon2, align 8
%gt = icmp ugt i64 4, %20
loop.cond: ; preds = %voiderr6, %voiderr
%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
%21 = load [4 x i8]*, [4 x i8]** %.anon, align 8
%22 = load i64, i64* %.anon2, align 8
%23 = getelementptr inbounds [4 x i8], [4 x i8]* %21, i64 0, i64 %22
%24 = load i8, i8* %23, align 1
store i8 %24, i8* %d, align 1
%25 = insertvalue %variant undef, i8* %d, 0
%26 = insertvalue %variant %25, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
%27 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots4, i64 0, i64 0
store %variant %26, %variant* %27, align 16
%28 = bitcast [1 x %variant]* %varargslots4 to %variant*
%29 = insertvalue %"variant[]" undef, %variant* %28, 0
%30 = insertvalue %"variant[]" %29, i64 1, 1
store %"variant[]" %30, %"variant[]"* %taddr5, align 8
%31 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }*
%32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0
%lo6 = load i8*, i8** %32, align 8
%33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1
%hi7 = load i64, i64* %33, align 8
%34 = call i64 @std_io_printf(i64* %retparam3, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i64 3, i8* %lo6, i64 %hi7)
%not_err8 = icmp eq i64 %34, 0
br i1 %not_err8, label %after_check9, label %voiderr10
%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 %variant undef, ptr %d, 0
%18 = insertvalue %variant %17, i64 ptrtoint (ptr @"ct$char" to i64), 1
%19 = getelementptr inbounds [1 x %variant], ptr %varargslots3, i64 0, i64 0
store %variant %18, ptr %19, align 16
%20 = call i64 @std_io_printf(ptr %retparam2, ptr @.str.1, i64 3, ptr %varargslots3, i64 1)
%not_err4 = icmp eq i64 %20, 0
br i1 %not_err4, label %after_check5, label %voiderr6
after_check9: ; preds = %loop.body
br label %voiderr10
after_check5: ; preds = %loop.body
br label %voiderr6
voiderr10: ; preds = %after_check9, %loop.body
%35 = load i64, i64* %.anon2, align 8
%add = add i64 %35, 1
store i64 %add, i64* %.anon2, align 8
voiderr6: ; preds = %after_check5, %loop.body
%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
%36 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i32 0, i32 0)) #2
%37 = load [4 x i8]*, [4 x i8]** %z, align 8
store [4 x i8]* %37, [4 x i8]** %.anon11, align 8
store i64 0, i64* %.anon12, align 8
br label %loop.cond13
%22 = call i32 @std_io_println(ptr @.str.2) #2
%23 = load ptr, ptr %z, align 8
store ptr %23, ptr %.anon7, align 8
store i64 0, ptr %.anon8, align 8
br label %loop.cond9
loop.cond13: ; preds = %voiderr24, %loop.exit
%38 = load i64, i64* %.anon12, align 8
%gt14 = icmp ugt i64 4, %38
br i1 %gt14, label %loop.body15, label %loop.exit26
loop.cond9: ; preds = %voiderr17, %loop.exit
%24 = load i64, ptr %.anon8, align 8
%gt10 = icmp ugt i64 4, %24
br i1 %gt10, label %loop.body11, label %loop.exit19
loop.body15: ; preds = %loop.cond13
%39 = load [4 x i8]*, [4 x i8]** %.anon11, align 8
%40 = load i64, i64* %.anon12, align 8
%41 = getelementptr inbounds [4 x i8], [4 x i8]* %39, i64 0, i64 %40
%42 = load i8, i8* %41, align 1
store i8 %42, i8* %d16, align 1
%43 = insertvalue %variant undef, i8* %d16, 0
%44 = insertvalue %variant %43, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
%45 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots18, i64 0, i64 0
store %variant %44, %variant* %45, align 16
%46 = bitcast [1 x %variant]* %varargslots18 to %variant*
%47 = insertvalue %"variant[]" undef, %variant* %46, 0
%48 = insertvalue %"variant[]" %47, i64 1, 1
store %"variant[]" %48, %"variant[]"* %taddr19, align 8
%49 = bitcast %"variant[]"* %taddr19 to { i8*, i64 }*
%50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 0
%lo20 = load i8*, i8** %50, align 8
%51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 1
%hi21 = load i64, i64* %51, align 8
%52 = call i64 @std_io_printf(i64* %retparam17, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i64 3, i8* %lo20, i64 %hi21)
%not_err22 = icmp eq i64 %52, 0
br i1 %not_err22, label %after_check23, label %voiderr24
loop.body11: ; preds = %loop.cond9
%25 = load ptr, ptr %.anon7, align 8
%26 = load i64, ptr %.anon8, align 8
%27 = getelementptr inbounds [4 x i8], ptr %25, i64 0, i64 %26
%28 = load i8, ptr %27, align 1
store i8 %28, ptr %d12, align 1
%29 = insertvalue %variant undef, ptr %d12, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1
%31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
store %variant %30, ptr %31, align 16
%32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 3, ptr %varargslots14, i64 1)
%not_err15 = icmp eq i64 %32, 0
br i1 %not_err15, label %after_check16, label %voiderr17
after_check23: ; preds = %loop.body15
br label %voiderr24
after_check16: ; preds = %loop.body11
br label %voiderr17
voiderr24: ; preds = %after_check23, %loop.body15
%53 = load i64, i64* %.anon12, align 8
%add25 = add i64 %53, 1
store i64 %add25, i64* %.anon12, align 8
br label %loop.cond13
voiderr17: ; preds = %after_check16, %loop.body11
%33 = load i64, ptr %.anon8, align 8
%add18 = add i64 %33, 1
store i64 %add18, ptr %.anon8, align 8
br label %loop.cond9
loop.exit26: ; preds = %loop.cond13
%54 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i32 0, i32 0)) #2
%55 = load i32, i32* %abc, align 4
%56 = call i32 @llvm.bswap.i32(i32 %55)
%57 = and i32 65535, %56
%ztrunc = trunc i32 %57 to i16
store i16 %ztrunc, i16* %taddr29, align 2
%58 = bitcast i16* %taddr29 to i8*
%59 = insertvalue %variant undef, i8* %58, 0
%60 = insertvalue %variant %59, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1
%61 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots28, i64 0, i64 0
store %variant %60, %variant* %61, align 16
%62 = bitcast [1 x %variant]* %varargslots28 to %variant*
%63 = insertvalue %"variant[]" undef, %variant* %62, 0
%64 = insertvalue %"variant[]" %63, i64 1, 1
store %"variant[]" %64, %"variant[]"* %taddr30, align 8
%65 = bitcast %"variant[]"* %taddr30 to { i8*, i64 }*
%66 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 0
%lo31 = load i8*, i8** %66, align 8
%67 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %65, i32 0, i32 1
%hi32 = load i64, i64* %67, align 8
%68 = call i64 @std_io_printfln(i64* %retparam27, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i64 10, i8* %lo31, i64 %hi32)
%not_err33 = icmp eq i64 %68, 0
br i1 %not_err33, label %after_check34, label %voiderr35
loop.exit19: ; preds = %loop.cond9
%34 = call i32 @std_io_println(ptr @.str.4) #2
%35 = load i32, ptr %abc, align 4
%36 = call i32 @llvm.bswap.i32(i32 %35)
%37 = and i32 65535, %36
%ztrunc = trunc i32 %37 to i16
store i16 %ztrunc, ptr %taddr22, align 2
%38 = insertvalue %variant undef, ptr %taddr22, 0
%39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
%40 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
store %variant %39, ptr %40, align 16
%41 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.5, i64 10, ptr %varargslots21, i64 1)
%not_err23 = icmp eq i64 %41, 0
br i1 %not_err23, label %after_check24, label %voiderr25
after_check34: ; preds = %loop.exit26
br label %voiderr35
after_check24: ; preds = %loop.exit19
br label %voiderr25
voiderr35: ; preds = %after_check34, %loop.exit26
%69 = load i32, i32* %abc, align 4
%70 = call i32 @llvm.bswap.i32(i32 %69)
%71 = and i32 %70, -65536
%72 = or i32 %71, 4660
%73 = call i32 @llvm.bswap.i32(i32 %72)
store i32 %73, i32* %abc, align 4
%74 = load i32, i32* %abc, align 4
%75 = call i32 @llvm.bswap.i32(i32 %74)
%76 = and i32 %75, 65535
%77 = or i32 %76, 1450704896
%78 = call i32 @llvm.bswap.i32(i32 %77)
store i32 %78, i32* %abc, align 4
%79 = load i32, i32* %abc, align 4
%80 = call i32 @llvm.bswap.i32(i32 %79)
%81 = and i32 65535, %80
%ztrunc38 = trunc i32 %81 to i16
store i16 %ztrunc38, i16* %taddr39, align 2
%82 = bitcast i16* %taddr39 to i8*
%83 = insertvalue %variant undef, i8* %82, 0
%84 = insertvalue %variant %83, i64 ptrtoint (%.introspect* @"ct$ushort" to i64), 1
%85 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots37, i64 0, i64 0
store %variant %84, %variant* %85, align 16
%86 = bitcast [1 x %variant]* %varargslots37 to %variant*
%87 = insertvalue %"variant[]" undef, %variant* %86, 0
%88 = insertvalue %"variant[]" %87, i64 1, 1
store %"variant[]" %88, %"variant[]"* %taddr40, align 8
%89 = bitcast %"variant[]"* %taddr40 to { i8*, i64 }*
%90 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 0
%lo41 = load i8*, i8** %90, align 8
%91 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %89, i32 0, i32 1
%hi42 = load i64, i64* %91, align 8
%92 = call i64 @std_io_printfln(i64* %retparam36, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i64 12, i8* %lo41, i64 %hi42)
%not_err43 = icmp eq i64 %92, 0
br i1 %not_err43, label %after_check44, label %voiderr45
voiderr25: ; preds = %after_check24, %loop.exit19
%42 = load i32, ptr %abc, align 4
%43 = call i32 @llvm.bswap.i32(i32 %42)
%44 = and i32 %43, -65536
%45 = or i32 %44, 4660
%46 = call i32 @llvm.bswap.i32(i32 %45)
store i32 %46, ptr %abc, align 4
%47 = load i32, ptr %abc, align 4
%48 = call i32 @llvm.bswap.i32(i32 %47)
%49 = and i32 %48, 65535
%50 = or i32 %49, 1450704896
%51 = call i32 @llvm.bswap.i32(i32 %50)
store i32 %51, ptr %abc, align 4
%52 = load i32, ptr %abc, align 4
%53 = call i32 @llvm.bswap.i32(i32 %52)
%54 = and i32 65535, %53
%ztrunc28 = trunc i32 %54 to i16
store i16 %ztrunc28, ptr %taddr29, align 2
%55 = insertvalue %variant undef, ptr %taddr29, 0
%56 = insertvalue %variant %55, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
%57 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
store %variant %56, ptr %57, align 16
%58 = call i64 @std_io_printfn(ptr %retparam26, ptr @.str.6, i64 12, ptr %varargslots27, i64 1)
%not_err30 = icmp eq i64 %58, 0
br i1 %not_err30, label %after_check31, label %voiderr32
after_check44: ; preds = %voiderr35
br label %voiderr45
after_check31: ; preds = %voiderr25
br label %voiderr32
voiderr45: ; preds = %after_check44, %voiderr35
%93 = load [4 x i8]*, [4 x i8]** %z, align 8
store [4 x i8]* %93, [4 x i8]** %.anon46, align 8
store i64 0, i64* %.anon47, align 8
br label %loop.cond48
voiderr32: ; preds = %after_check31, %voiderr25
%59 = load ptr, ptr %z, align 8
store ptr %59, ptr %.anon33, align 8
store i64 0, ptr %.anon34, align 8
br label %loop.cond35
loop.cond48: ; preds = %voiderr59, %voiderr45
%94 = load i64, i64* %.anon47, align 8
%gt49 = icmp ugt i64 4, %94
br i1 %gt49, label %loop.body50, label %loop.exit61
loop.cond35: ; preds = %voiderr43, %voiderr32
%60 = load i64, ptr %.anon34, align 8
%gt36 = icmp ugt i64 4, %60
br i1 %gt36, label %loop.body37, label %loop.exit45
loop.body50: ; preds = %loop.cond48
%95 = load [4 x i8]*, [4 x i8]** %.anon46, align 8
%96 = load i64, i64* %.anon47, align 8
%97 = getelementptr inbounds [4 x i8], [4 x i8]* %95, i64 0, i64 %96
%98 = load i8, i8* %97, align 1
store i8 %98, i8* %d51, align 1
%99 = insertvalue %variant undef, i8* %d51, 0
%100 = insertvalue %variant %99, i64 ptrtoint (%.introspect* @"ct$char" to i64), 1
%101 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots53, i64 0, i64 0
store %variant %100, %variant* %101, align 16
%102 = bitcast [1 x %variant]* %varargslots53 to %variant*
%103 = insertvalue %"variant[]" undef, %variant* %102, 0
%104 = insertvalue %"variant[]" %103, i64 1, 1
store %"variant[]" %104, %"variant[]"* %taddr54, align 8
%105 = bitcast %"variant[]"* %taddr54 to { i8*, i64 }*
%106 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 0
%lo55 = load i8*, i8** %106, align 8
%107 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %105, i32 0, i32 1
%hi56 = load i64, i64* %107, align 8
%108 = call i64 @std_io_printf(i64* %retparam52, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i32 0, i32 0), i64 3, i8* %lo55, i64 %hi56)
%not_err57 = icmp eq i64 %108, 0
br i1 %not_err57, label %after_check58, label %voiderr59
loop.body37: ; preds = %loop.cond35
%61 = load ptr, ptr %.anon33, align 8
%62 = load i64, ptr %.anon34, align 8
%63 = getelementptr inbounds [4 x i8], ptr %61, i64 0, i64 %62
%64 = load i8, ptr %63, align 1
store i8 %64, ptr %d38, align 1
%65 = insertvalue %variant undef, ptr %d38, 0
%66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$char" to i64), 1
%67 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
store %variant %66, ptr %67, align 16
%68 = call i64 @std_io_printf(ptr %retparam39, ptr @.str.7, i64 3, ptr %varargslots40, i64 1)
%not_err41 = icmp eq i64 %68, 0
br i1 %not_err41, label %after_check42, label %voiderr43
after_check58: ; preds = %loop.body50
br label %voiderr59
after_check42: ; preds = %loop.body37
br label %voiderr43
voiderr59: ; preds = %after_check58, %loop.body50
%109 = load i64, i64* %.anon47, align 8
%add60 = add i64 %109, 1
store i64 %add60, i64* %.anon47, align 8
br label %loop.cond48
voiderr43: ; preds = %after_check42, %loop.body37
%69 = load i64, ptr %.anon34, align 8
%add44 = add i64 %69, 1
store i64 %add44, ptr %.anon34, align 8
br label %loop.cond35
loop.exit61: ; preds = %loop.cond48
%110 = call i32 @std_io_println(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.8, i32 0, i32 0)) #2
store i32 0, i32* %y, align 4
%111 = load i32, i32* %y, align 4
store i32 123, i32* %y, align 4
%112 = bitcast i32* %y to i8*
%113 = insertvalue %variant undef, i8* %112, 0
%114 = insertvalue %variant %113, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%115 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots63, i64 0, i64 0
store %variant %114, %variant* %115, align 16
%116 = load i32, i32* %y, align 4
store i32 %116, i32* %taddr64, align 4
%117 = bitcast i32* %taddr64 to i8*
%118 = insertvalue %variant undef, i8* %117, 0
%119 = insertvalue %variant %118, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%120 = getelementptr inbounds [2 x %variant], [2 x %variant]* %varargslots63, i64 0, i64 1
store %variant %119, %variant* %120, align 16
%121 = bitcast [2 x %variant]* %varargslots63 to %variant*
%122 = insertvalue %"variant[]" undef, %variant* %121, 0
%123 = insertvalue %"variant[]" %122, i64 2, 1
store %"variant[]" %123, %"variant[]"* %taddr65, align 8
%124 = bitcast %"variant[]"* %taddr65 to { i8*, i64 }*
%125 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %124, i32 0, i32 0
%lo66 = load i8*, i8** %125, align 8
%126 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %124, i32 0, i32 1
%hi67 = load i64, i64* %126, align 8
%127 = call i64 @std_io_printf(i64* %retparam62, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i32 0, i32 0), i64 18, i8* %lo66, i64 %hi67)
%not_err68 = icmp eq i64 %127, 0
br i1 %not_err68, label %after_check69, label %voiderr70
loop.exit45: ; preds = %loop.cond35
%70 = call i32 @std_io_println(ptr @.str.8) #2
store i32 0, ptr %y, align 4
%71 = load i32, ptr %y, align 4
store i32 123, ptr %y, align 4
%72 = insertvalue %variant undef, ptr %y, 0
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$int" to i64), 1
%74 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 0
store %variant %73, ptr %74, align 16
%75 = load i32, ptr %y, align 4
store i32 %75, ptr %taddr48, align 4
%76 = insertvalue %variant undef, ptr %taddr48, 0
%77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$int" to i64), 1
%78 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 1
store %variant %77, ptr %78, align 16
%79 = call i64 @std_io_printf(ptr %retparam46, ptr @.str.9, i64 18, ptr %varargslots47, i64 2)
%not_err49 = icmp eq i64 %79, 0
br i1 %not_err49, label %after_check50, label %voiderr51
after_check69: ; preds = %loop.exit61
br label %voiderr70
after_check50: ; preds = %loop.exit45
br label %voiderr51
voiderr70: ; preds = %after_check69, %loop.exit61
voiderr51: ; preds = %after_check50, %loop.exit45
ret void
}

0
test/test_suite2/bitstruct/bitstruct_init_bool.c3t → test/test_suite/bitstruct/bitstruct_init_bool.c3t
View File

885
test/test_suite/bitstruct/bitstruct_initializer.c3t
View File

@@ -29,15 +29,15 @@ fn void hello(int z)
Abc d = { .b = { 23, 11, true } };
Bar b;
b = { .x = z, .w = z < 100 };
io::printfln("%s %s %s", x.x, x.y, x.w);
io::printfln("%s %s %s", y.b.x, y.b.y, y.b.w);
io::printfln("%s %s %s", b.x, b.y, b.w);
io::printfn("%s %s %s", x.x, x.y, x.w);
io::printfn("%s %s %s", y.b.x, y.b.y, y.b.w);
io::printfn("%s %s %s", b.x, b.y, b.w);
x = { z + 1, 1, z > 100 };
y.b = { 33, 11, true };
b = { z + 1, 1, z > 100 };
io::printfln("%s %s %s", x.x, x.y, x.w);
io::printfln("%s %s %s", y.b.x, y.b.y, y.b.w);
io::printfln("%s %s %s", b.x, b.y, b.w);
io::printfn("%s %s %s", x.x, x.y, x.w);
io::printfn("%s %s %s", y.b.x, y.b.y, y.b.w);
io::printfn("%s %s %s", b.x, b.y, b.w);
}
@@ -59,38 +59,32 @@ entry:
%taddr = alloca i32, align 4
%taddr13 = alloca i32, align 4
%taddr16 = alloca i8, align 1
%taddr17 = alloca %"variant[]", align 8
%retparam18 = alloca i64, align 8
%varargslots19 = alloca [3 x %variant], align 16
%taddr21 = alloca i32, align 4
%taddr24 = alloca i32, align 4
%taddr27 = alloca i8, align 1
%taddr28 = alloca %"variant[]", align 8
%retparam34 = alloca i64, align 8
%varargslots35 = alloca [3 x %variant], align 16
%taddr43 = alloca i32, align 4
%taddr51 = alloca i32, align 4
%taddr53 = alloca i8, align 1
%taddr54 = alloca %"variant[]", align 8
%retparam74 = alloca i64, align 8
%varargslots75 = alloca [3 x %variant], align 16
%taddr77 = alloca i32, align 4
%taddr80 = alloca i32, align 4
%taddr83 = alloca i8, align 1
%taddr84 = alloca %"variant[]", align 8
%retparam90 = alloca i64, align 8
%varargslots91 = alloca [3 x %variant], align 16
%taddr93 = alloca i32, align 4
%taddr96 = alloca i32, align 4
%taddr99 = alloca i8, align 1
%taddr100 = alloca %"variant[]", align 8
%retparam106 = alloca i64, align 8
%varargslots107 = alloca [3 x %variant], align 16
%taddr115 = alloca i32, align 4
%taddr123 = alloca i32, align 4
%taddr125 = alloca i8, align 1
%taddr126 = alloca %"variant[]", align 8
store i64 0, i64* %x, align 8
%retparam17 = alloca i64, align 8
%varargslots18 = alloca [3 x %variant], align 16
%taddr20 = alloca i32, align 4
%taddr23 = alloca i32, align 4
%taddr26 = alloca i8, align 1
%retparam30 = alloca i64, align 8
%varargslots31 = alloca [3 x %variant], align 16
%taddr39 = alloca i32, align 4
%taddr47 = alloca i32, align 4
%taddr49 = alloca i8, align 1
%retparam67 = alloca i64, align 8
%varargslots68 = alloca [3 x %variant], align 16
%taddr70 = alloca i32, align 4
%taddr73 = alloca i32, align 4
%taddr76 = alloca i8, align 1
%retparam80 = alloca i64, align 8
%varargslots81 = alloca [3 x %variant], align 16
%taddr83 = alloca i32, align 4
%taddr86 = alloca i32, align 4
%taddr89 = alloca i8, align 1
%retparam93 = alloca i64, align 8
%varargslots94 = alloca [3 x %variant], align 16
%taddr102 = alloca i32, align 4
%taddr110 = alloca i32, align 4
%taddr112 = alloca i8, align 1
store i64 0, ptr %x, align 8
%zext = zext i32 %0 to i64
%1 = and i64 %zext, 4294967295
%lt = icmp slt i32 %0, 100
@@ -100,470 +94,409 @@ entry:
%3 = and i64 %shl, -9223372036854775808
%4 = and i64 %1, 9223372036854775807
%5 = or i64 %4, %3
store i64 %5, i64* %x, align 8
%6 = bitcast %Abc* %y to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %6, i8* align 8 bitcast (%Abc* @.__const to i8*), i32 16, i1 false)
%7 = bitcast %Abc* %d to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %7, i8* align 8 bitcast (%Abc* @.__const.1 to i8*), i32 16, i1 false)
%8 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
store i8 0, i8* %8, align 1
%9 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
store i8 0, i8* %9, align 1
%10 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
store i8 0, i8* %10, align 1
%11 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
store i8 0, i8* %11, align 1
%12 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
store i8 0, i8* %12, align 1
%13 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
store i8 0, i8* %13, align 1
%14 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
store i8 0, i8* %14, align 1
%15 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
store i8 0, i8* %15, align 1
%16 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
store i8 0, i8* %16, align 1
%17 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
store i8 0, i8* %17, align 1
%18 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
store i8 0, i8* %18, align 1
%19 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
store i8 0, i8* %19, align 1
%20 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
store i8 0, i8* %20, align 1
%21 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
store i8 0, i8* %21, align 1
%22 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
store i8 0, i8* %22, align 1
%23 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
store i8 0, i8* %23, align 1
%24 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
store i64 %5, ptr %x, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %y, ptr align 8 @.__const, i32 16, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %d, ptr align 8 @.__const.1, i32 16, i1 false)
%6 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
store i8 0, ptr %6, align 1
%7 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
store i8 0, ptr %7, align 1
%8 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
store i8 0, ptr %8, align 1
%9 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
store i8 0, ptr %9, align 1
%10 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
store i8 0, ptr %10, align 1
%11 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
store i8 0, ptr %11, align 1
%12 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
store i8 0, ptr %12, align 1
%13 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
store i8 0, ptr %13, align 1
%14 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
store i8 0, ptr %14, align 1
%15 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
store i8 0, ptr %15, align 1
%16 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
store i8 0, ptr %16, align 1
%17 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
store i8 0, ptr %17, align 1
%18 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
store i8 0, ptr %18, align 1
%19 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
store i8 0, ptr %19, align 1
%20 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
store i8 0, ptr %20, align 1
%21 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
store i8 0, ptr %21, align 1
%22 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
%ztrunc = trunc i32 %0 to i8
store i8 %ztrunc, i8* %24, align 1
store i8 %ztrunc, ptr %22, align 1
%lshrl = lshr i32 %0, 8
%25 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
%23 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
%ztrunc2 = trunc i32 %lshrl to i8
store i8 %ztrunc2, i8* %25, align 1
store i8 %ztrunc2, ptr %23, align 1
%lshrl3 = lshr i32 %lshrl, 8
%26 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
%24 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
%ztrunc4 = trunc i32 %lshrl3 to i8
store i8 %ztrunc4, i8* %26, align 1
store i8 %ztrunc4, ptr %24, align 1
%lshrl5 = lshr i32 %lshrl3, 8
%27 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
%25 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
%ztrunc6 = trunc i32 %lshrl5 to i8
store i8 %ztrunc6, i8* %27, align 1
store i8 %ztrunc6, ptr %25, align 1
%lshrl7 = lshr i32 %lshrl5, 8
%lt8 = icmp slt i32 %0, 100
%28 = zext i1 %lt8 to i8
%shl9 = shl i8 %28, 7
%29 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%30 = load i8, i8* %29, align 1
%31 = and i8 %30, 127
%32 = or i8 %31, %shl9
store i8 %32, i8* %29, align 1
%33 = load i64, i64* %x, align 8
%34 = and i64 4294967295, %33
%ztrunc10 = trunc i64 %34 to i32
store i32 %ztrunc10, i32* %taddr, align 4
%35 = bitcast i32* %taddr to i8*
%36 = insertvalue %variant undef, i8* %35, 0
%37 = insertvalue %variant %36, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%38 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 0
store %variant %37, %variant* %38, align 16
%39 = load i64, i64* %x, align 8
%lshrl11 = lshr i64 %39, 32
%40 = and i64 2147483647, %lshrl11
%ztrunc12 = trunc i64 %40 to i32
store i32 %ztrunc12, i32* %taddr13, align 4
%41 = bitcast i32* %taddr13 to i8*
%42 = insertvalue %variant undef, i8* %41, 0
%43 = insertvalue %variant %42, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%44 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 1
store %variant %43, %variant* %44, align 16
%45 = load i64, i64* %x, align 8
%lshrl14 = lshr i64 %45, 63
%46 = and i64 1, %lshrl14
%ztrunc15 = trunc i64 %46 to i8
store i8 %ztrunc15, i8* %taddr16, align 1
%47 = insertvalue %variant undef, i8* %taddr16, 0
%48 = insertvalue %variant %47, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
%49 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots, i64 0, i64 2
store %variant %48, %variant* %49, align 16
%50 = bitcast [3 x %variant]* %varargslots to %variant*
%51 = insertvalue %"variant[]" undef, %variant* %50, 0
%52 = insertvalue %"variant[]" %51, i64 3, 1
store %"variant[]" %52, %"variant[]"* %taddr17, align 8
%53 = bitcast %"variant[]"* %taddr17 to { i8*, i64 }*
%54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 0
%lo = load i8*, i8** %54, align 8
%55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %53, i32 0, i32 1
%hi = load i64, i64* %55, align 8
%56 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i64 8, i8* %lo, i64 %hi)
%not_err = icmp eq i64 %56, 0
%26 = zext i1 %lt8 to i8
%shl9 = shl i8 %26, 7
%27 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%28 = load i8, ptr %27, align 1
%29 = and i8 %28, 127
%30 = or i8 %29, %shl9
store i8 %30, ptr %27, align 1
%31 = load i64, ptr %x, align 8
%32 = and i64 4294967295, %31
%ztrunc10 = trunc i64 %32 to i32
store i32 %ztrunc10, ptr %taddr, align 4
%33 = insertvalue %variant undef, ptr %taddr, 0
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%35 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %34, ptr %35, align 16
%36 = load i64, ptr %x, align 8
%lshrl11 = lshr i64 %36, 32
%37 = and i64 2147483647, %lshrl11
%ztrunc12 = trunc i64 %37 to i32
store i32 %ztrunc12, ptr %taddr13, align 4
%38 = insertvalue %variant undef, ptr %taddr13, 0
%39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%40 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1
store %variant %39, ptr %40, align 16
%41 = load i64, ptr %x, align 8
%lshrl14 = lshr i64 %41, 63
%42 = and i64 1, %lshrl14
%ztrunc15 = trunc i64 %42 to i8
store i8 %ztrunc15, ptr %taddr16, align 1
%43 = insertvalue %variant undef, ptr %taddr16, 0
%44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$bool" to i64), 1
%45 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
store %variant %44, ptr %45, align 16
%46 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
%not_err = icmp eq i64 %46, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
%57 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
%58 = load i64, i64* %57, align 8
%59 = and i64 4294967295, %58
%ztrunc20 = trunc i64 %59 to i32
store i32 %ztrunc20, i32* %taddr21, align 4
%60 = bitcast i32* %taddr21 to i8*
%61 = insertvalue %variant undef, i8* %60, 0
%62 = insertvalue %variant %61, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%63 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 0
store %variant %62, %variant* %63, align 16
%64 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
%65 = load i64, i64* %64, align 8
%lshrl22 = lshr i64 %65, 32
%66 = and i64 2147483647, %lshrl22
%ztrunc23 = trunc i64 %66 to i32
store i32 %ztrunc23, i32* %taddr24, align 4
%67 = bitcast i32* %taddr24 to i8*
%68 = insertvalue %variant undef, i8* %67, 0
%69 = insertvalue %variant %68, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%70 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 1
store %variant %69, %variant* %70, align 16
%71 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
%72 = load i64, i64* %71, align 8
%lshrl25 = lshr i64 %72, 63
%73 = and i64 1, %lshrl25
%ztrunc26 = trunc i64 %73 to i8
store i8 %ztrunc26, i8* %taddr27, align 1
%74 = insertvalue %variant undef, i8* %taddr27, 0
%75 = insertvalue %variant %74, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
%76 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots19, i64 0, i64 2
store %variant %75, %variant* %76, align 16
%77 = bitcast [3 x %variant]* %varargslots19 to %variant*
%78 = insertvalue %"variant[]" undef, %variant* %77, 0
%79 = insertvalue %"variant[]" %78, i64 3, 1
store %"variant[]" %79, %"variant[]"* %taddr28, align 8
%80 = bitcast %"variant[]"* %taddr28 to { i8*, i64 }*
%81 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 0
%lo29 = load i8*, i8** %81, align 8
%82 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %80, i32 0, i32 1
%hi30 = load i64, i64* %82, align 8
%83 = call i64 @std_io_printfln(i64* %retparam18, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i32 0, i32 0), i64 8, i8* %lo29, i64 %hi30)
%not_err31 = icmp eq i64 %83, 0
br i1 %not_err31, label %after_check32, label %voiderr33
%47 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
%48 = load i64, ptr %47, align 8
%49 = and i64 4294967295, %48
%ztrunc19 = trunc i64 %49 to i32
store i32 %ztrunc19, ptr %taddr20, align 4
%50 = insertvalue %variant undef, ptr %taddr20, 0
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%52 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 0
store %variant %51, ptr %52, align 16
%53 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
%54 = load i64, ptr %53, align 8
%lshrl21 = lshr i64 %54, 32
%55 = and i64 2147483647, %lshrl21
%ztrunc22 = trunc i64 %55 to i32
store i32 %ztrunc22, ptr %taddr23, align 4
%56 = insertvalue %variant undef, ptr %taddr23, 0
%57 = insertvalue %variant %56, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%58 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 1
store %variant %57, ptr %58, align 16
%59 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
%60 = load i64, ptr %59, align 8
%lshrl24 = lshr i64 %60, 63
%61 = and i64 1, %lshrl24
%ztrunc25 = trunc i64 %61 to i8
store i8 %ztrunc25, ptr %taddr26, align 1
%62 = insertvalue %variant undef, ptr %taddr26, 0
%63 = insertvalue %variant %62, i64 ptrtoint (ptr @"ct$bool" to i64), 1
%64 = getelementptr inbounds [3 x %variant], ptr %varargslots18, i64 0, i64 2
store %variant %63, ptr %64, align 16
%65 = call i64 @std_io_printfn(ptr %retparam17, ptr @.str.2, i64 8, ptr %varargslots18, i64 3)
%not_err27 = icmp eq i64 %65, 0
br i1 %not_err27, label %after_check28, label %voiderr29
after_check32: ; preds = %voiderr
br label %voiderr33
after_check28: ; preds = %voiderr
br label %voiderr29
voiderr33: ; preds = %after_check32, %voiderr
%84 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
%85 = load i8, i8* %84, align 1
%zext36 = zext i8 %85 to i32
%86 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
%87 = load i8, i8* %86, align 1
%zext37 = zext i8 %87 to i32
%shl38 = shl i32 %zext37, 8
%88 = or i32 %shl38, %zext36
%89 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
%90 = load i8, i8* %89, align 1
%zext39 = zext i8 %90 to i32
%shl40 = shl i32 %zext39, 16
%91 = or i32 %shl40, %88
%92 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
%93 = load i8, i8* %92, align 1
%zext41 = zext i8 %93 to i32
%shl42 = shl i32 %zext41, 24
%94 = or i32 %shl42, %91
store i32 %94, i32* %taddr43, align 4
%95 = bitcast i32* %taddr43 to i8*
%96 = insertvalue %variant undef, i8* %95, 0
%97 = insertvalue %variant %96, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%98 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 0
store %variant %97, %variant* %98, align 16
%99 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
%100 = load i8, i8* %99, align 1
%zext44 = zext i8 %100 to i32
%101 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
%102 = load i8, i8* %101, align 1
%zext45 = zext i8 %102 to i32
%shl46 = shl i32 %zext45, 8
%103 = or i32 %shl46, %zext44
%104 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
%105 = load i8, i8* %104, align 1
%zext47 = zext i8 %105 to i32
%shl48 = shl i32 %zext47, 16
%106 = or i32 %shl48, %103
%107 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%108 = load i8, i8* %107, align 1
%zext49 = zext i8 %108 to i32
%shl50 = shl i32 %zext49, 24
%109 = or i32 %shl50, %106
%110 = and i32 2147483647, %109
store i32 %110, i32* %taddr51, align 4
%111 = bitcast i32* %taddr51 to i8*
%112 = insertvalue %variant undef, i8* %111, 0
%113 = insertvalue %variant %112, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%114 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 1
store %variant %113, %variant* %114, align 16
%115 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%116 = load i8, i8* %115, align 1
%lshrl52 = lshr i8 %116, 7
%117 = trunc i8 %lshrl52 to i1
%118 = zext i1 %117 to i8
store i8 %118, i8* %taddr53, align 1
%119 = insertvalue %variant undef, i8* %taddr53, 0
%120 = insertvalue %variant %119, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
%121 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots35, i64 0, i64 2
store %variant %120, %variant* %121, align 16
%122 = bitcast [3 x %variant]* %varargslots35 to %variant*
%123 = insertvalue %"variant[]" undef, %variant* %122, 0
%124 = insertvalue %"variant[]" %123, i64 3, 1
store %"variant[]" %124, %"variant[]"* %taddr54, align 8
%125 = bitcast %"variant[]"* %taddr54 to { i8*, i64 }*
%126 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %125, i32 0, i32 0
%lo55 = load i8*, i8** %126, align 8
%127 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %125, i32 0, i32 1
%hi56 = load i64, i64* %127, align 8
%128 = call i64 @std_io_printfln(i64* %retparam34, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0), i64 8, i8* %lo55, i64 %hi56)
%not_err57 = icmp eq i64 %128, 0
br i1 %not_err57, label %after_check58, label %voiderr59
voiderr29: ; preds = %after_check28, %voiderr
%66 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
%67 = load i8, ptr %66, align 1
%zext32 = zext i8 %67 to i32
%68 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
%69 = load i8, ptr %68, align 1
%zext33 = zext i8 %69 to i32
%shl34 = shl i32 %zext33, 8
%70 = or i32 %shl34, %zext32
%71 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
%72 = load i8, ptr %71, align 1
%zext35 = zext i8 %72 to i32
%shl36 = shl i32 %zext35, 16
%73 = or i32 %shl36, %70
%74 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
%75 = load i8, ptr %74, align 1
%zext37 = zext i8 %75 to i32
%shl38 = shl i32 %zext37, 24
%76 = or i32 %shl38, %73
store i32 %76, ptr %taddr39, align 4
%77 = insertvalue %variant undef, ptr %taddr39, 0
%78 = insertvalue %variant %77, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%79 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 0
store %variant %78, ptr %79, align 16
%80 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
%81 = load i8, ptr %80, align 1
%zext40 = zext i8 %81 to i32
%82 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
%83 = load i8, ptr %82, align 1
%zext41 = zext i8 %83 to i32
%shl42 = shl i32 %zext41, 8
%84 = or i32 %shl42, %zext40
%85 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
%86 = load i8, ptr %85, align 1
%zext43 = zext i8 %86 to i32
%shl44 = shl i32 %zext43, 16
%87 = or i32 %shl44, %84
%88 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%89 = load i8, ptr %88, align 1
%zext45 = zext i8 %89 to i32
%shl46 = shl i32 %zext45, 24
%90 = or i32 %shl46, %87
%91 = and i32 2147483647, %90
store i32 %91, ptr %taddr47, align 4
%92 = insertvalue %variant undef, ptr %taddr47, 0
%93 = insertvalue %variant %92, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%94 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 1
store %variant %93, ptr %94, align 16
%95 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%96 = load i8, ptr %95, align 1
%lshrl48 = lshr i8 %96, 7
%97 = trunc i8 %lshrl48 to i1
%98 = zext i1 %97 to i8
store i8 %98, ptr %taddr49, align 1
%99 = insertvalue %variant undef, ptr %taddr49, 0
%100 = insertvalue %variant %99, i64 ptrtoint (ptr @"ct$bool" to i64), 1
%101 = getelementptr inbounds [3 x %variant], ptr %varargslots31, i64 0, i64 2
store %variant %100, ptr %101, align 16
%102 = call i64 @std_io_printfn(ptr %retparam30, ptr @.str.3, i64 8, ptr %varargslots31, i64 3)
%not_err50 = icmp eq i64 %102, 0
br i1 %not_err50, label %after_check51, label %voiderr52
after_check58: ; preds = %voiderr33
br label %voiderr59
after_check51: ; preds = %voiderr29
br label %voiderr52
voiderr59: ; preds = %after_check58, %voiderr33
voiderr52: ; preds = %after_check51, %voiderr29
%add = add i32 %0, 1
%zext60 = zext i32 %add to i64
%129 = and i64 %zext60, 4294967295
%130 = and i64 %129, -9223372032559808513
%131 = or i64 %130, 4294967296
%zext53 = zext i32 %add to i64
%103 = and i64 %zext53, 4294967295
%104 = and i64 %103, -9223372032559808513
%105 = or i64 %104, 4294967296
%gt = icmp sgt i32 %0, 100
%132 = zext i1 %gt to i8
%zext61 = zext i8 %132 to i64
%shl62 = shl i64 %zext61, 63
%133 = and i64 %shl62, -9223372036854775808
%134 = and i64 %131, 9223372036854775807
%135 = or i64 %134, %133
store i64 %135, i64* %x, align 8
%136 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
store i64 -9223371989610135519, i64* %136, align 8
%137 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
store i8 0, i8* %137, align 1
%138 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
store i8 0, i8* %138, align 1
%139 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
store i8 0, i8* %139, align 1
%140 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
store i8 0, i8* %140, align 1
%141 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
store i8 0, i8* %141, align 1
%142 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
store i8 0, i8* %142, align 1
%143 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
store i8 0, i8* %143, align 1
%144 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
store i8 0, i8* %144, align 1
%add63 = add i32 %0, 1
%145 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
%ztrunc64 = trunc i32 %add63 to i8
store i8 %ztrunc64, i8* %145, align 1
%lshrl65 = lshr i32 %add63, 8
%146 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
%ztrunc66 = trunc i32 %lshrl65 to i8
store i8 %ztrunc66, i8* %146, align 1
%lshrl67 = lshr i32 %lshrl65, 8
%147 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
%ztrunc68 = trunc i32 %lshrl67 to i8
store i8 %ztrunc68, i8* %147, align 1
%lshrl69 = lshr i32 %lshrl67, 8
%148 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
%ztrunc70 = trunc i32 %lshrl69 to i8
store i8 %ztrunc70, i8* %148, align 1
%lshrl71 = lshr i32 %lshrl69, 8
%149 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
store i8 1, i8* %149, align 1
%150 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
store i8 0, i8* %150, align 1
%151 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
store i8 0, i8* %151, align 1
%152 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%153 = load i8, i8* %152, align 1
%154 = and i8 %153, -128
store i8 %154, i8* %152, align 1
%gt72 = icmp sgt i32 %0, 100
%155 = zext i1 %gt72 to i8
%shl73 = shl i8 %155, 7
%156 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%157 = load i8, i8* %156, align 1
%158 = and i8 %157, 127
%159 = or i8 %158, %shl73
store i8 %159, i8* %156, align 1
%160 = load i64, i64* %x, align 8
%161 = and i64 4294967295, %160
%ztrunc76 = trunc i64 %161 to i32
store i32 %ztrunc76, i32* %taddr77, align 4
%162 = bitcast i32* %taddr77 to i8*
%163 = insertvalue %variant undef, i8* %162, 0
%164 = insertvalue %variant %163, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%165 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 0
store %variant %164, %variant* %165, align 16
%166 = load i64, i64* %x, align 8
%lshrl78 = lshr i64 %166, 32
%167 = and i64 2147483647, %lshrl78
%ztrunc79 = trunc i64 %167 to i32
store i32 %ztrunc79, i32* %taddr80, align 4
%168 = bitcast i32* %taddr80 to i8*
%169 = insertvalue %variant undef, i8* %168, 0
%170 = insertvalue %variant %169, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%171 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 1
store %variant %170, %variant* %171, align 16
%172 = load i64, i64* %x, align 8
%lshrl81 = lshr i64 %172, 63
%173 = and i64 1, %lshrl81
%ztrunc82 = trunc i64 %173 to i8
store i8 %ztrunc82, i8* %taddr83, align 1
%174 = insertvalue %variant undef, i8* %taddr83, 0
%175 = insertvalue %variant %174, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
%176 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots75, i64 0, i64 2
store %variant %175, %variant* %176, align 16
%177 = bitcast [3 x %variant]* %varargslots75 to %variant*
%178 = insertvalue %"variant[]" undef, %variant* %177, 0
%179 = insertvalue %"variant[]" %178, i64 3, 1
store %"variant[]" %179, %"variant[]"* %taddr84, align 8
%180 = bitcast %"variant[]"* %taddr84 to { i8*, i64 }*
%181 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 0
%lo85 = load i8*, i8** %181, align 8
%182 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %180, i32 0, i32 1
%hi86 = load i64, i64* %182, align 8
%183 = call i64 @std_io_printfln(i64* %retparam74, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i32 0, i32 0), i64 8, i8* %lo85, i64 %hi86)
%not_err87 = icmp eq i64 %183, 0
br i1 %not_err87, label %after_check88, label %voiderr89
%106 = zext i1 %gt to i8
%zext54 = zext i8 %106 to i64
%shl55 = shl i64 %zext54, 63
%107 = and i64 %shl55, -9223372036854775808
%108 = and i64 %105, 9223372036854775807
%109 = or i64 %108, %107
store i64 %109, ptr %x, align 8
%110 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
store i64 -9223371989610135519, ptr %110, align 8
%111 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
store i8 0, ptr %111, align 1
%112 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
store i8 0, ptr %112, align 1
%113 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
store i8 0, ptr %113, align 1
%114 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
store i8 0, ptr %114, align 1
%115 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
store i8 0, ptr %115, align 1
%116 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
store i8 0, ptr %116, align 1
%117 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
store i8 0, ptr %117, align 1
%118 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
store i8 0, ptr %118, align 1
%add56 = add i32 %0, 1
%119 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
%ztrunc57 = trunc i32 %add56 to i8
store i8 %ztrunc57, ptr %119, align 1
%lshrl58 = lshr i32 %add56, 8
%120 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
%ztrunc59 = trunc i32 %lshrl58 to i8
store i8 %ztrunc59, ptr %120, align 1
%lshrl60 = lshr i32 %lshrl58, 8
%121 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
%ztrunc61 = trunc i32 %lshrl60 to i8
store i8 %ztrunc61, ptr %121, align 1
%lshrl62 = lshr i32 %lshrl60, 8
%122 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
%ztrunc63 = trunc i32 %lshrl62 to i8
store i8 %ztrunc63, ptr %122, align 1
%lshrl64 = lshr i32 %lshrl62, 8
%123 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
store i8 1, ptr %123, align 1
%124 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
store i8 0, ptr %124, align 1
%125 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
store i8 0, ptr %125, align 1
%126 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%127 = load i8, ptr %126, align 1
%128 = and i8 %127, -128
store i8 %128, ptr %126, align 1
%gt65 = icmp sgt i32 %0, 100
%129 = zext i1 %gt65 to i8
%shl66 = shl i8 %129, 7
%130 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%131 = load i8, ptr %130, align 1
%132 = and i8 %131, 127
%133 = or i8 %132, %shl66
store i8 %133, ptr %130, align 1
%134 = load i64, ptr %x, align 8
%135 = and i64 4294967295, %134
%ztrunc69 = trunc i64 %135 to i32
store i32 %ztrunc69, ptr %taddr70, align 4
%136 = insertvalue %variant undef, ptr %taddr70, 0
%137 = insertvalue %variant %136, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%138 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 0
store %variant %137, ptr %138, align 16
%139 = load i64, ptr %x, align 8
%lshrl71 = lshr i64 %139, 32
%140 = and i64 2147483647, %lshrl71
%ztrunc72 = trunc i64 %140 to i32
store i32 %ztrunc72, ptr %taddr73, align 4
%141 = insertvalue %variant undef, ptr %taddr73, 0
%142 = insertvalue %variant %141, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%143 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 1
store %variant %142, ptr %143, align 16
%144 = load i64, ptr %x, align 8
%lshrl74 = lshr i64 %144, 63
%145 = and i64 1, %lshrl74
%ztrunc75 = trunc i64 %145 to i8
store i8 %ztrunc75, ptr %taddr76, align 1
%146 = insertvalue %variant undef, ptr %taddr76, 0
%147 = insertvalue %variant %146, i64 ptrtoint (ptr @"ct$bool" to i64), 1
%148 = getelementptr inbounds [3 x %variant], ptr %varargslots68, i64 0, i64 2
store %variant %147, ptr %148, align 16
%149 = call i64 @std_io_printfn(ptr %retparam67, ptr @.str.4, i64 8, ptr %varargslots68, i64 3)
%not_err77 = icmp eq i64 %149, 0
br i1 %not_err77, label %after_check78, label %voiderr79
after_check88: ; preds = %voiderr59
br label %voiderr89
after_check78: ; preds = %voiderr52
br label %voiderr79
voiderr89: ; preds = %after_check88, %voiderr59
%184 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
%185 = load i64, i64* %184, align 8
%186 = and i64 4294967295, %185
%ztrunc92 = trunc i64 %186 to i32
store i32 %ztrunc92, i32* %taddr93, align 4
%187 = bitcast i32* %taddr93 to i8*
%188 = insertvalue %variant undef, i8* %187, 0
%189 = insertvalue %variant %188, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%190 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 0
store %variant %189, %variant* %190, align 16
%191 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
%192 = load i64, i64* %191, align 8
%lshrl94 = lshr i64 %192, 32
%193 = and i64 2147483647, %lshrl94
%ztrunc95 = trunc i64 %193 to i32
store i32 %ztrunc95, i32* %taddr96, align 4
%194 = bitcast i32* %taddr96 to i8*
%195 = insertvalue %variant undef, i8* %194, 0
%196 = insertvalue %variant %195, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%197 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 1
store %variant %196, %variant* %197, align 16
%198 = getelementptr inbounds %Abc, %Abc* %y, i32 0, i32 1
%199 = load i64, i64* %198, align 8
%lshrl97 = lshr i64 %199, 63
%200 = and i64 1, %lshrl97
%ztrunc98 = trunc i64 %200 to i8
store i8 %ztrunc98, i8* %taddr99, align 1
%201 = insertvalue %variant undef, i8* %taddr99, 0
%202 = insertvalue %variant %201, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
%203 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots91, i64 0, i64 2
store %variant %202, %variant* %203, align 16
%204 = bitcast [3 x %variant]* %varargslots91 to %variant*
%205 = insertvalue %"variant[]" undef, %variant* %204, 0
%206 = insertvalue %"variant[]" %205, i64 3, 1
store %"variant[]" %206, %"variant[]"* %taddr100, align 8
%207 = bitcast %"variant[]"* %taddr100 to { i8*, i64 }*
%208 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %207, i32 0, i32 0
%lo101 = load i8*, i8** %208, align 8
%209 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %207, i32 0, i32 1
%hi102 = load i64, i64* %209, align 8
%210 = call i64 @std_io_printfln(i64* %retparam90, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i32 0, i32 0), i64 8, i8* %lo101, i64 %hi102)
%not_err103 = icmp eq i64 %210, 0
br i1 %not_err103, label %after_check104, label %voiderr105
voiderr79: ; preds = %after_check78, %voiderr52
%150 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
%151 = load i64, ptr %150, align 8
%152 = and i64 4294967295, %151
%ztrunc82 = trunc i64 %152 to i32
store i32 %ztrunc82, ptr %taddr83, align 4
%153 = insertvalue %variant undef, ptr %taddr83, 0
%154 = insertvalue %variant %153, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%155 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 0
store %variant %154, ptr %155, align 16
%156 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
%157 = load i64, ptr %156, align 8
%lshrl84 = lshr i64 %157, 32
%158 = and i64 2147483647, %lshrl84
%ztrunc85 = trunc i64 %158 to i32
store i32 %ztrunc85, ptr %taddr86, align 4
%159 = insertvalue %variant undef, ptr %taddr86, 0
%160 = insertvalue %variant %159, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%161 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 1
store %variant %160, ptr %161, align 16
%162 = getelementptr inbounds %Abc, ptr %y, i32 0, i32 1
%163 = load i64, ptr %162, align 8
%lshrl87 = lshr i64 %163, 63
%164 = and i64 1, %lshrl87
%ztrunc88 = trunc i64 %164 to i8
store i8 %ztrunc88, ptr %taddr89, align 1
%165 = insertvalue %variant undef, ptr %taddr89, 0
%166 = insertvalue %variant %165, i64 ptrtoint (ptr @"ct$bool" to i64), 1
%167 = getelementptr inbounds [3 x %variant], ptr %varargslots81, i64 0, i64 2
store %variant %166, ptr %167, align 16
%168 = call i64 @std_io_printfn(ptr %retparam80, ptr @.str.5, i64 8, ptr %varargslots81, i64 3)
%not_err90 = icmp eq i64 %168, 0
br i1 %not_err90, label %after_check91, label %voiderr92
after_check104: ; preds = %voiderr89
br label %voiderr105
after_check91: ; preds = %voiderr79
br label %voiderr92
voiderr105: ; preds = %after_check104, %voiderr89
%211 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 0
%212 = load i8, i8* %211, align 1
%zext108 = zext i8 %212 to i32
%213 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 1
%214 = load i8, i8* %213, align 1
%zext109 = zext i8 %214 to i32
%shl110 = shl i32 %zext109, 8
%215 = or i32 %shl110, %zext108
%216 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 2
%217 = load i8, i8* %216, align 1
%zext111 = zext i8 %217 to i32
%shl112 = shl i32 %zext111, 16
%218 = or i32 %shl112, %215
%219 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 3
%220 = load i8, i8* %219, align 1
%zext113 = zext i8 %220 to i32
%shl114 = shl i32 %zext113, 24
%221 = or i32 %shl114, %218
store i32 %221, i32* %taddr115, align 4
%222 = bitcast i32* %taddr115 to i8*
%223 = insertvalue %variant undef, i8* %222, 0
%224 = insertvalue %variant %223, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%225 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 0
store %variant %224, %variant* %225, align 16
%226 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 4
%227 = load i8, i8* %226, align 1
%zext116 = zext i8 %227 to i32
%228 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 5
%229 = load i8, i8* %228, align 1
%zext117 = zext i8 %229 to i32
%shl118 = shl i32 %zext117, 8
%230 = or i32 %shl118, %zext116
%231 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 6
%232 = load i8, i8* %231, align 1
%zext119 = zext i8 %232 to i32
%shl120 = shl i32 %zext119, 16
%233 = or i32 %shl120, %230
%234 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%235 = load i8, i8* %234, align 1
%zext121 = zext i8 %235 to i32
%shl122 = shl i32 %zext121, 24
%236 = or i32 %shl122, %233
%237 = and i32 2147483647, %236
store i32 %237, i32* %taddr123, align 4
%238 = bitcast i32* %taddr123 to i8*
%239 = insertvalue %variant undef, i8* %238, 0
%240 = insertvalue %variant %239, i64 ptrtoint (%.introspect* @"ct$uint" to i64), 1
%241 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 1
store %variant %240, %variant* %241, align 16
%242 = getelementptr inbounds [8 x i8], [8 x i8]* %b, i64 0, i64 7
%243 = load i8, i8* %242, align 1
%lshrl124 = lshr i8 %243, 7
%244 = trunc i8 %lshrl124 to i1
%245 = zext i1 %244 to i8
store i8 %245, i8* %taddr125, align 1
%246 = insertvalue %variant undef, i8* %taddr125, 0
%247 = insertvalue %variant %246, i64 ptrtoint (%.introspect* @"ct$bool" to i64), 1
%248 = getelementptr inbounds [3 x %variant], [3 x %variant]* %varargslots107, i64 0, i64 2
store %variant %247, %variant* %248, align 16
%249 = bitcast [3 x %variant]* %varargslots107 to %variant*
%250 = insertvalue %"variant[]" undef, %variant* %249, 0
%251 = insertvalue %"variant[]" %250, i64 3, 1
store %"variant[]" %251, %"variant[]"* %taddr126, align 8
%252 = bitcast %"variant[]"* %taddr126 to { i8*, i64 }*
%253 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %252, i32 0, i32 0
%lo127 = load i8*, i8** %253, align 8
%254 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %252, i32 0, i32 1
%hi128 = load i64, i64* %254, align 8
%255 = call i64 @std_io_printfln(i64* %retparam106, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i32 0, i32 0), i64 8, i8* %lo127, i64 %hi128)
%not_err129 = icmp eq i64 %255, 0
br i1 %not_err129, label %after_check130, label %voiderr131
voiderr92: ; preds = %after_check91, %voiderr79
%169 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 0
%170 = load i8, ptr %169, align 1
%zext95 = zext i8 %170 to i32
%171 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 1
%172 = load i8, ptr %171, align 1
%zext96 = zext i8 %172 to i32
%shl97 = shl i32 %zext96, 8
%173 = or i32 %shl97, %zext95
%174 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 2
%175 = load i8, ptr %174, align 1
%zext98 = zext i8 %175 to i32
%shl99 = shl i32 %zext98, 16
%176 = or i32 %shl99, %173
%177 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 3
%178 = load i8, ptr %177, align 1
%zext100 = zext i8 %178 to i32
%shl101 = shl i32 %zext100, 24
%179 = or i32 %shl101, %176
store i32 %179, ptr %taddr102, align 4
%180 = insertvalue %variant undef, ptr %taddr102, 0
%181 = insertvalue %variant %180, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%182 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 0
store %variant %181, ptr %182, align 16
%183 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 4
%184 = load i8, ptr %183, align 1
%zext103 = zext i8 %184 to i32
%185 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 5
%186 = load i8, ptr %185, align 1
%zext104 = zext i8 %186 to i32
%shl105 = shl i32 %zext104, 8
%187 = or i32 %shl105, %zext103
%188 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 6
%189 = load i8, ptr %188, align 1
%zext106 = zext i8 %189 to i32
%shl107 = shl i32 %zext106, 16
%190 = or i32 %shl107, %187
%191 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%192 = load i8, ptr %191, align 1
%zext108 = zext i8 %192 to i32
%shl109 = shl i32 %zext108, 24
%193 = or i32 %shl109, %190
%194 = and i32 2147483647, %193
store i32 %194, ptr %taddr110, align 4
%195 = insertvalue %variant undef, ptr %taddr110, 0
%196 = insertvalue %variant %195, i64 ptrtoint (ptr @"ct$uint" to i64), 1
%197 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 1
store %variant %196, ptr %197, align 16
%198 = getelementptr inbounds [8 x i8], ptr %b, i64 0, i64 7
%199 = load i8, ptr %198, align 1
%lshrl111 = lshr i8 %199, 7
%200 = trunc i8 %lshrl111 to i1
%201 = zext i1 %200 to i8
store i8 %201, ptr %taddr112, align 1
%202 = insertvalue %variant undef, ptr %taddr112, 0
%203 = insertvalue %variant %202, i64 ptrtoint (ptr @"ct$bool" to i64), 1
%204 = getelementptr inbounds [3 x %variant], ptr %varargslots94, i64 0, i64 2
store %variant %203, ptr %204, align 16
%205 = call i64 @std_io_printfn(ptr %retparam93, ptr @.str.6, i64 8, ptr %varargslots94, i64 3)
%not_err113 = icmp eq i64 %205, 0
br i1 %not_err113, label %after_check114, label %voiderr115
after_check130: ; preds = %voiderr105
br label %voiderr131
after_check114: ; preds = %voiderr92
br label %voiderr115
voiderr131: ; preds = %after_check130, %voiderr105
voiderr115: ; preds = %after_check114, %voiderr92
ret void
}
; Function Attrs: nounwind
define void @test_main() #0 {
entry:
call void @test_hello(i32 12)
ret void
}

38
test/test_suite/bitstruct/bitstruct_intcontainer.c3t
View File

@@ -55,51 +55,51 @@ entry:
%xxu = alloca i32, align 4
%xxy = alloca i64, align 8
%xxybe = alloca i64, align 8
store i32 8388128, i32* %xx, align 4
%0 = load i32, i32* %xx, align 4
store i32 8388128, ptr %xx, align 4
%0 = load i32, ptr %xx, align 4
%shl = shl i32 %0, 9
%ashr = ashr i32 %shl, 14
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
store i32 1073741375, i32* %xx, align 4
%1 = load i32, i32* %xx, align 4
call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
store i32 1073741375, ptr %xx, align 4
%1 = load i32, ptr %xx, align 4
%shl1 = shl i32 %1, 9
%ashr2 = ashr i32 %shl1, 14
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %ashr2)
store i32 -3485921, i32* %xxu, align 4
%2 = load i32, i32* %xxu, align 4
call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr2)
store i32 -3485921, ptr %xxu, align 4
%2 = load i32, ptr %xxu, align 4
%lshrl = lshr i32 %2, 5
%3 = and i32 262143, %lshrl
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %3)
store i64 1525363991714123551, i64* %xxy, align 8
%4 = load i64, i64* %xxy, align 8
call void (ptr, ...) @printf(ptr @.str.2, i32 %3)
store i64 1525363991714123551, ptr %xxy, align 8
%4 = load i64, ptr %xxy, align 8
%lshrl3 = lshr i64 %4, 5
%5 = and i64 262143, %lshrl3
%ztrunc = trunc i64 %5 to i32
%6 = load i64, i64* %xxy, align 8
%6 = load i64, ptr %xxy, align 8
%lshrl4 = lshr i64 %6, 23
%7 = and i64 262143, %lshrl4
%ztrunc5 = trunc i64 %7 to i32
%8 = load i64, i64* %xxy, align 8
%8 = load i64, ptr %xxy, align 8
%lshrl6 = lshr i64 %8, 41
%9 = and i64 2097151, %lshrl6
%ztrunc7 = trunc i64 %9 to i32
call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i32 0, i32 0), i32 %ztrunc, i32 %ztrunc5, i32 %ztrunc7)
store i64 2292133196431502101, i64* %xxybe, align 8
%10 = load i64, i64* %xxybe, align 8
call void (ptr, ...) @printf(ptr @.str.3, i32 %ztrunc, i32 %ztrunc5, i32 %ztrunc7)
store i64 2292133196431502101, ptr %xxybe, align 8
%10 = load i64, ptr %xxybe, align 8
%11 = call i64 @llvm.bswap.i64(i64 %10)
%lshrl8 = lshr i64 %11, 5
%12 = and i64 262143, %lshrl8
%ztrunc9 = trunc i64 %12 to i32
%13 = load i64, i64* %xxybe, align 8
%13 = load i64, ptr %xxybe, align 8
%14 = call i64 @llvm.bswap.i64(i64 %13)
%lshrl10 = lshr i64 %14, 23
%15 = and i64 262143, %lshrl10
%ztrunc11 = trunc i64 %15 to i32
%16 = load i64, i64* %xxybe, align 8
%16 = load i64, ptr %xxybe, align 8
%17 = call i64 @llvm.bswap.i64(i64 %16)
%lshrl12 = lshr i64 %17, 41
%18 = and i64 2097151, %lshrl12
%ztrunc13 = trunc i64 %18 to i32
call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i32 %ztrunc9, i32 %ztrunc11, i32 %ztrunc13)
call void (ptr, ...) @printf(ptr @.str.4, i32 %ztrunc9, i32 %ztrunc11, i32 %ztrunc13)
ret void
}

72
test/test_suite/bitstruct/bitstruct_to_int.c3t
View File

@@ -53,25 +53,23 @@ entry:
%b = alloca i32, align 4
%x = alloca i32, align 4
%y = alloca [4 x i8], align 1
%c = alloca i32*, align 8
%x2 = alloca i32*, align 8
%y2 = alloca [4 x i8]*, align 8
store i32 0, i32* %b, align 4
%0 = load i32, i32* %b, align 4
store i32 %0, i32* %x, align 4
%1 = bitcast i32* %b to [4 x i8]*
%2 = load [4 x i8], [4 x i8]* %1, align 4
store [4 x i8] %2, [4 x i8]* %y, align 1
store i32* %b, i32** %c, align 8
%3 = load i32*, i32** %c, align 8
%4 = load i32, i32* %3, align 8
%shl = shl i32 %4, 28
%c = alloca ptr, align 8
%x2 = alloca ptr, align 8
%y2 = alloca ptr, align 8
store i32 0, ptr %b, align 4
%0 = load i32, ptr %b, align 4
store i32 %0, ptr %x, align 4
%1 = load [4 x i8], ptr %b, align 4
store [4 x i8] %1, ptr %y, align 1
store ptr %b, ptr %c, align 8
%2 = load ptr, ptr %c, align 8
%3 = load i32, ptr %2, align 8
%shl = shl i32 %3, 28
%ashr = ashr i32 %shl, 29
%5 = load i32*, i32** %c, align 8
store i32* %5, i32** %x2, align 8
%6 = load i32*, i32** %c, align 8
%ptrptr = bitcast i32* %6 to [4 x i8]*
store [4 x i8]* %ptrptr, [4 x i8]** %y2, align 8
%4 = load ptr, ptr %c, align 8
store ptr %4, ptr %x2, align 8
%5 = load ptr, ptr %c, align 8
store ptr %5, ptr %y2, align 8
ret void
}
@@ -81,29 +79,25 @@ entry:
%b = alloca [4 x i8], align 1
%x = alloca i32, align 4
%y = alloca [4 x i8], align 1
%c = alloca [4 x i8]*, align 8
%x2 = alloca i32*, align 8
%y2 = alloca [4 x i8]*, align 8
store [4 x i8] c"\06\90\00\00", [4 x i8]* %b, align 1
%0 = bitcast [4 x i8]* %b to i32*
%1 = load i32, i32* %0, align 1
store i32 %1, i32* %x, align 4
%2 = bitcast [4 x i8]* %y to i8*
%3 = bitcast [4 x i8]* %b to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %2, i8* align 1 %3, i32 4, i1 false)
store [4 x i8]* %b, [4 x i8]** %c, align 8
%4 = load [4 x i8]*, [4 x i8]** %c, align 8
%5 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 0, i64 0
%6 = load i8, i8* %5, align 1
%zext = zext i8 %6 to i32
%c = alloca ptr, align 8
%x2 = alloca ptr, align 8
%y2 = alloca ptr, align 8
store [4 x i8] c"\06\90\00\00", ptr %b, align 1
%0 = load i32, ptr %b, align 1
store i32 %0, ptr %x, align 4
call void @llvm.memcpy.p0.p0.i32(ptr align 1 %y, ptr align 1 %b, i32 4, i1 false)
store ptr %b, ptr %c, align 8
%1 = load ptr, ptr %c, align 8
%2 = getelementptr inbounds [4 x i8], ptr %1, i64 0, i64 0
%3 = load i8, ptr %2, align 1
%zext = zext i8 %3 to i32
%lshrl = lshr i32 %zext, 1
%shl = shl i32 %lshrl, 29
%ashr = ashr i32 %shl, 29
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
%7 = load [4 x i8]*, [4 x i8]** %c, align 8
%ptrptr = bitcast [4 x i8]* %7 to i32*
store i32* %ptrptr, i32** %x2, align 8
%8 = load [4 x i8]*, [4 x i8]** %c, align 8
store [4 x i8]* %8, [4 x i8]** %y2, align 8
call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
%4 = load ptr, ptr %c, align 8
store ptr %4, ptr %x2, align 8
%5 = load ptr, ptr %c, align 8
store ptr %5, ptr %y2, align 8
ret void
}

50
test/test_suite/bitstruct/embedded_bitstruct.c3t
View File

@@ -50,32 +50,30 @@ define void @foo_main() #0 {
entry:
%b = alloca %Bar, align 4
%f = alloca %Foo, align 4
%0 = bitcast %Bar* %b to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast (%Bar* @.__const to i8*), i32 12, i1 false)
%1 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 1
%2 = getelementptr inbounds %.anon, %.anon* %1, i32 0, i32 0
%3 = getelementptr inbounds %.anon.0, %.anon.0* %2, i32 0, i32 0
%4 = load i32, i32* %3, align 4
%5 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 2
%6 = load i32, i32* %5, align 4
%shl = shl i32 %6, 21
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %b, ptr align 4 @.__const, i32 12, i1 false)
%0 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
%1 = getelementptr inbounds %.anon, ptr %0, i32 0, i32 0
%2 = getelementptr inbounds %.anon.0, ptr %1, i32 0, i32 0
%3 = load i32, ptr %2, align 4
%4 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 2
%5 = load i32, ptr %4, align 4
%shl = shl i32 %5, 21
%ashr = ashr i32 %shl, 23
call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %ashr)
%7 = bitcast %Foo* %f to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %7, i8* align 4 bitcast (%Foo* @.__const.10 to i8*), i32 16, i1 false)
%8 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
%9 = getelementptr inbounds %.anon.1, %.anon.1* %8, i32 0, i32 0
%10 = getelementptr inbounds %.anon.2, %.anon.2* %9, i32 0, i32 0
%11 = load i32, i32* %10, align 4
%12 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
%13 = getelementptr inbounds %.anon.1, %.anon.1* %12, i32 0, i32 1
%14 = getelementptr inbounds %.anon.3, %.anon.3* %13, i32 0, i32 0
%15 = load i32, i32* %14, align 4
%16 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
%17 = getelementptr inbounds %.anon.1, %.anon.1* %16, i32 0, i32 2
%18 = load i32, i32* %17, align 4
%19 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 1
%20 = load i32, i32* %19, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i32 0, i32 0), i32 %11, i32 %15, i32 %18, i32 %20)
call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %ashr)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %f, ptr align 4 @.__const.10, i32 16, i1 false)
%6 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
%7 = getelementptr inbounds %.anon.1, ptr %6, i32 0, i32 0
%8 = getelementptr inbounds %.anon.2, ptr %7, i32 0, i32 0
%9 = load i32, ptr %8, align 4
%10 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
%11 = getelementptr inbounds %.anon.1, ptr %10, i32 0, i32 1
%12 = getelementptr inbounds %.anon.3, ptr %11, i32 0, i32 0
%13 = load i32, ptr %12, align 4
%14 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
%15 = getelementptr inbounds %.anon.1, ptr %14, i32 0, i32 2
%16 = load i32, ptr %15, align 4
%17 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 1
%18 = load i32, ptr %17, align 4
call void (ptr, ...) @printf(ptr @.str.11, i32 %9, i32 %13, i32 %16, i32 %18)
ret void
}

0
test/test_suite2/bitstruct/param_bitstruct.c3t → test/test_suite/bitstruct/param_bitstruct.c3t
View File

2
test/test_suite/builtins/exacts.c3t
View File

@@ -11,7 +11,7 @@ fn void main()
int z4 = $$add(x, y);
int z5 = $$sub(x, y);
int z6 = $$neg(x);
io::printfln("%s %s %s %s %s %s", z1, z2, z3, z4, z5, z6);
io::printfn("%s %s %s %s %s %s", z1, z2, z3, z4, z5, z6);
}
/* #expect: test.ll

9
test/test_suite/builtins/mem.c3t
View File

@@ -16,7 +16,8 @@ fn void main()
/* #expect: test.ll
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 2 %0, i8* align 2 %1, i64 2, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* align 2 %2, i8* align 2 %3, i64 2, i1 false)
call void @llvm.memset.p0i8.i64(i8* align 2 %4, i8 0, i64 2, i1 false)
call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* align 2 %5, i8* align 2 %6, i64 2, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr align 2 %dst, ptr align 2 %src, i64 2, i1 false)
call void @llvm.memmove.p0.p0.i64(ptr align 2 %dst, ptr align 2 %src, i64 2, i1 false)
call void @llvm.memset.p0.i64(ptr align 2 %dst, i8 0, i64 2, i1 false)
call void @llvm.memcpy.inline.p0.p0.i64(ptr align 2 %dst, ptr align 2 %src, i64 2, i1 false)
call void @llvm.memset.inline.p0.i64(ptr align 2 %dst, i8 0, i64 2, i1 false)

50
test/test_suite/builtins/overflows.c3t
View File

@@ -14,53 +14,53 @@ fn void main()
bool success3 = $$overflow_add(x, x, &z3);
bool success4 = $$overflow_sub($$neg(y), y, &z4);
bool success5 = $$overflow_sub(x, y, &z5);
io::printfln("%s %s", success1, z1);
io::printfln("%s %s", success2, z2);
io::printfln("%s %s", success3, z3);
io::printfln("%s %s", success4, z4);
io::printfln("%s %s", success5, z5);
io::printfn("%s %s", success1, z1);
io::printfn("%s %s", success2, z2);
io::printfn("%s %s", success3, z3);
io::printfn("%s %s", success4, z4);
io::printfn("%s %s", success5, z5);
}
/* #expect: test.ll
%0 = load i8, i8* %x, align 1
%1 = load i8, i8* %y, align 1
%0 = load i8, ptr %x, align 1
%1 = load i8, ptr %y, align 1
%2 = call { i8, i1 } @llvm.smul.with.overflow.i8(i8 %0, i8 %1)
%3 = extractvalue { i8, i1 } %2, 1
%4 = extractvalue { i8, i1 } %2, 0
store i8 %4, i8* %z1, align 1
store i8 %4, ptr %z1, align 1
%5 = zext i1 %3 to i8
store i8 %5, i8* %success1, align 1
%6 = load i8, i8* %x, align 1
%7 = load i8, i8* %y, align 1
store i8 %5, ptr %success1, align 1
%6 = load i8, ptr %x, align 1
%7 = load i8, ptr %y, align 1
%8 = call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 %6, i8 %7)
%9 = extractvalue { i8, i1 } %8, 1
%10 = extractvalue { i8, i1 } %8, 0
store i8 %10, i8* %z2, align 1
store i8 %10, ptr %z2, align 1
%11 = zext i1 %9 to i8
store i8 %11, i8* %success2, align 1
%12 = load i8, i8* %x, align 1
%13 = load i8, i8* %x, align 1
store i8 %11, ptr %success2, align 1
%12 = load i8, ptr %x, align 1
%13 = load i8, ptr %x, align 1
%14 = call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 %12, i8 %13)
%15 = extractvalue { i8, i1 } %14, 1
%16 = extractvalue { i8, i1 } %14, 0
store i8 %16, i8* %z3, align 1
store i8 %16, ptr %z3, align 1
%17 = zext i1 %15 to i8
store i8 %17, i8* %success3, align 1
%18 = load i8, i8* %y, align 1
store i8 %17, ptr %success3, align 1
%18 = load i8, ptr %y, align 1
%eneg = sub i8 0, %18
%19 = load i8, i8* %y, align 1
%19 = load i8, ptr %y, align 1
%20 = call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %eneg, i8 %19)
%21 = extractvalue { i8, i1 } %20, 1
%22 = extractvalue { i8, i1 } %20, 0
store i8 %22, i8* %z4, align 1
store i8 %22, ptr %z4, align 1
%23 = zext i1 %21 to i8
store i8 %23, i8* %success4, align 1
%24 = load i8, i8* %x, align 1
%25 = load i8, i8* %y, align 1
store i8 %23, ptr %success4, align 1
%24 = load i8, ptr %x, align 1
%25 = load i8, ptr %y, align 1
%26 = call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 %24, i8 %25)
%27 = extractvalue { i8, i1 } %26, 1
%28 = extractvalue { i8, i1 } %26, 0
store i8 %28, i8* %z5, align 1
store i8 %28, ptr %z5, align 1
%29 = zext i1 %27 to i8
store i8 %29, i8* %success5, align 1
store i8 %29, ptr %success5, align 1

17
test/test_suite/builtins/prefetch.c3t
View File

@@ -13,13 +13,10 @@ fn void main()
/* #expect: test.ll
%a = alloca i32, align 4
%ptr = alloca i8*, align 8
store i32 0, i32* %a, align 4
%ptrptr = bitcast i32* %a to i8*
call void @llvm.prefetch.p0i8(i8* %ptrptr, i32 1, i32 3, i32 1)
%ptrptr1 = bitcast i32* %a to i8*
call void @llvm.prefetch.p0i8(i8* %ptrptr1, i32 0, i32 1, i32 1)
%ptrptr2 = bitcast i32* %a to i8*
store i8* %ptrptr2, i8** %ptr, align 8
%0 = load i8*, i8** %ptr, align 8
call void @llvm.prefetch.p0i8(i8* %0, i32 0, i32 3, i32 1)
%ptr = alloca ptr, align 8
store i32 0, ptr %a, align 4
call void @llvm.prefetch.p0(ptr %a, i32 1, i32 3, i32 1)
call void @llvm.prefetch.p0(ptr %a, i32 0, i32 1, i32 1)
store ptr %a, ptr %ptr, align 8
%0 = load ptr, ptr %ptr, align 8
call void @llvm.prefetch.p0(ptr %0, i32 0, i32 3, i32 1)

30
test/test_suite/builtins/reduce_arithmetics.c3t
View File

@@ -5,21 +5,21 @@ import std::io;
fn void main()
{
int a;
io::printfln("%s", $$pow_int(double[<2>] { 23.3, 2.1 }, 3));
io::printfln("%s", $$reduce_add(int[<2>] { 3, 10 }));
io::printfln("%s", $$reduce_fadd(double[<2>] { 3, 10 }, -0.0));
io::printfln("%s", $$reduce_fadd(double[<2>] { 3, 10 }, 3.2));
io::printfln("%s", $$reduce_mul(int[<2>] { 3, 10 }));
io::printfln("%s", $$reduce_fmul(double[<2>] { 3, 10 }, 3.4));
io::printfln("%s", $$reduce_and(int[<2>] { 3, 11 }));
io::printfln("%s", $$reduce_or(int[<2>] { 3, 10 }));
io::printfln("%s", $$reduce_xor(int[<2>] { 3, 10 }));
io::printfln("%s", $$reduce_max(double[<2>] { 23.2, 23.3 }));
io::printfln("%s", $$reduce_max(int[<2>] { -23, 32 }));
io::printfln("%s", $$reduce_max(char[<2>] { 4, 253 }));
io::printfln("%s", $$reduce_min(double[<2>] { 23.2, 23.3 }));
io::printfln("%s", $$reduce_min(int[<2>] { -23, 32 }));
io::printfln("%s", $$reduce_min(char[<2>] { 4, 253 }));
io::printfn("%s", $$pow_int(double[<2>] { 23.3, 2.1 }, 3));
io::printfn("%s", $$reduce_add(int[<2>] { 3, 10 }));
io::printfn("%s", $$reduce_fadd(double[<2>] { 3, 10 }, -0.0));
io::printfn("%s", $$reduce_fadd(double[<2>] { 3, 10 }, 3.2));
io::printfn("%s", $$reduce_mul(int[<2>] { 3, 10 }));
io::printfn("%s", $$reduce_fmul(double[<2>] { 3, 10 }, 3.4));
io::printfn("%s", $$reduce_and(int[<2>] { 3, 11 }));
io::printfn("%s", $$reduce_or(int[<2>] { 3, 10 }));
io::printfn("%s", $$reduce_xor(int[<2>] { 3, 10 }));
io::printfn("%s", $$reduce_max(double[<2>] { 23.2, 23.3 }));
io::printfn("%s", $$reduce_max(int[<2>] { -23, 32 }));
io::printfn("%s", $$reduce_max(char[<2>] { 4, 253 }));
io::printfn("%s", $$reduce_min(double[<2>] { 23.2, 23.3 }));
io::printfn("%s", $$reduce_min(int[<2>] { -23, 32 }));
io::printfn("%s", $$reduce_min(char[<2>] { 4, 253 }));
}

2
test/test_suite/builtins/reverse_builtin.c3t
View File

@@ -6,7 +6,7 @@ import std::io;
fn void main()
{
int[<4>] a = { 1, -3, 5, -7 };
io::printfln("%s", $$reverse(a));
io::printfn("%s", $$reverse(a));
}
/* #expect: test.ll

12
test/test_suite/builtins/sat_builtins.c3t
View File

@@ -7,18 +7,18 @@ fn void main()
{
char a = 123;
char b = 222;
io::printfln("%s %s", $$sat_add(a, b), $$sat_add((ichar)a, (ichar)30));
io::printfln("%s %s", $$sat_sub(a, b), $$sat_sub((ichar)-120, (ichar)10));
io::printfn("%s %s", $$sat_add(a, b), $$sat_add((ichar)a, (ichar)30));
io::printfn("%s %s", $$sat_sub(a, b), $$sat_sub((ichar)-120, (ichar)10));
b = 3;
io::printfln("%s %s", $$sat_shl(a, b), $$sat_shl((ichar)a, (ichar)1));
io::printfn("%s %s", $$sat_shl(a, b), $$sat_shl((ichar)a, (ichar)1));
b = 222;
char[<2>] x = { 123, 222 };
char[<2>] y = { 143, 50 };
ichar[<2>] z = { 120, -120 };
ichar[<2>] w = { -44, 30 };
io::printfln("%s %s", $$sat_add(x, y), $$sat_add(z, z));
io::printfln("%s %s", $$sat_sub(x, y), $$sat_sub(w, z));
io::printfln("%s %s", $$sat_shl(x, char[<2>] { 1, 1 }), $$sat_shl(z, ichar[<2>] { 1, 1 }));
io::printfn("%s %s", $$sat_add(x, y), $$sat_add(z, z));
io::printfn("%s %s", $$sat_sub(x, y), $$sat_sub(w, z));
io::printfn("%s %s", $$sat_shl(x, char[<2>] { 1, 1 }), $$sat_shl(z, ichar[<2>] { 1, 1 }));
}
/* #expect: test.ll

73
test/test_suite/builtins/shufflevector.c3t
View File

@@ -49,53 +49,48 @@ fn float[<2>] apply3(Matrix2x2* mat, float[<2>] vec)
fn void main()
{
Matrix2x2 a = { 1, -3, 5, -7 };
io::printfln("1: %s", apply1(&a, float[<2>] { 11, 13 }));
io::printfln("2: %s", apply2(&a, float[<2>] { 11, 13 }));
io::printfln("3: %s", apply3(&a, float[<2>] { 11, 13 }));
io::printfn("1: %s", apply1(&a, float[<2>] { 11, 13 }));
io::printfn("2: %s", apply2(&a, float[<2>] { 11, 13 }));
io::printfn("3: %s", apply3(&a, float[<2>] { 11, 13 }));
}
/* #expect: test.ll
define double @test_apply3(%Matrix2x2* %0, double %1) #0 {
define double @test_apply3(ptr %0, double %1) #0 {
entry:
%vec = alloca <2 x float>, align 8
%a = alloca <2 x float>, align 8
%b = alloca <2 x float>, align 8
%flip = alloca <2 x float>, align 8
%taddr = alloca <2 x float>, align 8
%2 = bitcast <2 x float>* %vec to double*
store double %1, double* %2, align 8
%3 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %0, i32 0, i32 0
%4 = bitcast %.anon* %3 to %.anon.1*
%5 = getelementptr inbounds %.anon.1, %.anon.1* %4, i32 0, i32 0
%6 = load <2 x float>, <2 x float>* %5, align 8
%7 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %0, i32 0, i32 0
%8 = bitcast %.anon* %7 to %.anon.1*
%9 = getelementptr inbounds %.anon.1, %.anon.1* %8, i32 0, i32 1
%10 = load <2 x float>, <2 x float>* %9, align 8
%shuffle = shufflevector <2 x float> %6, <2 x float> %10, <2 x i32> <i32 0, i32 3>
store <2 x float> %shuffle, <2 x float>* %a, align 8
%11 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %0, i32 0, i32 0
%12 = bitcast %.anon* %11 to %.anon.1*
%13 = getelementptr inbounds %.anon.1, %.anon.1* %12, i32 0, i32 0
%14 = load <2 x float>, <2 x float>* %13, align 8
%15 = getelementptr inbounds %Matrix2x2, %Matrix2x2* %0, i32 0, i32 0
%16 = bitcast %.anon* %15 to %.anon.1*
%17 = getelementptr inbounds %.anon.1, %.anon.1* %16, i32 0, i32 1
%18 = load <2 x float>, <2 x float>* %17, align 8
%shuffle1 = shufflevector <2 x float> %14, <2 x float> %18, <2 x i32> <i32 1, i32 2>
store <2 x float> %shuffle1, <2 x float>* %b, align 8
%19 = load <2 x float>, <2 x float>* %vec, align 8
%shuffle2 = shufflevector <2 x float> %19, <2 x float> poison, <2 x i32> <i32 1, i32 0>
store <2 x float> %shuffle2, <2 x float>* %flip, align 8
%20 = load <2 x float>, <2 x float>* %a, align 8
%21 = load <2 x float>, <2 x float>* %vec, align 8
%fmul = fmul <2 x float> %20, %21
%22 = load <2 x float>, <2 x float>* %b, align 8
%23 = load <2 x float>, <2 x float>* %flip, align 8
%fmul3 = fmul <2 x float> %22, %23
store double %1, ptr %vec, align 8
%2 = getelementptr inbounds %Matrix2x2, ptr %0, i32 0, i32 0
%3 = getelementptr inbounds %.anon.1, ptr %2, i32 0, i32 0
%4 = load <2 x float>, ptr %3, align 8
%5 = getelementptr inbounds %Matrix2x2, ptr %0, i32 0, i32 0
%6 = getelementptr inbounds %.anon.1, ptr %5, i32 0, i32 1
%7 = load <2 x float>, ptr %6, align 8
%shuffle = shufflevector <2 x float> %4, <2 x float> %7, <2 x i32> <i32 0, i32 3>
store <2 x float> %shuffle, ptr %a, align 8
%8 = getelementptr inbounds %Matrix2x2, ptr %0, i32 0, i32 0
%9 = getelementptr inbounds %.anon.1, ptr %8, i32 0, i32 0
%10 = load <2 x float>, ptr %9, align 8
%11 = getelementptr inbounds %Matrix2x2, ptr %0, i32 0, i32 0
%12 = getelementptr inbounds %.anon.1, ptr %11, i32 0, i32 1
%13 = load <2 x float>, ptr %12, align 8
%shuffle1 = shufflevector <2 x float> %10, <2 x float> %13, <2 x i32> <i32 1, i32 2>
store <2 x float> %shuffle1, ptr %b, align 8
%14 = load <2 x float>, ptr %vec, align 8
%shuffle2 = shufflevector <2 x float> %14, <2 x float> poison, <2 x i32> <i32 1, i32 0>
store <2 x float> %shuffle2, ptr %flip, align 8
%15 = load <2 x float>, ptr %a, align 8
%16 = load <2 x float>, ptr %vec, align 8
%fmul = fmul <2 x float> %15, %16
%17 = load <2 x float>, ptr %b, align 8
%18 = load <2 x float>, ptr %flip, align 8
%fmul3 = fmul <2 x float> %17, %18
%fadd = fadd <2 x float> %fmul, %fmul3
store <2 x float> %fadd, <2 x float>* %taddr, align 8
%24 = bitcast <2 x float>* %taddr to double*
%25 = load double, double* %24, align 8
ret double %25
store <2 x float> %fadd, ptr %taddr, align 8
%19 = load double, ptr %taddr, align 8
ret double %19
}

48
test/test_suite/builtins/simple_builtins.c3t
View File

@@ -29,34 +29,34 @@ entry:
%abcd = alloca [3 x i32], align 4
%sy = alloca i32, align 4
%1 = call double @llvm.ceil.f64(double %0)
store double %1, double* %d, align 8
%2 = load double, double* %d, align 8
store double %1, ptr %d, align 8
%2 = load double, ptr %d, align 8
%3 = call double @llvm.maxnum.f64(double 1.000000e+00, double %2)
store double %3, double* %e, align 8
%4 = load double, double* %d, align 8
store double %3, ptr %e, align 8
%4 = load double, ptr %d, align 8
%5 = call double @llvm.fma.f64(double %4, double 2.000000e+00, double 3.000000e+00)
store double %5, double* %f, align 8
%6 = load double, double* %d, align 8
store double %5, ptr %f, align 8
%6 = load double, ptr %d, align 8
%7 = call double @llvm.fmuladd.f64(double %6, double 2.000000e+00, double 3.000000e+00)
store double %7, double* %m, align 8
store i32 13, i32* %xeb, align 4
%8 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 0
store i32 0, i32* %8, align 4
%9 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 1
store i32 0, i32* %9, align 4
%10 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
store i32 0, i32* %10, align 4
%11 = load volatile i32, i32* %xeb, align 4
store i32 %11, i32* %sy, align 4
%12 = load i32, i32* %sy, align 4
store double %7, ptr %m, align 8
store i32 13, ptr %xeb, align 4
%8 = getelementptr inbounds [3 x i32], ptr %abcd, i64 0, i64 0
store i32 0, ptr %8, align 4
%9 = getelementptr inbounds [3 x i32], ptr %abcd, i64 0, i64 1
store i32 0, ptr %9, align 4
%10 = getelementptr inbounds [3 x i32], ptr %abcd, i64 0, i64 2
store i32 0, ptr %10, align 4
%11 = load volatile i32, ptr %xeb, align 4
store i32 %11, ptr %sy, align 4
%12 = load i32, ptr %sy, align 4
%add = add i32 %12, 1
store volatile i32 %add, i32* %xeb, align 4
%13 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
%14 = load i32, i32* %sy, align 4
store volatile i32 %add, ptr %xeb, align 4
%13 = getelementptr inbounds [3 x i32], ptr %abcd, i64 0, i64 2
%14 = load i32, ptr %sy, align 4
%add1 = add i32 %14, 2
store volatile i32 %add1, i32* %13, align 4
%15 = getelementptr inbounds [3 x i32], [3 x i32]* %abcd, i64 0, i64 2
%16 = load volatile i32, i32* %15, align 4
store i32 %16, i32* %sy, align 4
store volatile i32 %add1, ptr %13, align 4
%15 = getelementptr inbounds [3 x i32], ptr %abcd, i64 0, i64 2
%16 = load volatile i32, ptr %15, align 4
store i32 %16, ptr %sy, align 4
ret i32 1
}

16
test/test_suite/cast/cast_from_ptr.c3t
View File

@@ -9,10 +9,14 @@ fn void tester()
/* #expect: test.ll
%0 = load i32*, i32** %x, align 8
%ptrxi = ptrtoint i32* %0 to i16
store i16 %ptrxi, i16* %y, align 2
%1 = load i32*, i32** %x, align 8
%ptrxi1 = ptrtoint i32* %1 to i16
%x = alloca ptr, align 8
%y = alloca i16, align 2
%z = alloca i64, align 8
store ptr null, ptr %x, align 8
%0 = load ptr, ptr %x, align 8
%ptrxi = ptrtoint ptr %0 to i16
store i16 %ptrxi, ptr %y, align 2
%1 = load ptr, ptr %x, align 8
%ptrxi1 = ptrtoint ptr %1 to i16
%siuiext = sext i16 %ptrxi1 to i64
store i64 %siuiext, i64* %z, align 8
store i64 %siuiext, ptr %z, align 8

62
test/test_suite/cast/implicit_infer_len_cast.c3t
View File

@@ -26,41 +26,31 @@ fn void main()
%literal = alloca [1 x <2 x i32>], align 8
%bb = alloca [1 x %"int[]"], align 16
%literal1 = alloca [2 x i32], align 4
%y2 = alloca [2 x [2 x i32]]*, align 8
%y2 = alloca ptr, align 8
%z3 = alloca [2 x [2 x i32]], align 16
%0 = bitcast [2 x [2 x i32]]* %x to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %0, i8* align 16 bitcast ([2 x [2 x i32]]* @.__const to i8*), i32 16, i1 false)
%1 = bitcast [1 x <2 x i32>]* %y to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %1, i8* align 8 bitcast ([1 x <2 x i32>]* @.__const.1 to i8*), i32 8, i1 false)
%2 = bitcast [1 x <2 x i32>]* %z to i8*
%3 = bitcast [1 x <2 x i32>]* %y to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %2, i8* align 8 %3, i32 8, i1 false)
%4 = bitcast [1 x <2 x i32>]* %w to i8*
%5 = bitcast [1 x <2 x i32>]* %z to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %4, i8* align 8 %5, i32 8, i1 false)
%6 = getelementptr inbounds [1 x <2 x i32>], [1 x <2 x i32>]* %literal, i64 0, i64 0
%7 = getelementptr inbounds <2 x i32>, <2 x i32>* %6, i64 0, i64 0
store i32 1, i32* %7, align 4
%8 = getelementptr inbounds <2 x i32>, <2 x i32>* %6, i64 0, i64 1
store i32 3, i32* %8, align 4
%9 = bitcast [1 x <2 x i32>]* %literal to <2 x i32>*
%10 = insertvalue %"int[<2>][]" undef, <2 x i32>* %9, 0
%11 = insertvalue %"int[<2>][]" %10, i64 1, 1
store %"int[<2>][]" %11, %"int[<2>][]"* %aa, align 8
%12 = getelementptr inbounds [1 x %"int[]"], [1 x %"int[]"]* %bb, i64 0, i64 0
%13 = getelementptr inbounds [2 x i32], [2 x i32]* %literal1, i64 0, i64 0
store i32 1, i32* %13, align 4
%14 = getelementptr inbounds [2 x i32], [2 x i32]* %literal1, i64 0, i64 1
store i32 3, i32* %14, align 4
%15 = bitcast [2 x i32]* %literal1 to i32*
%16 = insertvalue %"int[]" undef, i32* %15, 0
%17 = insertvalue %"int[]" %16, i64 2, 1
store %"int[]" %17, %"int[]"* %12, align 16
store [2 x [2 x i32]]* %x, [2 x [2 x i32]]** %y2, align 8
%18 = load [2 x [2 x i32]]*, [2 x [2 x i32]]** %y2, align 8
%19 = bitcast [2 x [2 x i32]]* %z3 to i8*
%20 = bitcast [2 x [2 x i32]]* %18 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %19, i8* align 8 %20, i32 16, i1 false)
%21 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %z3, i64 0, i64 1
%22 = getelementptr inbounds [2 x i32], [2 x i32]* %21, i64 0, i64 1
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %x, ptr align 16 @.__const, i32 16, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %y, ptr align 8 @.__const.1, i32 8, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %z, ptr align 8 %y, i32 8, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %w, ptr align 8 %z, i32 8, i1 false)
%0 = getelementptr inbounds [1 x <2 x i32>], ptr %literal, i64 0, i64 0
%1 = getelementptr inbounds <2 x i32>, ptr %0, i64 0, i64 0
store i32 1, ptr %1, align 4
%2 = getelementptr inbounds <2 x i32>, ptr %0, i64 0, i64 1
store i32 3, ptr %2, align 4
%3 = insertvalue %"int[<2>][]" undef, ptr %literal, 0
%4 = insertvalue %"int[<2>][]" %3, i64 1, 1
store %"int[<2>][]" %4, ptr %aa, align 8
%5 = getelementptr inbounds [1 x %"int[]"], ptr %bb, i64 0, i64 0
%6 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 0
store i32 1, ptr %6, align 4
%7 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 1
store i32 3, ptr %7, align 4
%8 = insertvalue %"int[]" undef, ptr %literal1, 0
%9 = insertvalue %"int[]" %8, i64 2, 1
store %"int[]" %9, ptr %5, align 16
store ptr %x, ptr %y2, align 8
%10 = load ptr, ptr %y2, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %z3, ptr align 8 %10, i32 16, i1 false)
%11 = getelementptr inbounds [2 x [2 x i32]], ptr %z3, i64 0, i64 1
%12 = getelementptr inbounds [2 x i32], ptr %11, i64 0, i64 1
ret void

66
test/test_suite/cast/top_down_casts.c3t
View File

@@ -24,70 +24,70 @@ entry:
%z = alloca i64, align 8
%w = alloca i32, align 4
%w.f = alloca i64, align 8
store i32 0, i32* %x, align 4
store i32 0, i32* %y, align 4
%0 = load i32, i32* %x, align 4
store i32 0, ptr %x, align 4
store i32 0, ptr %y, align 4
%0 = load i32, ptr %x, align 4
%sisiext = sext i32 %0 to i64
%1 = load i32, i32* %y, align 4
%1 = load i32, ptr %y, align 4
%sisiext1 = sext i32 %1 to i64
%mul = mul i64 %sisiext, %sisiext1
store i64 %mul, i64* %z, align 8
%2 = load i32, i32* %x, align 4
store i64 %mul, ptr %z, align 8
%2 = load i32, ptr %x, align 4
%sisiext2 = sext i32 %2 to i64
%3 = load i32, i32* %y, align 4
%3 = load i32, ptr %y, align 4
%sisiext3 = sext i32 %3 to i64
%sdiv = sdiv i64 %sisiext2, %sisiext3
store i64 %sdiv, i64* %z, align 8
%4 = load i32, i32* %x, align 4
store i64 %sdiv, ptr %z, align 8
%4 = load i32, ptr %x, align 4
%sisiext4 = sext i32 %4 to i64
%5 = load i32, i32* %y, align 4
%5 = load i32, ptr %y, align 4
%sisiext5 = sext i32 %5 to i64
%add = add i64 %sisiext4, %sisiext5
store i64 %add, i64* %z, align 8
%6 = load i32, i32* %x, align 4
store i64 %add, ptr %z, align 8
%6 = load i32, ptr %x, align 4
%sisiext6 = sext i32 %6 to i64
%7 = load i32, i32* %y, align 4
%7 = load i32, ptr %y, align 4
%sisiext7 = sext i32 %7 to i64
%sub = sub i64 %sisiext6, %sisiext7
store i64 %sub, i64* %z, align 8
%8 = load i32, i32* %x, align 4
store i64 %sub, ptr %z, align 8
%8 = load i32, ptr %x, align 4
%sisiext8 = sext i32 %8 to i64
%9 = load i32, i32* %y, align 4
%9 = load i32, ptr %y, align 4
%sisiext9 = sext i32 %9 to i64
%smod = srem i64 %sisiext8, %sisiext9
store i64 %smod, i64* %z, align 8
%10 = load i32, i32* %x, align 4
store i64 %smod, ptr %z, align 8
%10 = load i32, ptr %x, align 4
%sisiext10 = sext i32 %10 to i64
%11 = load i32, i32* %y, align 4
%11 = load i32, ptr %y, align 4
%zext = zext i32 %11 to i64
%shl = shl i64 %sisiext10, %zext
%12 = freeze i64 %shl
store i64 %12, i64* %z, align 8
%13 = load i32, i32* %x, align 4
store i64 %12, ptr %z, align 8
%13 = load i32, ptr %x, align 4
%sisiext11 = sext i32 %13 to i64
%14 = load i32, i32* %y, align 4
%14 = load i32, ptr %y, align 4
%zext12 = zext i32 %14 to i64
%ashr = ashr i64 %sisiext11, %zext12
%15 = freeze i64 %ashr
store i64 %15, i64* %z, align 8
%16 = load i32, i32* %x, align 4
store i64 %15, ptr %z, align 8
%16 = load i32, ptr %x, align 4
%sisiext13 = sext i32 %16 to i64
%bnot = xor i64 %sisiext13, -1
store i64 %bnot, i64* %z, align 8
%17 = load i32, i32* %x, align 4
store i64 %bnot, ptr %z, align 8
%17 = load i32, ptr %x, align 4
%sisiext14 = sext i32 %17 to i64
%18 = load i32, i32* %x, align 4
%18 = load i32, ptr %x, align 4
%sisiext15 = sext i32 %18 to i64
%neg = sub i64 0, %sisiext15
store i64 %neg, i64* %z, align 8
store i64 0, i64* %w.f, align 8
store i32 0, i32* %w, align 4
%optval = load i64, i64* %w.f, align 8
store i64 %neg, ptr %z, align 8
store i64 0, ptr %w.f, align 8
store i32 0, ptr %w, align 4
%optval = load i64, ptr %w.f, align 8
%not_err = icmp eq i64 %optval, 0
br i1 %not_err, label %after_check, label %else_block
after_check: ; preds = %entry
%19 = load i32, i32* %w, align 4
%19 = load i32, ptr %w, align 4
%sisiext16 = sext i32 %19 to i64
br label %phi_block
@@ -96,6 +96,6 @@ else_block: ; preds = %entry
phi_block: ; preds = %else_block, %after_check
%val = phi i64 [ %sisiext16, %after_check ], [ 1, %else_block ]
store i64 %val, i64* %z, align 8
store i64 %val, ptr %z, align 8
ret void
}

178
test/test_suite/clang/2002-01_02.c3t
View File

@@ -136,8 +136,7 @@ void *[*] data = { &afoo, &abar, &axx };
%Foo = type { i32, i32 }
%Foostruct = type { i16 }
%Edge_rec = type { %Vertex*, %Edge_rec*, i32, i32 }
%Vertex = type { float, float, float }
%Edge_rec = type { ptr, ptr, i32, i32 }
%Test = type { i16, i16, i32, i32 }
%STest2 = type { i32, [4 x i16], double }
@@ -146,30 +145,25 @@ void *[*] data = { &afoo, &abar, &axx };
@test_abar = global double 1.200000e+01, align 8
@test_axx = global float 1.200000e+01, align 4
@.str = private unnamed_addr constant [5 x i8] c"EXIT\00", align 1
@test_procnames = local_unnamed_addr global [1 x i8*] [i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0)], align 8
@test_data = local_unnamed_addr global [3 x i8*] [i8* bitcast (double* @test_afoo to i8*), i8* bitcast (double* @test_abar to i8*), i8* bitcast (float* @test_axx to i8*)], align 16
@test_procnames = local_unnamed_addr global [1 x ptr] [ptr @.str], align 8
@test_data = local_unnamed_addr global [3 x ptr] [ptr @test_afoo, ptr @test_abar, ptr @test_axx], align 16
@.str.6 = private unnamed_addr constant [6 x i8] c"%lld\0A\00", align 1
; Function Attrs: nounwind
define void @test_foo() #0 {
entry:
ret void
}
; Function Attrs: nounwind
declare i8* @test_dlclose(i8*) #0
declare ptr @test_dlclose(ptr) #0
; Function Attrs: nounwind
define void @test_ap_os_dso_unload(i8* %0) #0 {
define void @test_ap_os_dso_unload(ptr %0) #0 {
entry:
%1 = call i8* @test_dlclose(i8* %0)
%1 = call ptr @test_dlclose(ptr %0)
ret void
}
; Function Attrs: nounwind
declare void @foo2(i32, double, float) #0
; Function Attrs: nounwind
define void @test_bar(i32 %0) #0 {
entry:
%intbool = icmp ne i32 %0, 0
@@ -178,11 +172,9 @@ entry:
ret void
}
; Function Attrs: nounwind
declare i32 @tolower(i32) #0
; Function Attrs: nounwind
define i8* @test_rangematch(i8* %0, i32 %1, i32 %2) #0 {
define ptr @test_rangematch(ptr %0, i32 %1, i32 %2) #0 {
entry:
%le = icmp sle i32 %2, %1
%3 = call i32 @tolower(i32 %2)
@@ -194,48 +186,44 @@ entry:
br i1 %or, label %if.then, label %if.exit
if.then: ; preds = %entry
ret i8* null
ret ptr null
if.exit: ; preds = %entry
ret i8* %0
ret ptr %0
}
; Function Attrs: nounwind
declare i32 @foo3(i16) #0
; Function Attrs: nounwind
define void @test_teste2() #0 {
entry:
%xqic = alloca %Foostruct, align 2
%0 = bitcast %Foostruct* %xqic to i16*
store i16 0, i16* %0, align 2
%1 = getelementptr inbounds %Foostruct, %Foostruct* %xqic, i32 0, i32 0
%2 = load i16, i16* %1, align 2
%3 = call i32 @foo3(i16 %2)
store i16 0, ptr %xqic, align 2
%0 = getelementptr inbounds %Foostruct, ptr %xqic, i32 0, i32 0
%1 = load i16, ptr %0, align 2
%2 = call i32 @foo3(i16 %1)
ret void
}
; Function Attrs: nounwind
define i32 @test_do_merge(%Edge_rec* %0, %Edge_rec* %1) #0 {
define i32 @test_do_merge(ptr %0, ptr %1) #0 {
entry:
%lvalid = alloca i32, align 4
%basel = alloca %Edge_rec*, align 8
%rcand = alloca %Edge_rec*, align 8
store i32 0, i32* %lvalid, align 4
store %Edge_rec* null, %Edge_rec** %basel, align 8
store %Edge_rec* null, %Edge_rec** %rcand, align 8
%basel = alloca ptr, align 8
%rcand = alloca ptr, align 8
store i32 0, ptr %lvalid, align 4
store ptr null, ptr %basel, align 8
store ptr null, ptr %rcand, align 8
br label %loop.body
loop.body: ; preds = %if.exit, %entry
%2 = load i32, i32* %lvalid, align 4
%2 = load i32, ptr %lvalid, align 4
%not = icmp eq i32 %2, 0
br i1 %not, label %if.then, label %if.exit
if.then: ; preds = %loop.body
%3 = load %Edge_rec*, %Edge_rec** %basel, align 8
%4 = getelementptr inbounds %Edge_rec, %Edge_rec* %3, i32 0, i32 1
%5 = load %Edge_rec*, %Edge_rec** %4, align 8
%ptrxi = ptrtoint %Edge_rec* %5 to i32
%3 = load ptr, ptr %basel, align 8
%4 = getelementptr inbounds %Edge_rec, ptr %3, i32 0, i32 1
%5 = load ptr, ptr %4, align 8
%ptrxi = ptrtoint ptr %5 to i32
ret i32 %ptrxi
if.exit: ; preds = %loop.body
@@ -245,132 +233,112 @@ loop.exit: ; No predecessors!
ret i32 1
}
; Function Attrs: nounwind
define i32 @test_test(i32 %0) #0 {
entry:
ret i32 %0
}
; Function Attrs: nounwind
declare void @test_abc(i32*) #0
declare void @test_abc(ptr) #0
; Function Attrs: nounwind
define i32 @test_def(i32 %0, i32 %1) #0 {
entry:
%z = alloca i32, align 4
store i32 %1, i32* %z, align 4
call void @test_abc(i32* %z)
store i32 %1, ptr %z, align 4
call void @test_abc(ptr %z)
ret i32 %0
}
; Function Attrs: nounwind
define i32 @test_testing(%Test* %0) #0 {
define i32 @test_testing(ptr %0) #0 {
entry:
%1 = getelementptr inbounds %Test, %Test* %0, i32 0, i32 1
%2 = load i16, i16* %1, align 2
%1 = getelementptr inbounds %Test, ptr %0, i32 0, i32 1
%2 = load i16, ptr %1, align 2
%sisiext = sext i16 %2 to i32
%3 = getelementptr inbounds %Test, %Test* %0, i32 0, i32 2
%4 = load i32, i32* %3, align 4
%3 = getelementptr inbounds %Test, ptr %0, i32 0, i32 2
%4 = load i32, ptr %3, align 4
%add = add i32 %sisiext, %4
ret i32 %add
}
; Function Attrs: nounwind
define i32 @test_test2(i32 %0, i64 %1, i32 %2, i32 %3) #0 {
entry:
%4 = alloca { i64, i32 }, align 8
%a = bitcast { i64, i32 }* %4 to %Test*
%5 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %4, i32 0, i32 0
store i64 %1, i64* %5, align 8
%6 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %4, i32 0, i32 1
store i32 %2, i32* %6, align 8
%5 = getelementptr inbounds { i64, i32 }, ptr %4, i32 0, i32 0
store i64 %1, ptr %5, align 8
%6 = getelementptr inbounds { i64, i32 }, ptr %4, i32 0, i32 1
store i32 %2, ptr %6, align 8
%add = add i32 %0, %3
%7 = getelementptr inbounds %Test, %Test* %a, i32 0, i32 1
%8 = load i16, i16* %7, align 2
%7 = getelementptr inbounds %Test, ptr %4, i32 0, i32 1
%8 = load i16, ptr %7, align 2
%sisiext = sext i16 %8 to i32
%add1 = add i32 %add, %sisiext
%9 = getelementptr inbounds %Test, %Test* %a, i32 0, i32 2
%10 = load i32, i32* %9, align 4
%9 = getelementptr inbounds %Test, ptr %4, i32 0, i32 2
%10 = load i32, ptr %9, align 4
%add2 = add i32 %add1, %10
ret i32 %add2
}
; Function Attrs: nounwind
define i32 @test_test3(i64 %0, i32 %1, i64 %2, i32 %3) #0 {
entry:
%4 = alloca { i64, i32 }, align 8
%5 = alloca { i64, i32 }, align 8
%a = bitcast { i64, i32 }* %4 to %Test*
%6 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %4, i32 0, i32 0
store i64 %0, i64* %6, align 8
%7 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %4, i32 0, i32 1
store i32 %1, i32* %7, align 8
%b = bitcast { i64, i32 }* %5 to %Test*
%8 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %5, i32 0, i32 0
store i64 %2, i64* %8, align 8
%9 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %5, i32 0, i32 1
store i32 %3, i32* %9, align 8
%10 = getelementptr inbounds %Test, %Test* %a, i32 0, i32 1
%11 = load i16, i16* %10, align 2
%6 = getelementptr inbounds { i64, i32 }, ptr %4, i32 0, i32 0
store i64 %0, ptr %6, align 8
%7 = getelementptr inbounds { i64, i32 }, ptr %4, i32 0, i32 1
store i32 %1, ptr %7, align 8
%8 = getelementptr inbounds { i64, i32 }, ptr %5, i32 0, i32 0
store i64 %2, ptr %8, align 8
%9 = getelementptr inbounds { i64, i32 }, ptr %5, i32 0, i32 1
store i32 %3, ptr %9, align 8
%10 = getelementptr inbounds %Test, ptr %4, i32 0, i32 1
%11 = load i16, ptr %10, align 2
%sisiext = sext i16 %11 to i32
%12 = getelementptr inbounds %Test, %Test* %a, i32 0, i32 2
%13 = load i32, i32* %12, align 4
%12 = getelementptr inbounds %Test, ptr %4, i32 0, i32 2
%13 = load i32, ptr %12, align 4
%add = add i32 %sisiext, %13
%14 = getelementptr inbounds %Test, %Test* %b, i32 0, i32 2
%15 = load i32, i32* %14, align 4
%14 = getelementptr inbounds %Test, ptr %5, i32 0, i32 2
%15 = load i32, ptr %14, align 4
%add1 = add i32 %add, %15
%16 = getelementptr inbounds %Test, %Test* %b, i32 0, i32 3
%17 = load i32, i32* %16, align 8
%16 = getelementptr inbounds %Test, ptr %5, i32 0, i32 3
%17 = load i32, ptr %16, align 8
%add2 = add i32 %add1, %17
ret i32 %add2
}
; Function Attrs: nounwind
define { i64, i32 } @test_test4(i64 %0, i32 %1) #0 {
entry:
%2 = alloca { i64, i32 }, align 8
%tempcoerce = alloca { i64, i32 }, align 8
%a = bitcast { i64, i32 }* %2 to %Test*
%3 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %2, i32 0, i32 0
store i64 %0, i64* %3, align 8
%4 = getelementptr inbounds { i64, i32 }, { i64, i32 }* %2, i32 0, i32 1
store i32 %1, i32* %4, align 8
%5 = bitcast { i64, i32 }* %tempcoerce to i8*
%6 = bitcast %Test* %a to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %5, i8* align 8 %6, i32 12, i1 false)
%7 = load { i64, i32 }, { i64, i32 }* %tempcoerce, align 8
ret { i64, i32 } %7
%3 = getelementptr inbounds { i64, i32 }, ptr %2, i32 0, i32 0
store i64 %0, ptr %3, align 8
%4 = getelementptr inbounds { i64, i32 }, ptr %2, i32 0, i32 1
store i32 %1, ptr %4, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %tempcoerce, ptr align 8 %2, i32 12, i1 false)
%5 = load { i64, i32 }, ptr %tempcoerce, align 8
ret { i64, i32 } %5
}
; Function Attrs: nounwind
define i32 @test_test6() #0 {
entry:
%b = alloca [200 x i32], align 16
%0 = bitcast [200 x i32]* %b to i8*
call void @llvm.memset.p0i8.i64(i8* align 16 %0, i8 0, i64 800, i1 false)
%1 = getelementptr inbounds [200 x i32], [200 x i32]* %b, i64 0, i64 4
%2 = load i32, i32* %1, align 4
ret i32 %2
call void @llvm.memset.p0.i64(ptr align 16 %b, i8 0, i64 800, i1 false)
%0 = getelementptr inbounds [200 x i32], ptr %b, i64 0, i64 4
%1 = load i32, ptr %0, align 4
ret i32 %1
}
; Function Attrs: nounwind
define void @test_test7(%STest2* noalias sret(%STest2) align 8 %0, %STest2* byval(%STest2) align 8 %1) #0 {
define void @test_test7(ptr noalias sret(%STest2) align 8 %0, ptr byval(%STest2) align 8 %1) #0 {
entry:
%2 = bitcast %STest2* %0 to i8*
%3 = bitcast %STest2* %1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %2, i8* align 8 %3, i32 24, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %1, i32 24, i1 false)
ret void
}
; Function Attrs: nounwind
declare i32 @printf(i8*, ...) #0
declare i32 @printf(ptr, ...) #0
; Function Attrs: nounwind
define i32 @test_main2() #0 {
entry:
%v = alloca i64, align 8
store i64 123455678902, i64* %v, align 8
%0 = load i64, i64* %v, align 8
%1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i32 0, i32 0), i64 %0)
store i64 123455678902, ptr %v, align 8
%0 = load i64, ptr %v, align 8
%1 = call i32 (ptr, ...) @printf(ptr @.str.6, i64 %0)
ret i32 1
}

28
test/test_suite/clang/2002-03.c3t
View File

@@ -55,41 +55,43 @@ fn char* foo() {
@test_a = local_unnamed_addr global { i32, i32, [8 x i32] } { i32 0, i32 2, [8 x i32] zeroinitializer }, align 16
@test_str = local_unnamed_addr global [10 x i8] c"x\00\00\00\00\00\00\00\00\00", align 1
@test_arr = local_unnamed_addr global { i8*, i8*, [3 x i8*] } zeroinitializer, align 16
@test_arr = local_unnamed_addr global { ptr, ptr, [3 x ptr] } zeroinitializer, align 16
@test_f = local_unnamed_addr global { float, float, [10 x float] } { float 0x3FF3AE1480000000, float 0x40415999A0000000, [10 x float] zeroinitializer }, align 16
@test_array = local_unnamed_addr global { %Test, %Test, [8 x %Test] } { %Test { i32 2, double 1.200000e+01 }, %Test { i32 3, double 2.400000e+01 }, [8 x %Test] zeroinitializer }, align 16
@test_b = local_unnamed_addr global { [4 x i32], { i32, i32, i32, i32 }, { i32, i32, [2 x i32] }, [4 x i32] } { [4 x i32] [i32 1, i32 2, i32 3, i32 4], { i32, i32, i32, i32 } { i32 5, i32 6, i32 7, i32 0 }, { i32, i32, [2 x i32] } { i32 8, i32 9, [2 x i32] zeroinitializer }, [4 x i32] zeroinitializer }, align 16
@test_link = local_unnamed_addr global [3 x %Connection] [%Connection { i64 1, [10 x i8] c"link1\00\00\00\00\00", i64 10 }, %Connection { i64 2, [10 x i8] c"link2\00\00\00\00\00", i64 20 }, %Connection { i64 3, [10 x i8] c"link3\00\00\00\00\00", i64 30 }], align 16
@.str = private unnamed_addr constant [4 x i8] c"\1F\C2\8B\00", align 1
@.str.7 = private unnamed_addr constant [32 x i8] c"*** Word \22%s\22 on line %d is not\00", align 1
declare i32 @test_strcmp(i8*, i8*) #0
declare i32 @test_strcmp(ptr, ptr) #0
define i32 @test_test(i8* %0) #0 {
define i32 @test_test(ptr %0) #0 {
entry:
%1 = call i32 @test_strcmp(i8* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0))
%1 = call i32 @test_strcmp(ptr %0, ptr @.str)
ret i32 %1
}
define i32 @test_trys(i8* %0, i32 %1) #0 {
define i32 @test_trys(ptr %0, i32 %1) #0 {
entry:
%asa = alloca i32, align 4
%val = alloca double, align 8
%lLS = alloca i32, align 4
store i32 0, i32* %asa, align 4
store double 0.000000e+00, double* %val, align 8
store i32 0, i32* %lLS, align 4
store i32 0, ptr %asa, align 4
store double 0.000000e+00, ptr %val, align 8
store i32 0, ptr %lLS, align 4
%intbool = icmp ne i32 %1, 0
br i1 %intbool, label %if.then, label %if.exit
if.then: ; preds = %entry
%2 = load i32, i32* %lLS, align 4
%3 = load i32, i32* %asa, align 4
%2 = load i32, ptr %lLS, align 4
%3 = load i32, ptr %asa, align 4
%add = add i32 %2, %3
store i32 %add, i32* %asa, align 4
store i32 %add, ptr %asa, align 4
br label %if.exit
if.exit: ; preds = %if.then, %entry
%4 = load i32, i32* %asa, align 4
%5 = load double, double* %val, align 8
%4 = load i32, ptr %asa, align 4
%5 = load double, ptr %val, align 8
%fpsi = fptosi double %5 to i32
%add1 = add i32 %4, %fpsi
ret i32 %add1

73
test/test_suite/clang/2002-04.c3t
View File

@@ -80,11 +80,11 @@ loop.cond: ; preds = %switch.exit, %entry
loop.body: ; preds = %loop.cond
%1 = call i32 @foo()
store i32 %1, i32* %switch, align 4
store i32 %1, ptr %switch, align 4
br label %switch.entry
switch.entry: ; preds = %loop.body
%2 = load i32, i32* %switch, align 4
%2 = load i32, ptr %switch, align 4
switch i32 %2, label %switch.exit [
i32 0, label %switch.case
i32 1, label %switch.case
@@ -96,11 +96,11 @@ switch.entry: ; preds = %loop.body
]
switch.case: ; preds = %switch.entry, %switch.entry, %switch.entry, %switch.entry
%3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i32 0, i32 0))
%3 = call i32 (ptr, ...) @printf(ptr @.str)
br label %switch.case1
switch.case1: ; preds = %switch.entry, %switch.case
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0))
%4 = call i32 (ptr, ...) @printf(ptr @.str.1)
br label %switch.exit
switch.exit: ; preds = %switch.entry, %switch.entry, %switch.case1, %switch.entry
@@ -110,70 +110,55 @@ loop.exit: ; preds = %loop.cond
ret i32 0
}
; Function Attrs: nounwind
define double @test_test(i32 %0) #0 {
entry:
%student_t = alloca [30 x double], align 16
%1 = bitcast [30 x double]* %student_t to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %1, i8* align 16 bitcast ([30 x double]* @.__const to i8*), i32 240, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %student_t, ptr align 16 @.__const, i32 240, i1 false)
%zext = zext i32 %0 to i64
%2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %zext
%3 = load double, double* %2, align 8
ret double %3
%1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %zext
%2 = load double, ptr %1, align 8
ret double %2
}
; Function Attrs: nounwind
declare i64 @func_returning_struct() #0
; Function Attrs: nounwind
define void @test_loop() #0 {
entry:
%result = alloca %St, align 4
%0 = call i64 @func_returning_struct()
%1 = bitcast %St* %result to i64*
store i64 %0, i64* %1, align 4
store i64 %0, ptr %result, align 4
ret void
}
; Function Attrs: nounwind
declare i32 @testF(%FooSt* byval(%FooSt) align 8, float) #0
declare i32 @testF(ptr byval(%FooSt) align 8, float) #0
; Function Attrs: nounwind
declare i32 @testE(i8 zeroext, i16 signext, i8 zeroext, i32, i32, float) #0
; Function Attrs: nounwind
define void @test_test3(%FooSt* %0) #0 {
define void @test_test3(ptr %0) #0 {
entry:
%1 = getelementptr inbounds %FooSt, %FooSt* %0, i32 0, i32 1
store i16 1, i16* %1, align 2
%1 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 1
store i16 1, ptr %1, align 2
ret void
}
; Function Attrs: nounwind
define void @test_test2(%FooSt* byval(%FooSt) align 8 %0) #0 {
define void @test_test2(ptr byval(%FooSt) align 8 %0) #0 {
entry:
%indirectarg = alloca %FooSt, align 8
%indirectarg1 = alloca %FooSt, align 8
%1 = getelementptr inbounds %FooSt, %FooSt* %0, i32 0, i32 0
%2 = load i8, i8* %1, align 4
%3 = getelementptr inbounds %FooSt, %FooSt* %0, i32 0, i32 1
%4 = load i16, i16* %3, align 2
%5 = getelementptr inbounds %FooSt, %FooSt* %0, i32 0, i32 2
%6 = load i8, i8* %5, align 4
%7 = getelementptr inbounds %FooSt, %FooSt* %0, i32 0, i32 3
%8 = load i32, i32* %7, align 4
%9 = getelementptr inbounds %FooSt, %FooSt* %0, i32 0, i32 4
%10 = load i16, i16* %9, align 4
%1 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 0
%2 = load i8, ptr %1, align 4
%3 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 1
%4 = load i16, ptr %3, align 2
%5 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 2
%6 = load i8, ptr %5, align 4
%7 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 3
%8 = load i32, ptr %7, align 4
%9 = getelementptr inbounds %FooSt, ptr %0, i32 0, i32 4
%10 = load i16, ptr %9, align 4
%sisiext = sext i16 %10 to i32
%11 = call i32 @testE(i8 %2, i16 %4, i8 %6, i32 %8, i32 %sisiext, float 0x3FB99999A0000000)
%12 = bitcast %FooSt* %indirectarg to i8*
%13 = bitcast %FooSt* %0 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %12, i8* align 4 %13, i32 20, i1 false)
%14 = call i32 @testF(%FooSt* byval(%FooSt) align 8 %indirectarg, float 0x3FB99999A0000000)
%15 = bitcast %FooSt* %indirectarg1 to i8*
%16 = bitcast %FooSt* %0 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %15, i8* align 4 %16, i32 20, i1 false)
call void @test_test2(%FooSt* byval(%FooSt) align 8 %indirectarg1)
call void @test_test3(%FooSt* %0)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg, ptr align 4 %0, i32 20, i1 false)
%12 = call i32 @testF(ptr byval(%FooSt) align 8 %indirectarg, float 0x3FB99999A0000000)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %indirectarg1, ptr align 4 %0, i32 20, i1 false)
call void @test_test2(ptr byval(%FooSt) align 8 %indirectarg1)
call void @test_test3(ptr %0)
ret void
}

138
test/test_suite/compile_time/compile_time_access_subscript.c3t
View File

@@ -39,84 +39,72 @@ fn void main()
check_type(Bdd);
check_type(int[2]);
check_type(int[]);
io::printfln("%d", $b[0].m11);
io::printfn("%d", $b[0].m11);
}
/* #expect: test.ll
%z = alloca i32, align 4
%z1 = alloca %Abc, align 4
%z2 = alloca i64, align 8
%z3 = alloca i32, align 4
%z4 = alloca i32*, align 8
%z5 = alloca i8, align 1
%z6 = alloca i64, align 8
%z7 = alloca <3 x i32>, align 16
%z8 = alloca %Abc, align 4
%z9 = alloca [2 x i32], align 4
%z10 = alloca %"int[]", align 8
%retparam = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%literal = alloca %Abc, align 4
%taddr = alloca %"variant[]", align 8
store i32 0, i32* %z, align 4
%0 = getelementptr inbounds %Abc, %Abc* %z1, i32 0, i32 0
store float 0.000000e+00, float* %0, align 4
%1 = getelementptr inbounds %Abc, %Abc* %z1, i32 0, i32 1
store float 0.000000e+00, float* %1, align 4
%2 = getelementptr inbounds %Abc, %Abc* %z1, i32 0, i32 2
store float 0.000000e+00, float* %2, align 4
%3 = getelementptr inbounds %Abc, %Abc* %z1, i32 0, i32 3
store float 0.000000e+00, float* %3, align 4
store i64 0, i64* %z2, align 8
store i32 0, i32* %z3, align 4
store i32* null, i32** %z4, align 8
store i8 0, i8* %z5, align 1
store i64 0, i64* %z6, align 8
store <3 x i32> zeroinitializer, <3 x i32>* %z7, align 16
%4 = getelementptr inbounds %Abc, %Abc* %z8, i32 0, i32 0
store float 0.000000e+00, float* %4, align 4
%5 = getelementptr inbounds %Abc, %Abc* %z8, i32 0, i32 1
store float 0.000000e+00, float* %5, align 4
%6 = getelementptr inbounds %Abc, %Abc* %z8, i32 0, i32 2
store float 0.000000e+00, float* %6, align 4
%7 = getelementptr inbounds %Abc, %Abc* %z8, i32 0, i32 3
store float 0.000000e+00, float* %7, align 4
%8 = getelementptr inbounds [2 x i32], [2 x i32]* %z9, i64 0, i64 0
store i32 0, i32* %8, align 4
%9 = getelementptr inbounds [2 x i32], [2 x i32]* %z9, i64 0, i64 1
store i32 0, i32* %9, align 4
%10 = bitcast %"int[]"* %z10 to i8*
call void @llvm.memset.p0i8.i64(i8* align 8 %10, i8 0, i64 16, i1 false)
%11 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 0
store float 0.000000e+00, float* %11, align 4
%12 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 1
store float 0.000000e+00, float* %12, align 4
%13 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 2
store float 0.000000e+00, float* %13, align 4
%14 = getelementptr inbounds %Abc, %Abc* %literal, i32 0, i32 3
store float 0.000000e+00, float* %14, align 4
%15 = bitcast %Abc* %literal to i8*
%16 = insertvalue %variant undef, i8* %15, 0
%17 = insertvalue %variant %16, i64 ptrtoint (%.introspect* @"ct$test_Abc" to i64), 1
%18 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
store %variant %17, %variant* %18, align 16
%19 = bitcast [1 x %variant]* %varargslots to %variant*
%20 = insertvalue %"variant[]" undef, %variant* %19, 0
%21 = insertvalue %"variant[]" %20, i64 1, 1
store %"variant[]" %21, %"variant[]"* %taddr, align 8
%22 = bitcast %"variant[]"* %taddr to { i8*, i64 }*
%23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 0
%lo = load i8*, i8** %23, align 8
%24 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %22, i32 0, i32 1
%hi = load i64, i64* %24, align 8
%25 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi)
%not_err = icmp eq i64 %25, 0
br i1 %not_err, label %after_check, label %voiderr
%z = alloca i32, align 4
%z1 = alloca %Abc, align 4
%z2 = alloca i64, align 8
%z3 = alloca i32, align 4
%z4 = alloca ptr, align 8
%z5 = alloca i8, align 1
%z6 = alloca i64, align 8
%z7 = alloca <3 x i32>, align 16
%z8 = alloca %Abc, align 4
%z9 = alloca [2 x i32], align 4
%z10 = alloca %"int[]", align 8
%retparam = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%literal = alloca %Abc, align 4
store i32 0, ptr %z, align 4
%0 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 0
store float 0.000000e+00, ptr %0, align 4
%1 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 1
store float 0.000000e+00, ptr %1, align 4
%2 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 2
store float 0.000000e+00, ptr %2, align 4
%3 = getelementptr inbounds %Abc, ptr %z1, i32 0, i32 3
store float 0.000000e+00, ptr %3, align 4
store i64 0, ptr %z2, align 8
store i32 0, ptr %z3, align 4
store ptr null, ptr %z4, align 8
store i8 0, ptr %z5, align 1
store i64 0, ptr %z6, align 8
store <3 x i32> zeroinitializer, ptr %z7, align 16
%4 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 0
store float 0.000000e+00, ptr %4, align 4
%5 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 1
store float 0.000000e+00, ptr %5, align 4
%6 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 2
store float 0.000000e+00, ptr %6, align 4
%7 = getelementptr inbounds %Abc, ptr %z8, i32 0, i32 3
store float 0.000000e+00, ptr %7, align 4
%8 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 0
store i32 0, ptr %8, align 4
%9 = getelementptr inbounds [2 x i32], ptr %z9, i64 0, i64 1
store i32 0, ptr %9, align 4
call void @llvm.memset.p0.i64(ptr align 8 %z10, i8 0, i64 16, i1 false)
%10 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 0
store float 0.000000e+00, ptr %10, align 4
%11 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 1
store float 0.000000e+00, ptr %11, align 4
%12 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 2
store float 0.000000e+00, ptr %12, align 4
%13 = getelementptr inbounds %Abc, ptr %literal, i32 0, i32 3
store float 0.000000e+00, ptr %13, align 4
%14 = insertvalue %variant undef, ptr %literal, 0
%15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$test_Abc" to i64), 1
%16 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %15, ptr %16, align 16
%17 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
%not_err = icmp eq i64 %17, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
ret void
}
voiderr: ; preds = %after_check, %entry
ret void
}

9
test/test_suite/compile_time/compile_time_array.c3t
View File

@@ -13,17 +13,16 @@ fn void test()
/* #expect: test.ll
%"char[]" = type { i8*, i64 }
%"char[]" = type { ptr, i64 }
@.str = private unnamed_addr constant [2 x i8] c"a\00", align 1
; Function Attrs: nounwind
define void @test_test() #0 {
entry:
%x = alloca i32, align 4
%z = alloca %"char[]", align 8
store i32 1, i32* %x, align 4
store %"char[]" { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i32 0, i32 0), i64 1 }, %"char[]"* %z, align 8
store i32 1, ptr %x, align 4
store %"char[]" { ptr @.str, i64 1 }, ptr %z, align 8
ret void
}

10
test/test_suite/compile_time/compile_time_array_ref.c3t
View File

@@ -13,12 +13,6 @@ fn void test()
/* #expect: foo.ll
@foo_stack = local_unnamed_addr global [8192 x i8] zeroinitializer, align 16
@foo_x = local_unnamed_addr global i8* getelementptr inbounds ([8192 x i8], [8192 x i8]* @foo_stack, i64 0, i64 1000), align 8
@foo_x = local_unnamed_addr global ptr getelementptr (i8, ptr @foo_stack, i64 1000), align 8
@"test$y" = internal unnamed_addr global [2 x i8] zeroinitializer, align 1
@"test$z" = internal unnamed_addr global i8* getelementptr inbounds ([2 x i8], [2 x i8]* @"test$y", i64 0, i64 1), align 8
; Function Attrs: nounwind
define void @foo_test() #0 {
entry:
ret void
}
@"test$z" = internal unnamed_addr global ptr getelementptr inbounds ([2 x i8], ptr @"test$y", i64 0, i64 1), align 8

10
test/test_suite/compile_time/compile_time_pointers.c3t
View File

@@ -24,12 +24,12 @@ fn void test()
/* #expect: test.ll
@test_ABC = local_unnamed_addr constant i64 531, align 8
@test_BAC = local_unnamed_addr constant i8* inttoptr (i64 143 to i8*), align 8
@test_EXX = local_unnamed_addr constant i8* inttoptr (i64 155 to i8*), align 8
@test_BAC = local_unnamed_addr constant ptr inttoptr (i64 143 to ptr), align 8
@test_EXX = local_unnamed_addr constant ptr inttoptr (i64 155 to ptr), align 8
@test_KEX = local_unnamed_addr constant i64 -12, align 8
@test_CAB = local_unnamed_addr constant i8* inttoptr (i64 143 to i8*), align 8
@test_CAB = local_unnamed_addr constant ptr inttoptr (i64 143 to ptr), align 8
@test_ZAB = local_unnamed_addr constant i64 143, align 8
@test_BOB = local_unnamed_addr constant i32* inttoptr (i64 12 to i32*), align 8
@test_BAB = local_unnamed_addr constant i32* inttoptr (i64 20 to i32*), align 8
@test_BOB = local_unnamed_addr constant ptr inttoptr (i64 12 to ptr), align 8
@test_BAB = local_unnamed_addr constant ptr inttoptr (i64 20 to ptr), align 8
@test_AO = local_unnamed_addr constant i64 2, align 8
@test_abc = local_unnamed_addr global i32 123, align 4

16
test/test_suite/compile_time/compile_time_ptr_ref.c3t
View File

@@ -9,14 +9,14 @@ int* c3 = (int*)(4 + (iptr)(&ptr));
iptr ff = (iptr)(&ptr);
int ptr = 0;
// #expect: test.ll
/* #expect: test.ll
%"int*[]" = type { i32**, i64 }
%"int*[]" = type { ptr, i64 }
@.taddr = private global [5 x i32*] [i32* @test_ptr, i32* @test_ptr, i32* getelementptr inbounds (i32, i32* @test_ptr, i64 1), i32* getelementptr (i32, i32* @test_ptr, i64 -1), i32* bitcast (i8* getelementptr (i8, i8* bitcast (i32* @test_ptr to i8*), i64 -4) to i32*)], align 8
@test_blurp = local_unnamed_addr global %"int*[]" { i32** getelementptr inbounds ([5 x i32*], [5 x i32*]* @.taddr, i32 0, i32 0), i64 5 }, align 8
@test_c = local_unnamed_addr global i32* bitcast (i8* getelementptr (i8, i8* bitcast (i32* @test_ptr to i8*), i64 -4) to i32*), align 8
@test_c2 = local_unnamed_addr global i32* bitcast (i8* getelementptr (i8, i8* bitcast (i32* @test_ptr to i8*), i64 4) to i32*), align 8
@test_c3 = local_unnamed_addr global i32* bitcast (i8* getelementptr (i8, i8* bitcast (i32* @test_ptr to i8*), i64 4) to i32*), align 8
@test_ff = local_unnamed_addr global i64 ptrtoint (i32* @test_ptr to i64), align 8
@.taddr = private global [5 x ptr] [ptr @test_ptr, ptr @test_ptr, ptr getelementptr inbounds (i32, ptr @test_ptr, i64 1), ptr getelementptr (i32, ptr @test_ptr, i64 -1), ptr getelementptr (i8, ptr @test_ptr, i64 -4)], align 8
@test_blurp = local_unnamed_addr global %"int*[]" { ptr @.taddr, i64 5 }, align 8
@test_c = local_unnamed_addr global ptr getelementptr (i8, ptr @test_ptr, i64 -4), align 8
@test_c2 = local_unnamed_addr global ptr getelementptr (i8, ptr @test_ptr, i64 4), align 8
@test_c3 = local_unnamed_addr global ptr getelementptr (i8, ptr @test_ptr, i64 4), align 8
@test_ff = local_unnamed_addr global i64 ptrtoint (ptr @test_ptr to i64), align 8
@test_ptr = global i32 0, align 4

116
test/test_suite/compile_time/ct_builtin_time_date.c3t
View File

@@ -4,11 +4,11 @@ import std::io;
macro printline()
{
io::printfln("%d", $$LINE); io::printfln("%d", $$LINE_RAW);
io::printfn("%d", $$LINE); io::printfn("%d", $$LINE_RAW);
}
fn void test(int x)
{
io::printfln("%d", x);
io::printfn("%d", x);
if (x > 0) $$FUNCTION(x - 1);
io::println($$TIME);
io::println($$DATE);
@@ -26,37 +26,25 @@ fn void main()
/* #expect: test.ll
define void @test_test(i32 %0) #0 {
entry:
%retparam = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%taddr = alloca i32, align 4
%taddr1 = alloca %"variant[]", align 8
%retparam2 = alloca i64, align 8
%varargslots3 = alloca [1 x %variant], align 16
%taddr4 = alloca i64, align 8
%taddr5 = alloca %"variant[]", align 8
%retparam11 = alloca i64, align 8
%varargslots12 = alloca [1 x %variant], align 16
%taddr13 = alloca i64, align 8
%taddr14 = alloca %"variant[]", align 8
store i32 %0, i32* %taddr, align 4
%1 = bitcast i32* %taddr to i8*
%2 = insertvalue %variant undef, i8* %1, 0
%3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
store %variant %3, %variant* %4, align 16
%5 = bitcast [1 x %variant]* %varargslots to %variant*
%6 = insertvalue %"variant[]" undef, %variant* %5, 0
%7 = insertvalue %"variant[]" %6, i64 1, 1
store %"variant[]" %7, %"variant[]"* %taddr1, align 8
%8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }*
%9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0
%lo = load i8*, i8** %9, align 8
%10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1
%hi = load i64, i64* %10, align 8
%11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi)
%not_err = icmp eq i64 %11, 0
%retparam1 = alloca i64, align 8
%varargslots2 = alloca [1 x %variant], align 16
%taddr3 = alloca i64, align 8
%retparam7 = alloca i64, align 8
%varargslots8 = alloca [1 x %variant], align 16
%taddr9 = alloca i64, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
%2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
%3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %2, ptr %3, align 16
%4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
%not_err = icmp eq i64 %4, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
@@ -72,55 +60,35 @@ if.then: ; preds = %voiderr
br label %if.exit
if.exit: ; preds = %if.then, %voiderr
%12 = call i32 @std_io_println(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0)) #1
%13 = call i32 @std_io_println(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0)) #1
store i64 14, i64* %taddr4, align 8
%14 = bitcast i64* %taddr4 to i8*
%15 = insertvalue %variant undef, i8* %14, 0
%16 = insertvalue %variant %15, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1
%17 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots3, i64 0, i64 0
store %variant %16, %variant* %17, align 16
%18 = bitcast [1 x %variant]* %varargslots3 to %variant*
%19 = insertvalue %"variant[]" undef, %variant* %18, 0
%20 = insertvalue %"variant[]" %19, i64 1, 1
store %"variant[]" %20, %"variant[]"* %taddr5, align 8
%21 = bitcast %"variant[]"* %taddr5 to { i8*, i64 }*
%22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 0
%lo6 = load i8*, i8** %22, align 8
%23 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %21, i32 0, i32 1
%hi7 = load i64, i64* %23, align 8
%24 = call i64 @std_io_printfln(i64* %retparam2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i64 2, i8* %lo6, i64 %hi7)
%not_err8 = icmp eq i64 %24, 0
br i1 %not_err8, label %after_check9, label %voiderr10
%5 = call i32 @std_io_println(ptr @.str.1) #1
%6 = call i32 @std_io_println(ptr @.str.2) #1
store i64 14, ptr %taddr3, align 8
%7 = insertvalue %variant undef, ptr %taddr3, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$long" to i64), 1
%9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
store %variant %8, ptr %9, align 16
%10 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.3, i64 2, ptr %varargslots2, i64 1)
%not_err4 = icmp eq i64 %10, 0
br i1 %not_err4, label %after_check5, label %voiderr6
after_check9: ; preds = %if.exit
br label %voiderr10
after_check5: ; preds = %if.exit
br label %voiderr6
voiderr10: ; preds = %after_check9, %if.exit
store i64 6, i64* %taddr13, align 8
%25 = bitcast i64* %taddr13 to i8*
%26 = insertvalue %variant undef, i8* %25, 0
%27 = insertvalue %variant %26, i64 ptrtoint (%.introspect* @"ct$long" to i64), 1
%28 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots12, i64 0, i64 0
store %variant %27, %variant* %28, align 16
%29 = bitcast [1 x %variant]* %varargslots12 to %variant*
%30 = insertvalue %"variant[]" undef, %variant* %29, 0
%31 = insertvalue %"variant[]" %30, i64 1, 1
store %"variant[]" %31, %"variant[]"* %taddr14, align 8
%32 = bitcast %"variant[]"* %taddr14 to { i8*, i64 }*
%33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0
%lo15 = load i8*, i8** %33, align 8
%34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1
%hi16 = load i64, i64* %34, align 8
%35 = call i64 @std_io_printfln(i64* %retparam11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i64 2, i8* %lo15, i64 %hi16)
%not_err17 = icmp eq i64 %35, 0
br i1 %not_err17, label %after_check18, label %voiderr19
voiderr6: ; preds = %after_check5, %if.exit
store i64 6, ptr %taddr9, align 8
%11 = insertvalue %variant undef, ptr %taddr9, 0
%12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$long" to i64), 1
%13 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
store %variant %12, ptr %13, align 16
%14 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.4, i64 2, ptr %varargslots8, i64 1)
%not_err10 = icmp eq i64 %14, 0
br i1 %not_err10, label %after_check11, label %voiderr12
after_check18: ; preds = %voiderr10
br label %voiderr19
after_check11: ; preds = %voiderr6
br label %voiderr12
voiderr19: ; preds = %after_check18, %voiderr10
%36 = call i32 @std_io_println(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.5, i32 0, i32 0)) #1
%37 = call i32 @std_io_println(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0)) #1
voiderr12: ; preds = %after_check11, %voiderr6
%15 = call i32 @std_io_println(ptr @.str.5) #1
%16 = call i32 @std_io_println(ptr @.str.6) #1
ret void
}

2
test/test_suite/compile_time/ct_checks.c3t
View File

@@ -10,7 +10,7 @@ fn void main()
bool c = $checks(int z = 23, $y += 23, &c);
bool d = $checks(&c, $y, int yy = 23);
int z = $y;
io::printfln("%s %s %s", b, $y, c);
io::printfn("%s %s %s", b, $y, c);
}
/* #expect: test.ll

6
test/test_suite/compile_time/ct_enum_values.c3t
View File

@@ -23,8 +23,8 @@ fn void main()
entry:
%x = alloca i32, align 4
store i32 0, i32* %x, align 4
store i32 0, i32* %x, align 4
store i32 1, i32* %x, align 4
store i32 0, ptr %x, align 4
store i32 0, ptr %x, align 4
store i32 1, ptr %x, align 4
ret void
}

8
test/test_suite/compile_time/ct_eval.c3t
View File

@@ -14,9 +14,9 @@ fn void main()
define void @test_main() #0 {
entry:
%abc = alloca i32, align 4
store i32 20, i32* %abc, align 4
store i32 444, i32* %abc, align 4
%0 = load i32, i32* %abc, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i32 0, i32 0), i32 %0)
store i32 20, ptr %abc, align 4
store i32 444, ptr %abc, align 4
%0 = load i32, ptr %abc, align 4
call void (ptr, ...) @printf(ptr @.str, i32 %0)
ret void
}

14
test/test_suite/compile_time/ct_for.c3t
View File

@@ -21,12 +21,12 @@ fn void main()
define void @test_main() #0 {
entry:
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 0)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i32 0, i32 0), i32 1)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0), i32 2)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i32 0, i32 100)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i32 0, i32 0), i32 1, i32 99)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i32 2, i32 98)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), i32 3, i32 97)
call void (ptr, ...) @printf(ptr @.str, i32 0)
call void (ptr, ...) @printf(ptr @.str.1, i32 1)
call void (ptr, ...) @printf(ptr @.str.2, i32 2)
call void (ptr, ...) @printf(ptr @.str.3, i32 0, i32 100)
call void (ptr, ...) @printf(ptr @.str.4, i32 1, i32 99)
call void (ptr, ...) @printf(ptr @.str.5, i32 2, i32 98)
call void (ptr, ...) @printf(ptr @.str.6, i32 3, i32 97)
ret void
}

32
test/test_suite/compile_time/ct_foreach.c3t
View File

@@ -31,22 +31,22 @@ fn void main()
define void @test_main() #0 {
entry:
%z = alloca i32, align 4
%z1 = alloca [3 x i8]*, align 8
%z1 = alloca ptr, align 8
%z2 = alloca i32, align 4
%z3 = alloca [5 x i8]*, align 8
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 1)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i32 0, i32 0), i32 10)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0), i32 34)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i32 0, i32 1)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i32 0, i32 0), i32 1, i32 10)
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i32 0, i32 0), i32 2, i32 34)
store i32 123, i32* %z, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i32 0, i32 0), i32 123)
store [3 x i8]* bitcast ([4 x i8]* @.str.7 to [3 x i8]*), [3 x i8]** %z1, align 8
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0), [3 x i8]* bitcast ([4 x i8]* @.str.9 to [3 x i8]*))
store i32 1177, i32* %z2, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i32 0, i32 0), i32 1177)
store [5 x i8]* bitcast ([6 x i8]* @.str.11 to [5 x i8]*), [5 x i8]** %z3, align 8
call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.12, i32 0, i32 0), [5 x i8]* bitcast ([6 x i8]* @.str.13 to [5 x i8]*))
%z3 = alloca ptr, align 8
call void (ptr, ...) @printf(ptr @.str, i32 1)
call void (ptr, ...) @printf(ptr @.str.1, i32 10)
call void (ptr, ...) @printf(ptr @.str.2, i32 34)
call void (ptr, ...) @printf(ptr @.str.3, i32 0, i32 1)
call void (ptr, ...) @printf(ptr @.str.4, i32 1, i32 10)
call void (ptr, ...) @printf(ptr @.str.5, i32 2, i32 34)
store i32 123, ptr %z, align 4
call void (ptr, ...) @printf(ptr @.str.6, i32 123)
store ptr @.str.7, ptr %z1, align 8
call void (ptr, ...) @printf(ptr @.str.8, ptr @.str.9)
store i32 1177, ptr %z2, align 4
call void (ptr, ...) @printf(ptr @.str.10, i32 1177)
store ptr @.str.11, ptr %z3, align 8
call void (ptr, ...) @printf(ptr @.str.12, ptr @.str.13)
ret void
}

35
test/test_suite/compile_time/ct_funcptr.c3t
View File

@@ -5,7 +5,7 @@ import std::io;
fn void test(int x)
{
$typeof(&$$FUNCTION) ptr = &$$FUNCTION;
io::printfln("%d", x);
io::printfn("%d", x);
if (x > 0) ptr(x - 1);
}
@@ -18,29 +18,18 @@ fn void main()
define void @test_test(i32 %0) #0 {
entry:
%ptr = alloca void (i32)*, align 8
%ptr = alloca ptr, align 8
%retparam = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%taddr = alloca i32, align 4
%taddr1 = alloca %"variant[]", align 8
store void (i32)* @test_test, void (i32)** %ptr, align 8
store i32 %0, i32* %taddr, align 4
%1 = bitcast i32* %taddr to i8*
%2 = insertvalue %variant undef, i8* %1, 0
%3 = insertvalue %variant %2, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%4 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0
store %variant %3, %variant* %4, align 16
%5 = bitcast [1 x %variant]* %varargslots to %variant*
%6 = insertvalue %"variant[]" undef, %variant* %5, 0
%7 = insertvalue %"variant[]" %6, i64 1, 1
store %"variant[]" %7, %"variant[]"* %taddr1, align 8
%8 = bitcast %"variant[]"* %taddr1 to { i8*, i64 }*
%9 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 0
%lo = load i8*, i8** %9, align 8
%10 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %8, i32 0, i32 1
%hi = load i64, i64* %10, align 8
%11 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i64 2, i8* %lo, i64 %hi)
%not_err = icmp eq i64 %11, 0
store ptr @test_test, ptr %ptr, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
%2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
%3 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %2, ptr %3, align 16
%4 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1)
%not_err = icmp eq i64 %4, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
@@ -51,9 +40,9 @@ voiderr: ; preds = %after_check, %entry
br i1 %gt, label %if.then, label %if.exit
if.then: ; preds = %voiderr
%12 = load void (i32)*, void (i32)** %ptr, align 8
%5 = load ptr, ptr %ptr, align 8
%sub = sub i32 %0, 1
call void %12(i32 %sub)
call void %5(i32 %sub)
br label %if.exit
if.exit: ; preds = %if.then, %voiderr

1186
test/test_suite/compile_time/ct_memberof.c3t
View File

File diff suppressed because it is too large Load Diff

14
test/test_suite/compile_time/ct_switch.c3t
View File

@@ -49,15 +49,17 @@ fn void main()
@.str.7 = private unnamed_addr constant [14 x i8] c"donnowifprime\00", align 1
@.str.8 = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
@.str.9 = private unnamed_addr constant [14 x i8] c"donnowifprime\00", align 1
; Function Attrs: nounwind
declare void @printf(i8*, ...) #0
declare void @printf(ptr, ...) #0
; Function Attrs: nounwind
define void @test_main() #0 {
entry:
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), [5 x i8]* bitcast ([6 x i8]* @.str.1 to [5 x i8]*))
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), [9 x i8]* bitcast ([10 x i8]* @.str.3 to [9 x i8]*))
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), [9 x i8]* bitcast ([10 x i8]* @.str.5 to [9 x i8]*))
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0), [13 x i8]* bitcast ([14 x i8]* @.str.7 to [13 x i8]*))
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i32 0, i32 0), [13 x i8]* bitcast ([14 x i8]* @.str.9 to [13 x i8]*))
call void (ptr, ...) @printf(ptr @.str, ptr @.str.1)
call void (ptr, ...) @printf(ptr @.str.2, ptr @.str.3)
call void (ptr, ...) @printf(ptr @.str.4, ptr @.str.5)
call void (ptr, ...) @printf(ptr @.str.6, ptr @.str.7)
call void (ptr, ...) @printf(ptr @.str.8, ptr @.str.9)
ret void
}

10
test/test_suite/compile_time/ct_switch_top_level.c3t
View File

@@ -45,10 +45,10 @@ entry:
%z = alloca i32, align 4
%z1 = alloca i32, align 4
%i = alloca i32, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0))
store i32 0, i32* %z, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i32 0, i32 0))
store i32 0, i32* %z1, align 4
store i32 1, i32* %i, align 4
call void (ptr, ...) @printf(ptr @.str)
store i32 0, ptr %z, align 4
call void (ptr, ...) @printf(ptr @.str.1)
store i32 0, ptr %z1, align 4
store i32 1, ptr %i, align 4
ret i32 1
}

10
test/test_suite/compile_time/ct_switch_type_check.c3t
View File

@@ -32,13 +32,15 @@ fn void main()
@.str.3 = private unnamed_addr constant [7 x i8] c"double\00", align 1
@.str.4 = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
@.str.5 = private unnamed_addr constant [10 x i8] c"any other\00", align 1
; Function Attrs: nounwind
declare void @printf(i8*, ...) #0
declare void @printf(ptr, ...) #0
; Function Attrs: nounwind
define void @test_main() #0 {
entry:
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), [3 x i8]* bitcast ([4 x i8]* @.str.1 to [3 x i8]*))
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), [6 x i8]* bitcast ([7 x i8]* @.str.3 to [6 x i8]*))
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), [9 x i8]* bitcast ([10 x i8]* @.str.5 to [9 x i8]*))
call void (ptr, ...) @printf(ptr @.str, ptr @.str.1)
call void (ptr, ...) @printf(ptr @.str.2, ptr @.str.3)
call void (ptr, ...) @printf(ptr @.str.4, ptr @.str.5)
ret void
}

2
test/test_suite/compile_time/cttype_reassign.c3t
View File

@@ -11,5 +11,5 @@ fn void test()
// #expect: reassign.ll
%hello = alloca i32, align 4
store i32 0, i32* %hello, align 4
store i32 0, ptr %hello, align 4
ret void

48
test/test_suite/compile_time/stringify.c3t
View File

@@ -45,20 +45,20 @@ fn void main()
define void @test_test() #0 {
entry:
%i = alloca i32, align 4
store i32 0, i32* %i, align 4
store i32 0, ptr %i, align 4
br label %loop.cond
loop.cond: ; preds = %loop.body, %entry
%0 = load i32, i32* %i, align 4
%0 = load i32, ptr %i, align 4
%lt = icmp slt i32 %0, 1000
br i1 %lt, label %loop.body, label %loop.exit
loop.body: ; preds = %loop.cond
%1 = load i32, i32* %i, align 4
%2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %1)
%3 = load i32, i32* %i, align 4
%1 = load i32, ptr %i, align 4
%2 = call i32 (ptr, ...) @printf(ptr @.str, i32 %1)
%3 = load i32, ptr %i, align 4
%add = add i32 %3, 1
store i32 %add, i32* %i, align 4
store i32 %add, ptr %i, align 4
br label %loop.cond
loop.exit: ; preds = %loop.cond
@@ -75,34 +75,34 @@ entry:
%result = alloca i32, align 4
%diff2 = alloca i64, align 8
%0 = call i64 @clock()
store i64 %0, i64* %t, align 8
store i64 %0, ptr %t, align 8
call void @test_test()
%1 = call i64 @clock()
%2 = load i64, i64* %t, align 8
%2 = load i64, ptr %t, align 8
%sub = sub i64 %1, %2
store i64 %sub, i64* %diff, align 8
%3 = load i64, i64* %diff, align 8
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i32 0, i32 0), [6 x i8]* bitcast ([7 x i8]* @.str.2 to [6 x i8]*), i64 %3)
store i32 100, i32* %a, align 4
store i64 %sub, ptr %diff, align 8
%3 = load i64, ptr %diff, align 8
%4 = call i32 (ptr, ...) @printf(ptr @.str.1, ptr @.str.2, i64 %3)
store i32 100, ptr %a, align 4
%5 = call i64 @clock()
store i64 %5, i64* %t1, align 8
%6 = load i32, i32* %a, align 4
store i64 %5, ptr %t1, align 8
%6 = load i32, ptr %a, align 4
%add = add i32 4, %6
store i32 %add, i32* %result, align 4
store i32 %add, ptr %result, align 4
%7 = call i64 @clock()
%8 = load i64, i64* %t1, align 8
%8 = load i64, ptr %t1, align 8
%sub3 = sub i64 %7, %8
store i64 %sub3, i64* %diff2, align 8
%9 = load i64, i64* %diff2, align 8
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.3, i32 0, i32 0), [9 x i8]* bitcast ([10 x i8]* @.str.4 to [9 x i8]*), i64 %9)
%11 = load i32, i32* %result, align 4
store i32 %11, i32* %x, align 4
%12 = load i32, i32* %x, align 4
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i32 0, i32 0), i32 %12)
store i64 %sub3, ptr %diff2, align 8
%9 = load i64, ptr %diff2, align 8
%10 = call i32 (ptr, ...) @printf(ptr @.str.3, ptr @.str.4, i64 %9)
%11 = load i32, ptr %result, align 4
store i32 %11, ptr %x, align 4
%12 = load i32, ptr %x, align 4
%13 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %12)
ret void
}
define i32 @main(i32 %0, i8** %1) #0 {
define i32 @main(i32 %0, ptr %1) #0 {
entry:
call void @test_main()
ret i32 0

6
test/test_suite/compile_time/stringify2.c3t
View File

@@ -8,9 +8,9 @@ fn void main()
char[*] s2 = $stringify($s1);
char[] s3 = $s1;
io::printfln("$s1 == %s", $s1);
io::printfln("s2 == %s", &s2);
io::printfln("s3 == %s", s3);
io::printfn("$s1 == %s", $s1);
io::printfn("s2 == %s", &s2);
io::printfn("s3 == %s", s3);
}
/* #expect: test.ll

2
test/test_suite/compile_time/ternary_folding.c3t
View File

@@ -20,6 +20,6 @@ fn int test2() { return 3; }
define void @ternary_folding_test() #0 {
entry:
%x = alloca i32, align 4
store i32 0, i32* %x, align 4
store i32 0, ptr %x, align 4
ret void
}

70
test/test_suite/compile_time/typeof_example.c3t
View File

@@ -15,40 +15,38 @@ fn void main()
printf("Bitcast %f to %d to %f", f, i, f2);
}
// #expect: typeof_example.ll
/* #expect: typeof_example.ll
%f = alloca float, align 4
%i = alloca i32, align 4
%value = alloca float, align 4
%temp = alloca float, align 4
%result = alloca i32*, align 8
%f2 = alloca float, align 4
%value1 = alloca i32, align 4
%temp2 = alloca i32, align 4
%result3 = alloca float*, align 8
store float 1.000000e+02, float* %f, align 4
%0 = load float, float* %f, align 4
store float %0, float* %value, align 4
%1 = load float, float* %value, align 4
store float %1, float* %temp, align 4
%ptrptr = bitcast float* %temp to i32*
store i32* %ptrptr, i32** %result, align 8
%2 = load i32*, i32** %result, align 8
%3 = load i32, i32* %2, align 8
store i32 %3, i32* %i, align 4
%4 = load i32, i32* %i, align 4
store i32 %4, i32* %value1, align 4
%5 = load i32, i32* %value1, align 4
store i32 %5, i32* %temp2, align 4
%ptrptr4 = bitcast i32* %temp2 to float*
store float* %ptrptr4, float** %result3, align 8
%6 = load float*, float** %result3, align 8
%7 = load float, float* %6, align 8
store float %7, float* %f2, align 4
%8 = load float, float* %f, align 4
%fpfpext = fpext float %8 to double
%9 = load i32, i32* %i, align 4
%10 = load float, float* %f2, align 4
%fpfpext5 = fpext float %10 to double
call void (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i32 0, i32 0), double %fpfpext, i32 %9, double %fpfpext5)
ret void
%f = alloca float, align 4
%i = alloca i32, align 4
%value = alloca float, align 4
%temp = alloca float, align 4
%result = alloca ptr, align 8
%f2 = alloca float, align 4
%value1 = alloca i32, align 4
%temp2 = alloca i32, align 4
%result3 = alloca ptr, align 8
store float 1.000000e+02, ptr %f, align 4
%0 = load float, ptr %f, align 4
store float %0, ptr %value, align 4
%1 = load float, ptr %value, align 4
store float %1, ptr %temp, align 4
store ptr %temp, ptr %result, align 8
%2 = load ptr, ptr %result, align 8
%3 = load i32, ptr %2, align 8
store i32 %3, ptr %i, align 4
%4 = load i32, ptr %i, align 4
store i32 %4, ptr %value1, align 4
%5 = load i32, ptr %value1, align 4
store i32 %5, ptr %temp2, align 4
store ptr %temp2, ptr %result3, align 8
%6 = load ptr, ptr %result3, align 8
%7 = load float, ptr %6, align 8
store float %7, ptr %f2, align 4
%8 = load float, ptr %f, align 4
%fpfpext = fpext float %8 to double
%9 = load i32, ptr %i, align 4
%10 = load float, ptr %f2, align 4
%fpfpext4 = fpext float %10 to double
call void (ptr, ...) @printf(ptr @.str, double %fpfpext, i32 %9, double %fpfpext4)
ret void

210
test/test_suite/compile_time/untyped_conversions.c3t
View File

@@ -7,7 +7,7 @@ struct Foo
}
fn void test(int[2] a, int[] b, int[<2>] c)
{
io::printfln("%s %s %s", a, b, c);
io::printfn("%s %s %s", a, b, c);
}
fn void main()
{
@@ -16,7 +16,7 @@ fn void main()
Foo def = (Foo)$x[0];
int[2][1] y = (int[2][1])$x;
double[2][1] y2 = $x;
io::printfln("%s %s {%s, %s}", y, y2, def.a, def.b);
io::printfn("%s %s {%s, %s}", y, y2, def.a, def.b);
test({ 1, 2 }, { 3, 4}, { 5, 6 });
var $a = { 2, 7 };
test($a, $a, $a);
@@ -24,6 +24,66 @@ fn void main()
/* #expect: test.ll
%.introspect = type { i8, i64, i64, i64, [0 x i64] }
%Foo = type { i32, i32 }
%"int[]" = type { ptr, i64 }
%variant = type { ptr, i64 }
@"ct$test_Foo" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@.str = private unnamed_addr constant [9 x i8] c"%s %s %s\00", align 1
@"ct$int" = linkonce constant %.introspect { i8 2, i64 4, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
@"ct$a2$int" = linkonce constant %.introspect { i8 15, i64 8, i64 ptrtoint (ptr @"ct$int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
@"ct$sa$int" = linkonce constant %.introspect { i8 16, i64 16, i64 ptrtoint (ptr @"ct$int" to i64), i64 0, [0 x i64] zeroinitializer }, align 8
@"ct$v2$int" = linkonce constant %.introspect { i8 17, i64 8, i64 ptrtoint (ptr @"ct$int" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
@.__const = private unnamed_addr constant [1 x %Foo] [%Foo { i32 1, i32 2 }], align 4
@.__const.1 = private unnamed_addr constant %Foo { i32 1, i32 2 }, align 4
@.__const.2 = private unnamed_addr constant [1 x [2 x i32]] [[2 x i32] [i32 1, i32 2]], align 4
@.__const.3 = private unnamed_addr constant [1 x [2 x double]] [[2 x double] [double 1.000000e+00, double 2.000000e+00]], align 16
@.str.4 = private unnamed_addr constant [15 x i8] c"%s %s {%s, %s}\00", align 1
@"ct$a1$a2$int" = linkonce constant %.introspect { i8 15, i64 8, i64 ptrtoint (ptr @"ct$a2$int" to i64), i64 1, [0 x i64] zeroinitializer }, align 8
@"ct$double" = linkonce constant %.introspect { i8 4, i64 8, i64 0, i64 0, [0 x i64] zeroinitializer }, align 8
@"ct$a2$double" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"ct$double" to i64), i64 2, [0 x i64] zeroinitializer }, align 8
@"ct$a1$a2$double" = linkonce constant %.introspect { i8 15, i64 16, i64 ptrtoint (ptr @"ct$a2$double" to i64), i64 1, [0 x i64] zeroinitializer }, align 8
; Function Attrs: nounwind
define void @test_test(i64 %0, ptr %1, i64 %2, double %3) #0 {
entry:
%a = alloca [2 x i32], align 4
%b = alloca %"int[]", align 8
%c = alloca <2 x i32>, align 8
%retparam = alloca i64, align 8
%varargslots = alloca [3 x %variant], align 16
store i64 %0, ptr %a, align 4
%4 = getelementptr inbounds { ptr, i64 }, ptr %b, i32 0, i32 0
store ptr %1, ptr %4, align 8
%5 = getelementptr inbounds { ptr, i64 }, ptr %b, i32 0, i32 1
store i64 %2, ptr %5, align 8
store double %3, ptr %c, align 8
%6 = insertvalue %variant undef, ptr %a, 0
%7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$a2$int" to i64), 1
%8 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %7, ptr %8, align 16
%9 = insertvalue %variant undef, ptr %b, 0
%10 = insertvalue %variant %9, i64 ptrtoint (ptr @"ct$sa$int" to i64), 1
%11 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 1
store %variant %10, ptr %11, align 16
%12 = insertvalue %variant undef, ptr %c, 0
%13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$v2$int" to i64), 1
%14 = getelementptr inbounds [3 x %variant], ptr %varargslots, i64 0, i64 2
store %variant %13, ptr %14, align 16
%15 = call i64 @std_io_printfn(ptr %retparam, ptr @.str, i64 8, ptr %varargslots, i64 3)
%not_err = icmp eq i64 %15, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
ret void
}
; Function Attrs: nounwind
define void @test_main() #0 {
entry:
%abc = alloca [1 x %Foo], align 4
%def = alloca %Foo, align 4
@@ -31,107 +91,65 @@ entry:
%y2 = alloca [1 x [2 x double]], align 16
%retparam = alloca i64, align 8
%varargslots = alloca [4 x %variant], align 16
%taddr = alloca %"variant[]", align 8
%literal = alloca [2 x i32], align 4
%literal1 = alloca [2 x i32], align 4
%taddr2 = alloca %"int[]", align 8
%taddr5 = alloca <2 x i32>, align 8
%literal6 = alloca [2 x i32], align 4
%literal7 = alloca [2 x i32], align 4
%taddr8 = alloca %"int[]", align 8
%taddr11 = alloca <2 x i32>, align 8
%0 = bitcast [1 x %Foo]* %abc to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([1 x %Foo]* @.__const to i8*), i32 8, i1 false)
%1 = bitcast %Foo* %def to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %1, i8* align 4 bitcast (%Foo* @.__const.1 to i8*), i32 8, i1 false)
%2 = bitcast [1 x [2 x i32]]* %y to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 bitcast ([1 x [2 x i32]]* @.__const.2 to i8*), i32 8, i1 false)
%3 = bitcast [1 x [2 x double]]* %y2 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %3, i8* align 16 bitcast ([1 x [2 x double]]* @.__const.3 to i8*), i32 16, i1 false)
%4 = bitcast [1 x [2 x i32]]* %y to i8*
%5 = insertvalue %variant undef, i8* %4, 0
%6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$a1$a2$int" to i64), 1
%7 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 0
store %variant %6, %variant* %7, align 16
%8 = bitcast [1 x [2 x double]]* %y2 to i8*
%9 = insertvalue %variant undef, i8* %8, 0
%10 = insertvalue %variant %9, i64 ptrtoint (%.introspect* @"ct$a1$a2$double" to i64), 1
%11 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 1
store %variant %10, %variant* %11, align 16
%12 = getelementptr inbounds %Foo, %Foo* %def, i32 0, i32 0
%13 = bitcast i32* %12 to i8*
%14 = insertvalue %variant undef, i8* %13, 0
%15 = insertvalue %variant %14, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%16 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 2
store %variant %15, %variant* %16, align 16
%17 = getelementptr inbounds %Foo, %Foo* %def, i32 0, i32 1
%18 = bitcast i32* %17 to i8*
%19 = insertvalue %variant undef, i8* %18, 0
%20 = insertvalue %variant %19, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1
%21 = getelementptr inbounds [4 x %variant], [4 x %variant]* %varargslots, i64 0, i64 3
store %variant %20, %variant* %21, align 16
%22 = bitcast [4 x %variant]* %varargslots to %variant*
%23 = insertvalue %"variant[]" undef, %variant* %22, 0
%24 = insertvalue %"variant[]" %23, i64 4, 1
store %"variant[]" %24, %"variant[]"* %taddr, align 8
%25 = bitcast %"variant[]"* %taddr to { i8*, i64 }*
%26 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 0
%lo = load i8*, i8** %26, align 8
%27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %25, i32 0, i32 1
%hi = load i64, i64* %27, align 8
%28 = call i64 @std_io_printfln(i64* %retparam, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i32 0, i32 0), i64 14, i8* %lo, i64 %hi)
%not_err = icmp eq i64 %28, 0
%taddr = alloca <2 x i32>, align 8
%literal2 = alloca [2 x i32], align 4
%literal3 = alloca [2 x i32], align 4
%taddr4 = alloca <2 x i32>, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %abc, ptr align 4 @.__const, i32 8, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %def, ptr align 4 @.__const.1, i32 8, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 @.__const.2, i32 8, i1 false)
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %y2, ptr align 16 @.__const.3, i32 16, i1 false)
%0 = insertvalue %variant undef, ptr %y, 0
%1 = insertvalue %variant %0, i64 ptrtoint (ptr @"ct$a1$a2$int" to i64), 1
%2 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %1, ptr %2, align 16
%3 = insertvalue %variant undef, ptr %y2, 0
%4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$a1$a2$double" to i64), 1
%5 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 1
store %variant %4, ptr %5, align 16
%6 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 0
%7 = insertvalue %variant undef, ptr %6, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$int" to i64), 1
%9 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 2
store %variant %8, ptr %9, align 16
%10 = getelementptr inbounds %Foo, ptr %def, i32 0, i32 1
%11 = insertvalue %variant undef, ptr %10, 0
%12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$int" to i64), 1
%13 = getelementptr inbounds [4 x %variant], ptr %varargslots, i64 0, i64 3
store %variant %12, ptr %13, align 16
%14 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.4, i64 14, ptr %varargslots, i64 4)
%not_err = icmp eq i64 %14, 0
br i1 %not_err, label %after_check, label %voiderr
after_check: ; preds = %entry
br label %voiderr
voiderr: ; preds = %after_check, %entry
%29 = getelementptr inbounds [2 x i32], [2 x i32]* %literal, i64 0, i64 0
store i32 1, i32* %29, align 4
%30 = getelementptr inbounds [2 x i32], [2 x i32]* %literal, i64 0, i64 1
store i32 2, i32* %30, align 4
%31 = bitcast [2 x i32]* %literal to i64*
%32 = load i64, i64* %31, align 4
%33 = getelementptr inbounds [2 x i32], [2 x i32]* %literal1, i64 0, i64 0
store i32 3, i32* %33, align 4
%34 = getelementptr inbounds [2 x i32], [2 x i32]* %literal1, i64 0, i64 1
store i32 4, i32* %34, align 4
%35 = bitcast [2 x i32]* %literal1 to i32*
%36 = insertvalue %"int[]" undef, i32* %35, 0
%37 = insertvalue %"int[]" %36, i64 2, 1
store %"int[]" %37, %"int[]"* %taddr2, align 8
%38 = bitcast %"int[]"* %taddr2 to { i8*, i64 }*
%39 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 0
%lo3 = load i8*, i8** %39, align 8
%40 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %38, i32 0, i32 1
%hi4 = load i64, i64* %40, align 8
store <2 x i32> <i32 5, i32 6>, <2 x i32>* %taddr5, align 8
%41 = bitcast <2 x i32>* %taddr5 to double*
%42 = load double, double* %41, align 8
call void @test_test(i64 %32, i8* %lo3, i64 %hi4, double %42)
%43 = getelementptr inbounds [2 x i32], [2 x i32]* %literal6, i64 0, i64 0
store i32 2, i32* %43, align 4
%44 = getelementptr inbounds [2 x i32], [2 x i32]* %literal6, i64 0, i64 1
store i32 7, i32* %44, align 4
%45 = bitcast [2 x i32]* %literal6 to i64*
%46 = load i64, i64* %45, align 4
%47 = getelementptr inbounds [2 x i32], [2 x i32]* %literal7, i64 0, i64 0
store i32 2, i32* %47, align 4
%48 = getelementptr inbounds [2 x i32], [2 x i32]* %literal7, i64 0, i64 1
store i32 7, i32* %48, align 4
%49 = bitcast [2 x i32]* %literal7 to i32*
%50 = insertvalue %"int[]" undef, i32* %49, 0
%51 = insertvalue %"int[]" %50, i64 2, 1
store %"int[]" %51, %"int[]"* %taddr8, align 8
%52 = bitcast %"int[]"* %taddr8 to { i8*, i64 }*
%53 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 0
%lo9 = load i8*, i8** %53, align 8
%54 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %52, i32 0, i32 1
%hi10 = load i64, i64* %54, align 8
store <2 x i32> <i32 2, i32 7>, <2 x i32>* %taddr11, align 8
%55 = bitcast <2 x i32>* %taddr11 to double*
%56 = load double, double* %55, align 8
call void @test_test(i64 %46, i8* %lo9, i64 %hi10, double %56)
%15 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 0
store i32 1, ptr %15, align 4
%16 = getelementptr inbounds [2 x i32], ptr %literal, i64 0, i64 1
store i32 2, ptr %16, align 4
%17 = load i64, ptr %literal, align 4
%18 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 0
store i32 3, ptr %18, align 4
%19 = getelementptr inbounds [2 x i32], ptr %literal1, i64 0, i64 1
store i32 4, ptr %19, align 4
store <2 x i32> <i32 5, i32 6>, ptr %taddr, align 8
%20 = load double, ptr %taddr, align 8
call void @test_test(i64 %17, ptr %literal1, i64 2, double %20)
%21 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 0
store i32 2, ptr %21, align 4
%22 = getelementptr inbounds [2 x i32], ptr %literal2, i64 0, i64 1
store i32 7, ptr %22, align 4
%23 = load i64, ptr %literal2, align 4
%24 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 0
store i32 2, ptr %24, align 4
%25 = getelementptr inbounds [2 x i32], ptr %literal3, i64 0, i64 1
store i32 7, ptr %25, align 4
store <2 x i32> <i32 2, i32 7>, ptr %taddr4, align 8
%26 = load double, ptr %taddr4, align 8
call void @test_test(i64 %23, ptr %literal3, i64 2, double %26)
ret void
}

42
test/test_suite/compile_time_introspection/defined.c3t
View File

@@ -59,39 +59,39 @@ fn void main()
printf("%d\n", x);
}
// #expect: mymodule.ll
/* #expect: mymodule.ll
define void @mymodule_main() #0 {
entry:
%x = alloca i32, align 4
%y = alloca i32, align 4
%z = alloca i32, align 4
store i32 0, i32* %x, align 4
%0 = load i32, i32* %x, align 4
store i32 0, ptr %x, align 4
%0 = load i32, ptr %x, align 4
%add = add i32 %0, 1
store i32 %add, i32* %x, align 4
store i32 10, i32* %y, align 4
%1 = load i32, i32* %x, align 4
store i32 %add, ptr %x, align 4
store i32 10, ptr %y, align 4
%1 = load i32, ptr %x, align 4
%add1 = add i32 %1, 1
store i32 %add1, i32* %x, align 4
%2 = load i32, i32* %x, align 4
store i32 %add1, ptr %x, align 4
%2 = load i32, ptr %x, align 4
%add2 = add i32 %2, 1
store i32 %add2, i32* %x, align 4
%3 = load i32, i32* %x, align 4
store i32 %add2, ptr %x, align 4
%3 = load i32, ptr %x, align 4
%add3 = add i32 %3, 1
store i32 %add3, i32* %x, align 4
%4 = load i32, i32* %x, align 4
store i32 %add3, ptr %x, align 4
%4 = load i32, ptr %x, align 4
%add4 = add i32 %4, 1
store i32 %add4, i32* %x, align 4
%5 = load i32, i32* %x, align 4
store i32 %add4, ptr %x, align 4
%5 = load i32, ptr %x, align 4
%add5 = add i32 %5, 1
store i32 %add5, i32* %x, align 4
%6 = load i32, i32* %x, align 4
store i32 %add5, ptr %x, align 4
%6 = load i32, ptr %x, align 4
%add6 = add i32 %6, 1
store i32 %add6, i32* %x, align 4
store i32 1, i32* %y, align 4
store i32 7, i32* %z, align 4
%7 = load i32, i32* %x, align 4
call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %7)
store i32 %add6, ptr %x, align 4
store i32 1, ptr %y, align 4
store i32 7, ptr %z, align 4
%7 = load i32, ptr %x, align 4
call void (ptr, ...) @printf(ptr @.str, i32 %7)
ret void
}

4
test/test_suite/compile_time_introspection/defined_builtin.c3t
View File

@@ -12,7 +12,7 @@ define void @foo_test() #0 {
entry:
%a = alloca i8, align 1
%b = alloca i8, align 1
store i8 1, i8* %a, align 1
store i8 0, i8* %b, align 1
store i8 1, ptr %a, align 1
store i8 0, ptr %b, align 1
ret void
}

29
test/test_suite/compile_time_introspection/qnameof.c3t
View File

@@ -1,3 +1,4 @@
// #target: macos-x64
module qnametest;
extern fn int printf(char *, ...);
@@ -19,8 +20,10 @@ fn void main()
printf("Blob**[3]: %s\n", Blob**[3].nameof);
}
// #expect: qnametest.ll
/* #expect: qnametest.ll
@"ct$qnametest_Blob" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@qnametest_x = local_unnamed_addr global i32 0, align 4
@.str = private unnamed_addr constant [12 x i8] c"printf: %s\0A\00", align 1
@.str.1 = private unnamed_addr constant [7 x i8] c"printf\00", align 1
@.str.2 = private unnamed_addr constant [13 x i8] c"printfq: %s\0A\00", align 1
@@ -40,16 +43,18 @@ fn void main()
@.str.16 = private unnamed_addr constant [15 x i8] c"Blob**[3]: %s\0A\00", align 1
@.str.17 = private unnamed_addr constant [10 x i8] c"Blob**[3]\00", align 1
define void @qnametest_main()
define void @qnametest_main() #0 {
entry:
%help = alloca i32, align 4
store i32 0, i32* %help, align 4
%0 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), [6 x i8]* bitcast ([7 x i8]* @.str.1 to [6 x i8]*))
%1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i32 0, i32 0), [17 x i8]* bitcast ([18 x i8]* @.str.3 to [17 x i8]*))
%2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i32 0, i32 0), [15 x i8]* bitcast ([16 x i8]* @.str.5 to [15 x i8]*))
%3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), [4 x i8]* bitcast ([5 x i8]* @.str.7 to [4 x i8]*))
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0), [12 x i8]* bitcast ([13 x i8]* @.str.9 to [12 x i8]*))
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.10, i32 0, i32 0), [1 x i8]* bitcast ([2 x i8]* @.str.11 to [1 x i8]*))
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.12, i32 0, i32 0), [4 x i8]* bitcast ([5 x i8]* @.str.13 to [4 x i8]*))
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.14, i32 0, i32 0), [15 x i8]* bitcast ([16 x i8]* @.str.15 to [15 x i8]*))
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.16, i32 0, i32 0), [9 x i8]* bitcast ([10 x i8]* @.str.17 to [9 x i8]*))
store i32 0, ptr %help, align 4
%0 = call i32 (ptr, ...) @printf(ptr @.str, ptr @.str.1)
%1 = call i32 (ptr, ...) @printf(ptr @.str.2, ptr @.str.3)
%2 = call i32 (ptr, ...) @printf(ptr @.str.4, ptr @.str.5)
%3 = call i32 (ptr, ...) @printf(ptr @.str.6, ptr @.str.7)
%4 = call i32 (ptr, ...) @printf(ptr @.str.8, ptr @.str.9)
%5 = call i32 (ptr, ...) @printf(ptr @.str.10, ptr @.str.11)
%6 = call i32 (ptr, ...) @printf(ptr @.str.12, ptr @.str.13)
%7 = call i32 (ptr, ...) @printf(ptr @.str.14, ptr @.str.15)
%8 = call i32 (ptr, ...) @printf(ptr @.str.16, ptr @.str.17)
ret void
}

1
test/test_suite/compile_time_introspection/sizeof.c3t
View File

@@ -1,5 +1,6 @@
module foo;
import bar;
import bar::abc;
long x = Baz.sizeof;
short y = $evaltype("Baz").sizeof;

8
test/test_suite/constants/const_var_copy.c3t
View File

@@ -19,11 +19,11 @@ entry:
%s = alloca i8, align 1
%zd = alloca i32, align 4
%sisiext = sext i32 %0 to i64
%1 = getelementptr inbounds [100 x i8], [100 x i8]* bitcast ({ [50 x i8], i8, [49 x i8] }* @foo_FOO to [100 x i8]*), i64 0, i64 %sisiext
%2 = load i8, i8* %1, align 1
store i8 %2, i8* %s, align 1
%1 = getelementptr inbounds [100 x i8], ptr @foo_FOO, i64 0, i64 %sisiext
%2 = load i8, ptr %1, align 1
store i8 %2, ptr %s, align 1
%sisiext1 = sext i32 %0 to i64
%3 = extractelement <4 x i32> <i32 1, i32 2, i32 3, i32 4>, i64 %sisiext1
store i32 %3, i32* %zd, align 4
store i32 %3, ptr %zd, align 4
ret void
}

Some files were not shown because too many files have changed in this diff Show More