c3c/test/test_suite/statements/foreach_common.c3t

// #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 (a : foo)
    {
        printf("Value: %f\n", a);
    }
    foreach (float* &a : foo)
    {
        *a *= 2;
        printf("Value: %f\n", *a);
    }
    foreach (void* &a : foo)
    {
        printf("Value: %f\n", *((float*)(a)));
    }
    foreach (i, a : foo)
    {
        printf("Value[%d]: %f\n", i, a);
    }
    foreach (char i, double a : foo)
    {
        printf("Value2[%d]: %f\n", i, a);
    }
    foreach (double a : foo)
    {
        printf("Value3: %f\n", a);
    }

    foreach (a : foo2)
    {
        printf("Value: %f\n", a);
    }
    foreach (float* &a : foo2)
    {
        *a *= 2;
        printf("Value: %f\n", *a);
    }
    foreach (i, a : foo2)
    {
        printf("Value[%d]: %f\n", i, a);
    }
    foreach (char i, double a : foo2)
    {
        printf("Value2[%d]: %f\n", i, a);
    }
    foreach (double a : foo2)
    {
        printf("Value3: %f\n", a);
    }
}

/* #expect: test.ll

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
  %a5 = alloca ptr, align 8
  %.anon10 = alloca i64, align 8
  %a14 = alloca ptr, align 8
  %.anon19 = alloca i64, align 8
  %i = alloca i64, align 8
  %a23 = alloca float, align 4
  %.anon28 = alloca i64, align 8
  %i32 = alloca i8, align 1
  %a33 = alloca double, align 8
  %.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
  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
  br label %loop.cond

loop.cond:                                        ; preds = %loop.body, %entry
  %0 = load i64, ptr %.anon, align 8
  %gt = icmp ugt i64 3, %0
  br i1 %gt, label %loop.body, label %loop.exit

loop.body:                                        ; preds = %loop.cond
  %1 = load i64, ptr %.anon, align 8
  %ptroffset = getelementptr inbounds [4 x i8], ptr %foo, i64 %1
  %2 = load float, ptr %ptroffset, align 4
  store float %2, ptr %a, align 4
  %3 = load float, ptr %a, align 4
  %fpfpext = fpext float %3 to double
  call void (ptr, ...) @printf(ptr @.str, double %fpfpext)
  %4 = load i64, ptr %.anon, align 8
  %addnuw = add nuw i64 %4, 1
  store i64 %addnuw, ptr %.anon, align 8
  br label %loop.cond

loop.exit:                                        ; preds = %loop.cond
  store i64 0, ptr %.anon1, align 8
  br label %loop.cond2

loop.cond2:                                       ; preds = %loop.body4, %loop.exit
  %5 = load i64, ptr %.anon1, align 8
  %gt3 = icmp ugt i64 3, %5
  br i1 %gt3, label %loop.body4, label %loop.exit9

loop.body4:                                       ; preds = %loop.cond2
  %6 = load i64, ptr %.anon1, align 8
  %ptroffset6 = getelementptr inbounds [4 x i8], ptr %foo, i64 %6
  store ptr %ptroffset6, ptr %a5, align 8
  %7 = load ptr, ptr %a5, align 8
  %8 = load float, ptr %7, align 4
  %fmul = fmul float %8, 2.000000e+00
  store float %fmul, ptr %7, align 4
  %9 = load ptr, ptr %a5, align 8
  %10 = load float, ptr %9, align 4
  %fpfpext7 = fpext float %10 to double
  call void (ptr, ...) @printf(ptr @.str.1, double %fpfpext7)
  %11 = load i64, ptr %.anon1, align 8
  %addnuw8 = add nuw i64 %11, 1
  store i64 %addnuw8, ptr %.anon1, align 8
  br label %loop.cond2

loop.exit9:                                       ; preds = %loop.cond2
  store i64 0, ptr %.anon10, align 8
  br label %loop.cond11

loop.cond11:                                      ; preds = %loop.body13, %loop.exit9
  %12 = load i64, ptr %.anon10, align 8
  %gt12 = icmp ugt i64 3, %12
  br i1 %gt12, label %loop.body13, label %loop.exit18

loop.body13:                                      ; preds = %loop.cond11
  %13 = load i64, ptr %.anon10, align 8
  %ptroffset15 = getelementptr inbounds [4 x i8], ptr %foo, i64 %13
  store ptr %ptroffset15, ptr %a14, align 8
  %14 = load ptr, ptr %a14, align 8
  %15 = load float, ptr %14, align 4
  %fpfpext16 = fpext float %15 to double
  call void (ptr, ...) @printf(ptr @.str.2, double %fpfpext16)
  %16 = load i64, ptr %.anon10, align 8
  %addnuw17 = add nuw i64 %16, 1
  store i64 %addnuw17, ptr %.anon10, align 8
  br label %loop.cond11

loop.exit18:                                      ; preds = %loop.cond11
  store i64 0, ptr %.anon19, align 8
  br label %loop.cond20

loop.cond20:                                      ; preds = %loop.body22, %loop.exit18
  %17 = load i64, ptr %.anon19, align 8
  %gt21 = icmp ugt i64 3, %17
  br i1 %gt21, label %loop.body22, label %loop.exit27

loop.body22:                                      ; preds = %loop.cond20
  %18 = load i64, ptr %.anon19, align 8
  store i64 %18, ptr %i, align 8
  %19 = load i64, ptr %.anon19, align 8
  %ptroffset24 = getelementptr inbounds [4 x i8], ptr %foo, i64 %19
  %20 = load float, ptr %ptroffset24, align 4
  store float %20, ptr %a23, align 4
  %21 = load float, ptr %a23, align 4
  %fpfpext25 = fpext float %21 to double
  %22 = load i64, ptr %i, align 8
  call void (ptr, ...) @printf(ptr @.str.3, i64 %22, double %fpfpext25)
  %23 = load i64, ptr %.anon19, align 8
  %addnuw26 = add nuw i64 %23, 1
  store i64 %addnuw26, ptr %.anon19, align 8
  br label %loop.cond20

loop.exit27:                                      ; preds = %loop.cond20
  store i64 0, ptr %.anon28, align 8
  br label %loop.cond29

loop.cond29:                                      ; preds = %loop.body31, %loop.exit27
  %24 = load i64, ptr %.anon28, align 8
  %gt30 = icmp ugt i64 3, %24
  br i1 %gt30, label %loop.body31, label %loop.exit37

loop.body31:                                      ; preds = %loop.cond29
  %25 = load i64, ptr %.anon28, align 8
  %trunc = trunc i64 %25 to i8
  store i8 %trunc, ptr %i32, align 1
  %26 = load i64, ptr %.anon28, align 8
  %ptroffset34 = getelementptr inbounds [4 x i8], ptr %foo, i64 %26
  %27 = load float, ptr %ptroffset34, align 4
  %fpfpext35 = fpext float %27 to double
  store double %fpfpext35, ptr %a33, align 8
  %28 = load i8, ptr %i32, align 1
  %zext = zext i8 %28 to i32
  %29 = load double, ptr %a33, align 8
  call void (ptr, ...) @printf(ptr @.str.4, i32 %zext, double %29)
  %30 = load i64, ptr %.anon28, align 8
  %addnuw36 = add nuw i64 %30, 1
  store i64 %addnuw36, ptr %.anon28, align 8
  br label %loop.cond29

loop.exit37:                                      ; preds = %loop.cond29
  store i64 0, ptr %.anon38, align 8
  br label %loop.cond39

loop.cond39:                                      ; preds = %loop.body41, %loop.exit37
  %31 = load i64, ptr %.anon38, align 8
  %gt40 = icmp ugt i64 3, %31
  br i1 %gt40, label %loop.body41, label %loop.exit46

loop.body41:                                      ; preds = %loop.cond39
  %32 = load i64, ptr %.anon38, align 8
  %ptroffset43 = getelementptr inbounds [4 x i8], ptr %foo, i64 %32
  %33 = load float, ptr %ptroffset43, align 4
  %fpfpext44 = fpext float %33 to double
  store double %fpfpext44, ptr %a42, align 8
  %34 = load double, ptr %a42, align 8
  call void (ptr, ...) @printf(ptr @.str.5, double %34)
  %35 = load i64, ptr %.anon38, align 8
  %addnuw45 = add nuw i64 %35, 1
  store i64 %addnuw45, ptr %.anon38, align 8
  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

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.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
  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

loop.exit54:                                      ; preds = %loop.cond49
  store i64 3, ptr %.anon55, align 8
  store i64 0, ptr %.anon56, align 8
  br label %loop.cond57

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.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
  %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

loop.exit65:                                      ; preds = %loop.cond57
  store i64 3, ptr %.anon66, align 8
  store i64 0, ptr %.anon67, align 8
  br label %loop.cond68

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.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.exit75:                                      ; preds = %loop.cond68
  store i64 3, ptr %.anon76, align 8
  store i64 0, ptr %.anon77, align 8
  br label %loop.cond78

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.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.exit87:                                      ; preds = %loop.cond78
  store i64 3, ptr %.anon88, align 8
  store i64 0, ptr %.anon89, align 8
  br label %loop.cond90

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.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.exit96:                                      ; preds = %loop.cond90
  ret void
}