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

Fix +a = 1 erronously being accepted. Refactorings.

Browse Source
This commit is contained in:
Christoffer Lerno
2025-01-05 02:24:11 +01:00
parent 86a674b87e
commit 07c59e6a6c
18 changed files with 304 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
test/test_suite/expressions/plus_int.c3
View File

@@ -18,3 +18,10 @@ fn void test3()
@ok(+a);
long b = +a; // #error: 'long!' to 'long'
}
fn void test4()
{
int a = 1;
+a = 3; // #error: An assignable expression
}

85
test/test_suite/slices/slice_to_slice_assign.c3t
View File

@@ -24,25 +24,22 @@ define void @test.main() #0 {
entry:
%z = alloca [7 x i32], align 16
%y = alloca [6 x i32], align 16
%taddr = alloca %"int[]", align 8
%varargslots = alloca [2 x %any], align 16
%retparam = alloca i64, align 8
%taddr6 = alloca %"int[]", align 8
%varargslots8 = alloca [2 x %any], align 16
%retparam10 = alloca i64, align 8
%varargslots5 = alloca [2 x %any], align 16
%retparam7 = alloca i64, align 8
%a = alloca %"int[][]", align 8
%literal = alloca [1 x %"int[]"], align 16
%literal11 = alloca [1 x i32], align 4
%literal8 = alloca [1 x i32], align 4
%b = alloca %"int[][]", align 8
%literal12 = alloca [1 x %"int[]"], align 16
%literal13 = alloca [1 x i32], align 4
%varargslots14 = alloca [1 x %any], align 16
%retparam15 = alloca i64, align 8
%taddr16 = alloca %"int[][]", align 8
%varargslots18 = alloca [1 x %any], align 16
%retparam19 = alloca i64, align 8
%varargslots21 = alloca [1 x %any], align 16
%retparam22 = alloca i64, align 8
%literal9 = alloca [1 x %"int[]"], align 16
%literal10 = alloca [1 x i32], align 4
%varargslots11 = alloca [1 x %any], align 16
%retparam12 = alloca i64, align 8
%varargslots13 = alloca [1 x %any], align 16
%retparam14 = alloca i64, align 8
%varargslots16 = alloca [1 x %any], align 16
%retparam17 = alloca i64, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 16 %z, ptr align 16 @.__const, i32 28, i1 false)
call void @llvm.memset.p0.i64(ptr align 16 %y, i8 0, i64 24, i1 false)
%ptradd = getelementptr inbounds i8, ptr %z, i64 12
@@ -53,9 +50,7 @@ entry:
%3 = insertvalue %"int[]" %2, i64 3, 1
%4 = extractvalue %"int[]" %3, 0
%5 = extractvalue %"int[]" %1, 0
store %"int[]" %1, ptr %taddr, align 8
%ptradd2 = getelementptr inbounds i8, ptr %taddr, i64 8
%6 = load i64, ptr %ptradd2, align 8
%6 = extractvalue %"int[]" %1, 1
%7 = mul i64 %6, 4
call void @llvm.memmove.p0.p0.i64(ptr align 4 %4, ptr align 4 %5, i64 %7, i1 false)
%8 = insertvalue %any undef, ptr %y, 0
@@ -63,48 +58,46 @@ entry:
store %any %9, ptr %varargslots, align 16
%10 = insertvalue %any undef, ptr %z, 0
%11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.a7$int" to i64), 1
%ptradd3 = getelementptr inbounds i8, ptr %varargslots, i64 16
store %any %11, ptr %ptradd3, align 16
%ptradd2 = getelementptr inbounds i8, ptr %varargslots, i64 16
store %any %11, ptr %ptradd2, align 16
%12 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
%ptradd4 = getelementptr inbounds i8, ptr %z, i64 20
%13 = insertvalue %"int[]" undef, ptr %ptradd4, 0
%ptradd3 = getelementptr inbounds i8, ptr %z, i64 20
%13 = insertvalue %"int[]" undef, ptr %ptradd3, 0
%14 = insertvalue %"int[]" %13, i64 2, 1
%ptradd5 = getelementptr inbounds i8, ptr %y, i64 16
%15 = insertvalue %"int[]" undef, ptr %ptradd5, 0
%ptradd4 = getelementptr inbounds i8, ptr %y, i64 16
%15 = insertvalue %"int[]" undef, ptr %ptradd4, 0
%16 = insertvalue %"int[]" %15, i64 2, 1
%17 = extractvalue %"int[]" %16, 0
%18 = extractvalue %"int[]" %14, 0
store %"int[]" %14, ptr %taddr6, align 8
%ptradd7 = getelementptr inbounds i8, ptr %taddr6, i64 8
%19 = load i64, ptr %ptradd7, align 8
%19 = extractvalue %"int[]" %14, 1
%20 = mul i64 %19, 4
call void @llvm.memmove.p0.p0.i64(ptr align 4 %17, ptr align 4 %18, i64 %20, i1 false)
%21 = insertvalue %any undef, ptr %y, 0
%22 = insertvalue %any %21, i64 ptrtoint (ptr @"$ct.a6$int" to i64), 1
store %any %22, ptr %varargslots8, align 16
store %any %22, ptr %varargslots5, align 16
%23 = insertvalue %any undef, ptr %z, 0
%24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.a7$int" to i64), 1
%ptradd9 = getelementptr inbounds i8, ptr %varargslots8, i64 16
store %any %24, ptr %ptradd9, align 16
%25 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.1, i64 5, ptr %varargslots8, i64 2)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal11, ptr align 4 @.__const.2, i32 4, i1 false)
%26 = insertvalue %"int[]" undef, ptr %literal11, 0
%ptradd6 = getelementptr inbounds i8, ptr %varargslots5, i64 16
store %any %24, ptr %ptradd6, align 16
%25 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 5, ptr %varargslots5, i64 2)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal8, ptr align 4 @.__const.2, i32 4, i1 false)
%26 = insertvalue %"int[]" undef, ptr %literal8, 0
%27 = insertvalue %"int[]" %26, i64 1, 1
store %"int[]" %27, ptr %literal, align 8
%28 = insertvalue %"int[][]" undef, ptr %literal, 0
%29 = insertvalue %"int[][]" %28, i64 1, 1
store %"int[][]" %29, ptr %a, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal13, ptr align 4 @.__const.3, i32 4, i1 false)
%30 = insertvalue %"int[]" undef, ptr %literal13, 0
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal10, ptr align 4 @.__const.3, i32 4, i1 false)
%30 = insertvalue %"int[]" undef, ptr %literal10, 0
%31 = insertvalue %"int[]" %30, i64 1, 1
store %"int[]" %31, ptr %literal12, align 8
%32 = insertvalue %"int[][]" undef, ptr %literal12, 0
store %"int[]" %31, ptr %literal9, align 8
%32 = insertvalue %"int[][]" undef, ptr %literal9, 0
%33 = insertvalue %"int[][]" %32, i64 1, 1
store %"int[][]" %33, ptr %b, align 8
%34 = insertvalue %any undef, ptr %a, 0
%35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
store %any %35, ptr %varargslots14, align 16
%36 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.4, i64 2, ptr %varargslots14, i64 1)
store %any %35, ptr %varargslots11, align 16
%36 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.4, i64 2, ptr %varargslots11, i64 1)
%37 = load %"int[][]", ptr %b, align 8
%38 = extractvalue %"int[][]" %37, 0
%39 = insertvalue %"int[][]" undef, ptr %38, 0
@@ -115,24 +108,22 @@ entry:
%44 = insertvalue %"int[][]" %43, i64 1, 1
%45 = extractvalue %"int[][]" %44, 0
%46 = extractvalue %"int[][]" %40, 0
store %"int[][]" %40, ptr %taddr16, align 8
%ptradd17 = getelementptr inbounds i8, ptr %taddr16, i64 8
%47 = load i64, ptr %ptradd17, align 8
%47 = extractvalue %"int[][]" %40, 1
%48 = mul i64 %47, 16
call void @llvm.memmove.p0.p0.i64(ptr align 8 %45, ptr align 8 %46, i64 %48, i1 false)
%49 = insertvalue %any undef, ptr %a, 0
%50 = insertvalue %any %49, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
store %any %50, ptr %varargslots18, align 16
%51 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 2, ptr %varargslots18, i64 1)
%ptradd20 = getelementptr inbounds i8, ptr %y, i64 8
%52 = insertvalue %"int[]" undef, ptr %ptradd20, 0
store %any %50, ptr %varargslots13, align 16
%51 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.5, i64 2, ptr %varargslots13, i64 1)
%ptradd15 = getelementptr inbounds i8, ptr %y, i64 8
%52 = insertvalue %"int[]" undef, ptr %ptradd15, 0
%53 = insertvalue %"int[]" %52, i64 3, 1
%54 = load %"int[][]", ptr %a, align 8
%55 = extractvalue %"int[][]" %54, 0
store %"int[]" %53, ptr %55, align 8
%56 = insertvalue %any undef, ptr %a, 0
%57 = insertvalue %any %56, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
store %any %57, ptr %varargslots21, align 16
%58 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 2, ptr %varargslots21, i64 1)
store %any %57, ptr %varargslots16, align 16
%58 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.6, i64 2, ptr %varargslots16, i64 1)
ret void
}

85
test/test_suite/slices/slice_to_slice_vector_assign.c3t
View File

@@ -25,25 +25,22 @@ define void @test.main() #0 {
entry:
%z = alloca <7 x i32>, align 32
%y = alloca <6 x i32>, align 32
%taddr = alloca %"int[]", align 8
%varargslots = alloca [2 x %any], align 16
%retparam = alloca i64, align 8
%taddr6 = alloca %"int[]", align 8
%varargslots8 = alloca [2 x %any], align 16
%retparam10 = alloca i64, align 8
%varargslots5 = alloca [2 x %any], align 16
%retparam7 = alloca i64, align 8
%a = alloca %"int[][]", align 8
%literal = alloca [1 x %"int[]"], align 16
%literal11 = alloca [1 x i32], align 4
%literal8 = alloca [1 x i32], align 4
%b = alloca %"int[][]", align 8
%literal12 = alloca [1 x %"int[]"], align 16
%literal13 = alloca [1 x i32], align 4
%varargslots14 = alloca [1 x %any], align 16
%retparam15 = alloca i64, align 8
%taddr16 = alloca %"int[][]", align 8
%varargslots18 = alloca [1 x %any], align 16
%retparam19 = alloca i64, align 8
%varargslots21 = alloca [1 x %any], align 16
%retparam22 = alloca i64, align 8
%literal9 = alloca [1 x %"int[]"], align 16
%literal10 = alloca [1 x i32], align 4
%varargslots11 = alloca [1 x %any], align 16
%retparam12 = alloca i64, align 8
%varargslots13 = alloca [1 x %any], align 16
%retparam14 = alloca i64, align 8
%varargslots16 = alloca [1 x %any], align 16
%retparam17 = alloca i64, align 8
store <7 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>, ptr %z, align 32
store <6 x i32> zeroinitializer, ptr %y, align 32
%ptradd = getelementptr inbounds i8, ptr %z, i64 12
@@ -54,9 +51,7 @@ entry:
%3 = insertvalue %"int[]" %2, i64 3, 1
%4 = extractvalue %"int[]" %3, 0
%5 = extractvalue %"int[]" %1, 0
store %"int[]" %1, ptr %taddr, align 8
%ptradd2 = getelementptr inbounds i8, ptr %taddr, i64 8
%6 = load i64, ptr %ptradd2, align 8
%6 = extractvalue %"int[]" %1, 1
%7 = mul i64 %6, 4
call void @llvm.memmove.p0.p0.i64(ptr align 4 %4, ptr align 4 %5, i64 %7, i1 false)
%8 = insertvalue %any undef, ptr %y, 0
@@ -64,48 +59,46 @@ entry:
store %any %9, ptr %varargslots, align 16
%10 = insertvalue %any undef, ptr %z, 0
%11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.v7$int" to i64), 1
%ptradd3 = getelementptr inbounds i8, ptr %varargslots, i64 16
store %any %11, ptr %ptradd3, align 16
%ptradd2 = getelementptr inbounds i8, ptr %varargslots, i64 16
store %any %11, ptr %ptradd2, align 16
%12 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 5, ptr %varargslots, i64 2)
%ptradd4 = getelementptr inbounds i8, ptr %z, i64 20
%13 = insertvalue %"int[]" undef, ptr %ptradd4, 0
%ptradd3 = getelementptr inbounds i8, ptr %z, i64 20
%13 = insertvalue %"int[]" undef, ptr %ptradd3, 0
%14 = insertvalue %"int[]" %13, i64 2, 1
%ptradd5 = getelementptr inbounds i8, ptr %y, i64 16
%15 = insertvalue %"int[]" undef, ptr %ptradd5, 0
%ptradd4 = getelementptr inbounds i8, ptr %y, i64 16
%15 = insertvalue %"int[]" undef, ptr %ptradd4, 0
%16 = insertvalue %"int[]" %15, i64 2, 1
%17 = extractvalue %"int[]" %16, 0
%18 = extractvalue %"int[]" %14, 0
store %"int[]" %14, ptr %taddr6, align 8
%ptradd7 = getelementptr inbounds i8, ptr %taddr6, i64 8
%19 = load i64, ptr %ptradd7, align 8
%19 = extractvalue %"int[]" %14, 1
%20 = mul i64 %19, 4
call void @llvm.memmove.p0.p0.i64(ptr align 4 %17, ptr align 4 %18, i64 %20, i1 false)
%21 = insertvalue %any undef, ptr %y, 0
%22 = insertvalue %any %21, i64 ptrtoint (ptr @"$ct.v6$int" to i64), 1
store %any %22, ptr %varargslots8, align 16
store %any %22, ptr %varargslots5, align 16
%23 = insertvalue %any undef, ptr %z, 0
%24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.v7$int" to i64), 1
%ptradd9 = getelementptr inbounds i8, ptr %varargslots8, i64 16
store %any %24, ptr %ptradd9, align 16
%25 = call i64 @std.io.printfn(ptr %retparam10, ptr @.str.1, i64 5, ptr %varargslots8, i64 2)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal11, ptr align 4 @.__const, i32 4, i1 false)
%26 = insertvalue %"int[]" undef, ptr %literal11, 0
%ptradd6 = getelementptr inbounds i8, ptr %varargslots5, i64 16
store %any %24, ptr %ptradd6, align 16
%25 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 5, ptr %varargslots5, i64 2)
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal8, ptr align 4 @.__const, i32 4, i1 false)
%26 = insertvalue %"int[]" undef, ptr %literal8, 0
%27 = insertvalue %"int[]" %26, i64 1, 1
store %"int[]" %27, ptr %literal, align 8
%28 = insertvalue %"int[][]" undef, ptr %literal, 0
%29 = insertvalue %"int[][]" %28, i64 1, 1
store %"int[][]" %29, ptr %a, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal13, ptr align 4 @.__const.2, i32 4, i1 false)
%30 = insertvalue %"int[]" undef, ptr %literal13, 0
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %literal10, ptr align 4 @.__const.2, i32 4, i1 false)
%30 = insertvalue %"int[]" undef, ptr %literal10, 0
%31 = insertvalue %"int[]" %30, i64 1, 1
store %"int[]" %31, ptr %literal12, align 8
%32 = insertvalue %"int[][]" undef, ptr %literal12, 0
store %"int[]" %31, ptr %literal9, align 8
%32 = insertvalue %"int[][]" undef, ptr %literal9, 0
%33 = insertvalue %"int[][]" %32, i64 1, 1
store %"int[][]" %33, ptr %b, align 8
%34 = insertvalue %any undef, ptr %a, 0
%35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
store %any %35, ptr %varargslots14, align 16
%36 = call i64 @std.io.printfn(ptr %retparam15, ptr @.str.3, i64 2, ptr %varargslots14, i64 1)
store %any %35, ptr %varargslots11, align 16
%36 = call i64 @std.io.printfn(ptr %retparam12, ptr @.str.3, i64 2, ptr %varargslots11, i64 1)
%37 = load %"int[][]", ptr %b, align 8
%38 = extractvalue %"int[][]" %37, 0
%39 = insertvalue %"int[][]" undef, ptr %38, 0
@@ -116,24 +109,22 @@ entry:
%44 = insertvalue %"int[][]" %43, i64 1, 1
%45 = extractvalue %"int[][]" %44, 0
%46 = extractvalue %"int[][]" %40, 0
store %"int[][]" %40, ptr %taddr16, align 8
%ptradd17 = getelementptr inbounds i8, ptr %taddr16, i64 8
%47 = load i64, ptr %ptradd17, align 8
%47 = extractvalue %"int[][]" %40, 1
%48 = mul i64 %47, 16
call void @llvm.memmove.p0.p0.i64(ptr align 8 %45, ptr align 8 %46, i64 %48, i1 false)
%49 = insertvalue %any undef, ptr %a, 0
%50 = insertvalue %any %49, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
store %any %50, ptr %varargslots18, align 16
%51 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.4, i64 2, ptr %varargslots18, i64 1)
%ptradd20 = getelementptr inbounds i8, ptr %y, i64 8
%52 = insertvalue %"int[]" undef, ptr %ptradd20, 0
store %any %50, ptr %varargslots13, align 16
%51 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.4, i64 2, ptr %varargslots13, i64 1)
%ptradd15 = getelementptr inbounds i8, ptr %y, i64 8
%52 = insertvalue %"int[]" undef, ptr %ptradd15, 0
%53 = insertvalue %"int[]" %52, i64 3, 1
%54 = load %"int[][]", ptr %a, align 8
%55 = extractvalue %"int[][]" %54, 0
store %"int[]" %53, ptr %55, align 8
%56 = insertvalue %any undef, ptr %a, 0
%57 = insertvalue %any %56, i64 ptrtoint (ptr @"$ct.sa$sa$int" to i64), 1
store %any %57, ptr %varargslots21, align 16
%58 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.5, i64 2, ptr %varargslots21, i64 1)
store %any %57, ptr %varargslots16, align 16
%58 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.5, i64 2, ptr %varargslots16, i64 1)
ret void
}

243
test/test_suite/statements/foreach_common.c3t
View File

@@ -76,22 +76,17 @@ entry:
%.anon38 = alloca i64, align 8
%a42 = alloca double, align 8
%.anon47 = alloca i64, align 8
%.anon48 = alloca i64, align 8
%a51 = alloca float, align 4
%.anon55 = alloca i64, align 8
%.anon56 = alloca i64, align 8
%a60 = alloca ptr, align 8
%.anon66 = alloca i64, align 8
%.anon67 = alloca i64, align 8
%i71 = alloca i64, align 8
%a72 = alloca float, align 4
%.anon76 = alloca i64, align 8
%.anon77 = alloca i64, align 8
%i81 = alloca i8, align 1
%a83 = alloca double, align 8
%.anon88 = alloca i64, align 8
%.anon89 = alloca i64, align 8
%a93 = alloca double, align 8
%a59 = alloca ptr, align 8
%.anon65 = alloca i64, align 8
%i69 = alloca i64, align 8
%a70 = alloca float, align 4
%.anon74 = alloca i64, align 8
%i78 = alloca i8, align 1
%a80 = alloca double, align 8
%.anon85 = alloca i64, align 8
%a89 = alloca double, align 8
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %foo, ptr align 4 @.__const, i32 12, i1 false)
store <3 x float> <float 2.000000e+00, float 4.500000e+00, float 8.000000e+00>, ptr %foo2, align 16
store i64 0, ptr %.anon, align 8
@@ -238,137 +233,127 @@ loop.body41: ; preds = %loop.cond39
br label %loop.cond39
loop.exit46: ; preds = %loop.cond39
store i64 3, ptr %.anon47, align 8
store i64 0, ptr %.anon48, align 8
br label %loop.cond49
store i64 0, ptr %.anon47, align 8
br label %loop.cond48
loop.cond49: ; preds = %loop.body50, %loop.exit46
%36 = load i64, ptr %.anon48, align 8
%37 = load i64, ptr %.anon47, align 8
%lt = icmp ult i64 %36, %37
br i1 %lt, label %loop.body50, label %loop.exit54
loop.cond48: ; preds = %loop.body50, %loop.exit46
%36 = load i64, ptr %.anon47, align 8
%gt49 = icmp ugt i64 3, %36
br i1 %gt49, label %loop.body50, label %loop.exit54
loop.body50: ; preds = %loop.cond49
%38 = load <3 x float>, ptr %foo2, align 16
%39 = load i64, ptr %.anon48, align 8
%40 = extractelement <3 x float> %38, i64 %39
store float %40, ptr %a51, align 4
%41 = load float, ptr %a51, align 4
%fpfpext52 = fpext float %41 to double
loop.body50: ; preds = %loop.cond48
%37 = load <3 x float>, ptr %foo2, align 16
%38 = load i64, ptr %.anon47, align 8
%39 = extractelement <3 x float> %37, i64 %38
store float %39, ptr %a51, align 4
%40 = load float, ptr %a51, align 4
%fpfpext52 = fpext float %40 to double
call void (ptr, ...) @printf(ptr @.str.6, double %fpfpext52)
%42 = load i64, ptr %.anon48, align 8
%addnuw53 = add nuw i64 %42, 1
store i64 %addnuw53, ptr %.anon48, align 8
br label %loop.cond49
%41 = load i64, ptr %.anon47, align 8
%addnuw53 = add nuw i64 %41, 1
store i64 %addnuw53, ptr %.anon47, align 8
br label %loop.cond48
loop.exit54: ; preds = %loop.cond49
store i64 3, ptr %.anon55, align 8
store i64 0, ptr %.anon56, align 8
br label %loop.cond57
loop.exit54: ; preds = %loop.cond48
store i64 0, ptr %.anon55, align 8
br label %loop.cond56
loop.cond57: ; preds = %loop.body59, %loop.exit54
%43 = load i64, ptr %.anon56, align 8
%44 = load i64, ptr %.anon55, align 8
%lt58 = icmp ult i64 %43, %44
br i1 %lt58, label %loop.body59, label %loop.exit65
loop.cond56: ; preds = %loop.body58, %loop.exit54
%42 = load i64, ptr %.anon55, align 8
%gt57 = icmp ugt i64 3, %42
br i1 %gt57, label %loop.body58, label %loop.exit64
loop.body59: ; preds = %loop.cond57
%45 = load i64, ptr %.anon56, align 8
%ptroffset61 = getelementptr inbounds [4 x i8], ptr %foo2, i64 %45
store ptr %ptroffset61, ptr %a60, align 8
%46 = load ptr, ptr %a60, align 8
loop.body58: ; preds = %loop.cond56
%43 = load i64, ptr %.anon55, align 8
%ptroffset60 = getelementptr inbounds [4 x i8], ptr %foo2, i64 %43
store ptr %ptroffset60, ptr %a59, align 8
%44 = load ptr, ptr %a59, align 8
%45 = load float, ptr %44, align 4
%fmul61 = fmul float %45, 2.000000e+00
store float %fmul61, ptr %44, align 4
%46 = load ptr, ptr %a59, align 8
%47 = load float, ptr %46, align 4
%fmul62 = fmul float %47, 2.000000e+00
store float %fmul62, ptr %46, align 4
%48 = load ptr, ptr %a60, align 8
%49 = load float, ptr %48, align 4
%fpfpext63 = fpext float %49 to double
call void (ptr, ...) @printf(ptr @.str.7, double %fpfpext63)
%50 = load i64, ptr %.anon56, align 8
%addnuw64 = add nuw i64 %50, 1
store i64 %addnuw64, ptr %.anon56, align 8
br label %loop.cond57
%fpfpext62 = fpext float %47 to double
call void (ptr, ...) @printf(ptr @.str.7, double %fpfpext62)
%48 = load i64, ptr %.anon55, align 8
%addnuw63 = add nuw i64 %48, 1
store i64 %addnuw63, ptr %.anon55, align 8
br label %loop.cond56
loop.exit65: ; preds = %loop.cond57
store i64 3, ptr %.anon66, align 8
store i64 0, ptr %.anon67, align 8
br label %loop.cond68
loop.exit64: ; preds = %loop.cond56
store i64 0, ptr %.anon65, align 8
br label %loop.cond66
loop.cond68: ; preds = %loop.body70, %loop.exit65
%51 = load i64, ptr %.anon67, align 8
%52 = load i64, ptr %.anon66, align 8
%lt69 = icmp ult i64 %51, %52
br i1 %lt69, label %loop.body70, label %loop.exit75
loop.cond66: ; preds = %loop.body68, %loop.exit64
%49 = load i64, ptr %.anon65, align 8
%gt67 = icmp ugt i64 3, %49
br i1 %gt67, label %loop.body68, label %loop.exit73
loop.body70: ; preds = %loop.cond68
%53 = load i64, ptr %.anon67, align 8
store i64 %53, ptr %i71, align 8
%54 = load <3 x float>, ptr %foo2, align 16
%55 = load i64, ptr %.anon67, align 8
%56 = extractelement <3 x float> %54, i64 %55
store float %56, ptr %a72, align 4
%57 = load float, ptr %a72, align 4
%fpfpext73 = fpext float %57 to double
%58 = load i64, ptr %i71, align 8
call void (ptr, ...) @printf(ptr @.str.8, i64 %58, double %fpfpext73)
%59 = load i64, ptr %.anon67, align 8
%addnuw74 = add nuw i64 %59, 1
store i64 %addnuw74, ptr %.anon67, align 8
br label %loop.cond68
loop.body68: ; preds = %loop.cond66
%50 = load i64, ptr %.anon65, align 8
store i64 %50, ptr %i69, align 8
%51 = load <3 x float>, ptr %foo2, align 16
%52 = load i64, ptr %.anon65, align 8
%53 = extractelement <3 x float> %51, i64 %52
store float %53, ptr %a70, align 4
%54 = load float, ptr %a70, align 4
%fpfpext71 = fpext float %54 to double
%55 = load i64, ptr %i69, align 8
call void (ptr, ...) @printf(ptr @.str.8, i64 %55, double %fpfpext71)
%56 = load i64, ptr %.anon65, align 8
%addnuw72 = add nuw i64 %56, 1
store i64 %addnuw72, ptr %.anon65, align 8
br label %loop.cond66
loop.exit75: ; preds = %loop.cond68
store i64 3, ptr %.anon76, align 8
store i64 0, ptr %.anon77, align 8
br label %loop.cond78
loop.exit73: ; preds = %loop.cond66
store i64 0, ptr %.anon74, align 8
br label %loop.cond75
loop.cond78: ; preds = %loop.body80, %loop.exit75
%60 = load i64, ptr %.anon77, align 8
%61 = load i64, ptr %.anon76, align 8
%lt79 = icmp ult i64 %60, %61
br i1 %lt79, label %loop.body80, label %loop.exit87
loop.cond75: ; preds = %loop.body77, %loop.exit73
%57 = load i64, ptr %.anon74, align 8
%gt76 = icmp ugt i64 3, %57
br i1 %gt76, label %loop.body77, label %loop.exit84
loop.body80: ; preds = %loop.cond78
%62 = load i64, ptr %.anon77, align 8
%trunc82 = trunc i64 %62 to i8
store i8 %trunc82, ptr %i81, align 1
%63 = load <3 x float>, ptr %foo2, align 16
%64 = load i64, ptr %.anon77, align 8
%65 = extractelement <3 x float> %63, i64 %64
%fpfpext84 = fpext float %65 to double
store double %fpfpext84, ptr %a83, align 8
%66 = load i8, ptr %i81, align 1
%zext85 = zext i8 %66 to i32
%67 = load double, ptr %a83, align 8
call void (ptr, ...) @printf(ptr @.str.9, i32 %zext85, double %67)
%68 = load i64, ptr %.anon77, align 8
%addnuw86 = add nuw i64 %68, 1
store i64 %addnuw86, ptr %.anon77, align 8
br label %loop.cond78
loop.body77: ; preds = %loop.cond75
%58 = load i64, ptr %.anon74, align 8
%trunc79 = trunc i64 %58 to i8
store i8 %trunc79, ptr %i78, align 1
%59 = load <3 x float>, ptr %foo2, align 16
%60 = load i64, ptr %.anon74, align 8
%61 = extractelement <3 x float> %59, i64 %60
%fpfpext81 = fpext float %61 to double
store double %fpfpext81, ptr %a80, align 8
%62 = load i8, ptr %i78, align 1
%zext82 = zext i8 %62 to i32
%63 = load double, ptr %a80, align 8
call void (ptr, ...) @printf(ptr @.str.9, i32 %zext82, double %63)
%64 = load i64, ptr %.anon74, align 8
%addnuw83 = add nuw i64 %64, 1
store i64 %addnuw83, ptr %.anon74, align 8
br label %loop.cond75
loop.exit87: ; preds = %loop.cond78
store i64 3, ptr %.anon88, align 8
store i64 0, ptr %.anon89, align 8
br label %loop.cond90
loop.exit84: ; preds = %loop.cond75
store i64 0, ptr %.anon85, align 8
br label %loop.cond86
loop.cond90: ; preds = %loop.body92, %loop.exit87
%69 = load i64, ptr %.anon89, align 8
%70 = load i64, ptr %.anon88, align 8
%lt91 = icmp ult i64 %69, %70
br i1 %lt91, label %loop.body92, label %loop.exit96
loop.cond86: ; preds = %loop.body88, %loop.exit84
%65 = load i64, ptr %.anon85, align 8
%gt87 = icmp ugt i64 3, %65
br i1 %gt87, label %loop.body88, label %loop.exit92
loop.body92: ; preds = %loop.cond90
%71 = load <3 x float>, ptr %foo2, align 16
%72 = load i64, ptr %.anon89, align 8
%73 = extractelement <3 x float> %71, i64 %72
%fpfpext94 = fpext float %73 to double
store double %fpfpext94, ptr %a93, align 8
%74 = load double, ptr %a93, align 8
call void (ptr, ...) @printf(ptr @.str.10, double %74)
%75 = load i64, ptr %.anon89, align 8
%addnuw95 = add nuw i64 %75, 1
store i64 %addnuw95, ptr %.anon89, align 8
br label %loop.cond90
loop.body88: ; preds = %loop.cond86
%66 = load <3 x float>, ptr %foo2, align 16
%67 = load i64, ptr %.anon85, align 8
%68 = extractelement <3 x float> %66, i64 %67
%fpfpext90 = fpext float %68 to double
store double %fpfpext90, ptr %a89, align 8
%69 = load double, ptr %a89, align 8
call void (ptr, ...) @printf(ptr @.str.10, double %69)
%70 = load i64, ptr %.anon85, align 8
%addnuw91 = add nuw i64 %70, 1
store i64 %addnuw91, ptr %.anon85, align 8
br label %loop.cond86
loop.exit96: ; preds = %loop.cond90
loop.exit92: ; preds = %loop.cond86
ret void
}

2
test/unit/regression/vector_ops.c3
View File

@@ -83,6 +83,8 @@ fn void! testb() @test
fn void! testi() @test
{
int[<4>] x = { 4, 0, -1, 33 };
assert({ true, false, true, true} == (bool[<4>])x);
int[<4>] y = { 1, 2, 3, 4 };
int[<4>] z = { 2, 2, 2, -100 };
int[<4>] w = y + z;