mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
354 lines
13 KiB
C
354 lines
13 KiB
C
// #target: macos-x64
|
|
module test;
|
|
|
|
extern fn void printf(char*, ...);
|
|
|
|
fn void main()
|
|
{
|
|
float[3] foo = { 2, 4.5, 8 };
|
|
float[<3>] foo2 = { 2, 4.5, 8 };
|
|
foreach_r (a : foo)
|
|
{
|
|
printf("Value: %f\n", a);
|
|
}
|
|
foreach_r (float* &a : foo)
|
|
{
|
|
*a *= 2;
|
|
printf("Value: %f\n", *a);
|
|
}
|
|
foreach_r (void* &a : foo)
|
|
{
|
|
printf("Value: %f\n", *((float*)(a)));
|
|
}
|
|
foreach_r (i, a : foo)
|
|
{
|
|
printf("Value[%d]: %f\n", i, a);
|
|
}
|
|
foreach_r (char i, double a : foo)
|
|
{
|
|
printf("Value2[%d]: %f\n", i, a);
|
|
}
|
|
foreach_r (double a : foo)
|
|
{
|
|
printf("Value3: %f\n", a);
|
|
}
|
|
|
|
foreach_r (a : foo2)
|
|
{
|
|
printf("Value: %f\n", a);
|
|
}
|
|
foreach_r (i, a : foo2)
|
|
{
|
|
printf("Value[%d]: %f\n", i, a);
|
|
}
|
|
foreach_r (char i, double a : foo2)
|
|
{
|
|
printf("Value2[%d]: %f\n", i, a);
|
|
}
|
|
foreach_r (double a : foo2)
|
|
{
|
|
printf("Value3: %f\n", a);
|
|
}
|
|
}
|
|
|
|
/* #expect: test.ll
|
|
|
|
@.__const = private unnamed_addr constant [3 x float] [float 2.000000e+00, float 4.500000e+00, float 8.000000e+00], align 4
|
|
@.str = private unnamed_addr constant [11 x i8] c"Value: %f\0A\00", align 1
|
|
@.str.1 = private unnamed_addr constant [11 x i8] c"Value: %f\0A\00", align 1
|
|
@.str.2 = private unnamed_addr constant [11 x i8] c"Value: %f\0A\00", align 1
|
|
@.str.3 = private unnamed_addr constant [15 x i8] c"Value[%d]: %f\0A\00", align 1
|
|
@.str.4 = private unnamed_addr constant [16 x i8] c"Value2[%d]: %f\0A\00", align 1
|
|
@.str.5 = private unnamed_addr constant [12 x i8] c"Value3: %f\0A\00", align 1
|
|
@.str.6 = private unnamed_addr constant [11 x i8] c"Value: %f\0A\00", align 1
|
|
@.str.7 = private unnamed_addr constant [15 x i8] c"Value[%d]: %f\0A\00", align 1
|
|
@.str.8 = private unnamed_addr constant [16 x i8] c"Value2[%d]: %f\0A\00", align 1
|
|
@.str.9 = private unnamed_addr constant [12 x i8] c"Value3: %f\0A\00", align 1
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @printf(i8*, ...) #0
|
|
|
|
; Function Attrs: nounwind
|
|
define void @test_main() #0 {
|
|
entry:
|
|
%foo = alloca [3 x float], align 4
|
|
%foo2 = alloca <3 x float>, align 16
|
|
%.anon = alloca i64, align 8
|
|
%a = alloca float, align 4
|
|
%.anon1 = alloca i64, align 8
|
|
%a6 = alloca float*, align 8
|
|
%.anon9 = alloca i64, align 8
|
|
%a14 = alloca i8*, align 8
|
|
%.anon18 = alloca i64, align 8
|
|
%i = alloca i64, align 8
|
|
%a23 = alloca float, align 4
|
|
%.anon26 = alloca i64, align 8
|
|
%i31 = alloca i8, align 1
|
|
%a32 = alloca double, align 8
|
|
%.anon35 = alloca i64, align 8
|
|
%a40 = alloca double, align 8
|
|
%.anon43 = alloca i64, align 8
|
|
%a48 = alloca float, align 4
|
|
%.anon51 = alloca i64, align 8
|
|
%i56 = alloca i64, align 8
|
|
%a57 = alloca float, align 4
|
|
%.anon60 = alloca i64, align 8
|
|
%i65 = alloca i8, align 1
|
|
%a67 = alloca double, align 8
|
|
%.anon71 = alloca i64, align 8
|
|
%a76 = alloca double, align 8
|
|
%0 = bitcast [3 x float]* %foo to i8*
|
|
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([3 x float]* @.__const to i8*), i32 12, i1 false)
|
|
store <3 x float> <float 2.000000e+00, float 4.500000e+00, float 8.000000e+00>, <3 x float>* %foo2, align 16
|
|
store i64 3, i64* %.anon, align 8
|
|
br label %loop.cond
|
|
|
|
loop.cond: ; preds = %loop.body, %entry
|
|
%1 = load i64, i64* %.anon, align 8
|
|
%gt = icmp ugt i64 %1, 0
|
|
br i1 %gt, label %loop.body, label %loop.exit
|
|
|
|
loop.body: ; preds = %loop.cond
|
|
%2 = load i64, i64* %.anon, align 8
|
|
%sub = sub i64 %2, 1
|
|
store i64 %sub, i64* %.anon, align 8
|
|
%3 = load i64, i64* %.anon, align 8
|
|
%4 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %3
|
|
%5 = load float, float* %4, align 4
|
|
store float %5, float* %a, align 4
|
|
%6 = load float, float* %a, align 4
|
|
%fpfpext = fpext float %6 to double
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), double %fpfpext)
|
|
br label %loop.cond
|
|
|
|
loop.exit: ; preds = %loop.cond
|
|
store i64 3, i64* %.anon1, align 8
|
|
br label %loop.cond2
|
|
|
|
loop.cond2: ; preds = %loop.body4, %loop.exit
|
|
%7 = load i64, i64* %.anon1, align 8
|
|
%gt3 = icmp ugt i64 %7, 0
|
|
br i1 %gt3, label %loop.body4, label %loop.exit8
|
|
|
|
loop.body4: ; preds = %loop.cond2
|
|
%8 = load i64, i64* %.anon1, align 8
|
|
%sub5 = sub i64 %8, 1
|
|
store i64 %sub5, i64* %.anon1, align 8
|
|
%9 = load i64, i64* %.anon1, align 8
|
|
%10 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %9
|
|
store float* %10, float** %a6, align 8
|
|
%11 = load float*, float** %a6, align 8
|
|
%12 = load float, float* %11, align 8
|
|
%fmul = fmul float %12, 2.000000e+00
|
|
store float %fmul, float* %11, align 8
|
|
%13 = load float*, float** %a6, align 8
|
|
%14 = load float, float* %13, align 8
|
|
%fpfpext7 = fpext float %14 to double
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), double %fpfpext7)
|
|
br label %loop.cond2
|
|
|
|
loop.exit8: ; preds = %loop.cond2
|
|
store i64 3, i64* %.anon9, align 8
|
|
br label %loop.cond10
|
|
|
|
loop.cond10: ; preds = %loop.body12, %loop.exit8
|
|
%15 = load i64, i64* %.anon9, align 8
|
|
%gt11 = icmp ugt i64 %15, 0
|
|
br i1 %gt11, label %loop.body12, label %loop.exit17
|
|
|
|
loop.body12: ; preds = %loop.cond10
|
|
%16 = load i64, i64* %.anon9, align 8
|
|
%sub13 = sub i64 %16, 1
|
|
store i64 %sub13, i64* %.anon9, align 8
|
|
%17 = load i64, i64* %.anon9, align 8
|
|
%18 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %17
|
|
%ptrptr = bitcast float* %18 to i8*
|
|
store i8* %ptrptr, i8** %a14, align 8
|
|
%19 = load i8*, i8** %a14, align 8
|
|
%ptrptr15 = bitcast i8* %19 to float*
|
|
%20 = load float, float* %ptrptr15, align 8
|
|
%fpfpext16 = fpext float %20 to double
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), double %fpfpext16)
|
|
br label %loop.cond10
|
|
|
|
loop.exit17: ; preds = %loop.cond10
|
|
store i64 3, i64* %.anon18, align 8
|
|
br label %loop.cond19
|
|
|
|
loop.cond19: ; preds = %loop.body21, %loop.exit17
|
|
%21 = load i64, i64* %.anon18, align 8
|
|
%gt20 = icmp ugt i64 %21, 0
|
|
br i1 %gt20, label %loop.body21, label %loop.exit25
|
|
|
|
loop.body21: ; preds = %loop.cond19
|
|
%22 = load i64, i64* %.anon18, align 8
|
|
%sub22 = sub i64 %22, 1
|
|
store i64 %sub22, i64* %.anon18, align 8
|
|
%23 = load i64, i64* %.anon18, align 8
|
|
store i64 %23, i64* %i, align 8
|
|
%24 = load i64, i64* %.anon18, align 8
|
|
%25 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %24
|
|
%26 = load float, float* %25, align 4
|
|
store float %26, float* %a23, align 4
|
|
%27 = load i64, i64* %i, align 8
|
|
%28 = load float, float* %a23, align 4
|
|
%fpfpext24 = fpext float %28 to double
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i32 0, i32 0), i64 %27, double %fpfpext24)
|
|
br label %loop.cond19
|
|
|
|
loop.exit25: ; preds = %loop.cond19
|
|
store i64 3, i64* %.anon26, align 8
|
|
br label %loop.cond27
|
|
|
|
loop.cond27: ; preds = %loop.body29, %loop.exit25
|
|
%29 = load i64, i64* %.anon26, align 8
|
|
%gt28 = icmp ugt i64 %29, 0
|
|
br i1 %gt28, label %loop.body29, label %loop.exit34
|
|
|
|
loop.body29: ; preds = %loop.cond27
|
|
%30 = load i64, i64* %.anon26, align 8
|
|
%sub30 = sub i64 %30, 1
|
|
store i64 %sub30, i64* %.anon26, align 8
|
|
%31 = load i64, i64* %.anon26, align 8
|
|
%ztrunc = trunc i64 %31 to i8
|
|
store i8 %ztrunc, i8* %i31, align 1
|
|
%32 = load i64, i64* %.anon26, align 8
|
|
%33 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %32
|
|
%34 = load float, float* %33, align 4
|
|
%fpfpext33 = fpext float %34 to double
|
|
store double %fpfpext33, double* %a32, align 8
|
|
%35 = load i8, i8* %i31, align 1
|
|
%uisiext = zext i8 %35 to i32
|
|
%36 = load double, double* %a32, align 8
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i32 0, i32 0), i32 %uisiext, double %36)
|
|
br label %loop.cond27
|
|
|
|
loop.exit34: ; preds = %loop.cond27
|
|
store i64 3, i64* %.anon35, align 8
|
|
br label %loop.cond36
|
|
|
|
loop.cond36: ; preds = %loop.body38, %loop.exit34
|
|
%37 = load i64, i64* %.anon35, align 8
|
|
%gt37 = icmp ugt i64 %37, 0
|
|
br i1 %gt37, label %loop.body38, label %loop.exit42
|
|
|
|
loop.body38: ; preds = %loop.cond36
|
|
%38 = load i64, i64* %.anon35, align 8
|
|
%sub39 = sub i64 %38, 1
|
|
store i64 %sub39, i64* %.anon35, align 8
|
|
%39 = load i64, i64* %.anon35, align 8
|
|
%40 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %39
|
|
%41 = load float, float* %40, align 4
|
|
%fpfpext41 = fpext float %41 to double
|
|
store double %fpfpext41, double* %a40, align 8
|
|
%42 = load double, double* %a40, align 8
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i32 0, i32 0), double %42)
|
|
br label %loop.cond36
|
|
|
|
loop.exit42: ; preds = %loop.cond36
|
|
store i64 3, i64* %.anon43, align 8
|
|
br label %loop.cond44
|
|
|
|
loop.cond44: ; preds = %loop.body46, %loop.exit42
|
|
%43 = load i64, i64* %.anon43, align 8
|
|
%gt45 = icmp ugt i64 %43, 0
|
|
br i1 %gt45, label %loop.body46, label %loop.exit50
|
|
|
|
loop.body46: ; preds = %loop.cond44
|
|
%44 = load i64, i64* %.anon43, align 8
|
|
%sub47 = sub i64 %44, 1
|
|
store i64 %sub47, i64* %.anon43, align 8
|
|
%45 = load <3 x float>, <3 x float>* %foo2, align 16
|
|
%46 = load i64, i64* %.anon43, align 8
|
|
%47 = extractelement <3 x float> %45, i64 %46
|
|
store float %47, float* %a48, align 4
|
|
%48 = load float, float* %a48, align 4
|
|
%fpfpext49 = fpext float %48 to double
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), double %fpfpext49)
|
|
br label %loop.cond44
|
|
|
|
loop.exit50: ; preds = %loop.cond44
|
|
store i64 3, i64* %.anon51, align 8
|
|
br label %loop.cond52
|
|
|
|
loop.cond52: ; preds = %loop.body54, %loop.exit50
|
|
%49 = load i64, i64* %.anon51, align 8
|
|
%gt53 = icmp ugt i64 %49, 0
|
|
br i1 %gt53, label %loop.body54, label %loop.exit59
|
|
|
|
loop.body54: ; preds = %loop.cond52
|
|
%50 = load i64, i64* %.anon51, align 8
|
|
%sub55 = sub i64 %50, 1
|
|
store i64 %sub55, i64* %.anon51, align 8
|
|
%51 = load i64, i64* %.anon51, align 8
|
|
store i64 %51, i64* %i56, align 8
|
|
%52 = load <3 x float>, <3 x float>* %foo2, align 16
|
|
%53 = load i64, i64* %.anon51, align 8
|
|
%54 = extractelement <3 x float> %52, i64 %53
|
|
store float %54, float* %a57, align 4
|
|
%55 = load i64, i64* %i56, align 8
|
|
%56 = load float, float* %a57, align 4
|
|
%fpfpext58 = fpext float %56 to double
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i32 0, i32 0), i64 %55, double %fpfpext58)
|
|
br label %loop.cond52
|
|
|
|
loop.exit59: ; preds = %loop.cond52
|
|
store i64 3, i64* %.anon60, align 8
|
|
br label %loop.cond61
|
|
|
|
loop.cond61: ; preds = %loop.body63, %loop.exit59
|
|
%57 = load i64, i64* %.anon60, align 8
|
|
%gt62 = icmp ugt i64 %57, 0
|
|
br i1 %gt62, label %loop.body63, label %loop.exit70
|
|
|
|
loop.body63: ; preds = %loop.cond61
|
|
%58 = load i64, i64* %.anon60, align 8
|
|
%sub64 = sub i64 %58, 1
|
|
store i64 %sub64, i64* %.anon60, align 8
|
|
%59 = load i64, i64* %.anon60, align 8
|
|
%ztrunc66 = trunc i64 %59 to i8
|
|
store i8 %ztrunc66, i8* %i65, align 1
|
|
%60 = load <3 x float>, <3 x float>* %foo2, align 16
|
|
%61 = load i64, i64* %.anon60, align 8
|
|
%62 = extractelement <3 x float> %60, i64 %61
|
|
%fpfpext68 = fpext float %62 to double
|
|
store double %fpfpext68, double* %a67, align 8
|
|
%63 = load i8, i8* %i65, align 1
|
|
%uisiext69 = zext i8 %63 to i32
|
|
%64 = load double, double* %a67, align 8
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i32 0, i32 0), i32 %uisiext69, double %64)
|
|
br label %loop.cond61
|
|
|
|
loop.exit70: ; preds = %loop.cond61
|
|
store i64 3, i64* %.anon71, align 8
|
|
br label %loop.cond72
|
|
|
|
loop.cond72: ; preds = %loop.body74, %loop.exit70
|
|
%65 = load i64, i64* %.anon71, align 8
|
|
%gt73 = icmp ugt i64 %65, 0
|
|
br i1 %gt73, label %loop.body74, label %loop.exit78
|
|
|
|
loop.body74: ; preds = %loop.cond72
|
|
%66 = load i64, i64* %.anon71, align 8
|
|
%sub75 = sub i64 %66, 1
|
|
store i64 %sub75, i64* %.anon71, align 8
|
|
%67 = load <3 x float>, <3 x float>* %foo2, align 16
|
|
%68 = load i64, i64* %.anon71, align 8
|
|
%69 = extractelement <3 x float> %67, i64 %68
|
|
%fpfpext77 = fpext float %69 to double
|
|
store double %fpfpext77, double* %a76, align 8
|
|
%70 = load double, double* %a76, align 8
|
|
call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i32 0, i32 0), double %70)
|
|
br label %loop.cond72
|
|
|
|
loop.exit78: ; preds = %loop.cond72
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define i32 @main(i32 %0, i8** %1) #0 {
|
|
entry:
|
|
call void @test_main()
|
|
ret i32 0
|
|
}
|