c3c/test/test_suite/statements/foreach_common.c3t

module test;

extern func void printf(char*, ...);

func void main()
{
    float[3] foo = { 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);
    }
}

// #expect: test.ll

entry:
  %foo = alloca [3 x float], align 4
  %idx = alloca i64, align 8
  %a = alloca float, align 4
  %idx1 = alloca i64, align 8
  %a2 = alloca float*, align 8
  %idx10 = alloca i64, align 8
  %a11 = alloca i8*, align 8
  %i = alloca i64, align 8
  %a20 = alloca float, align 4
  %i28 = alloca i8, align 1
  %idx29 = alloca i64, align 8
  %a30 = alloca double, align 8
  %idx38 = alloca i64, align 8
  %a39 = 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 i64 0, i64* %idx, align 8
  br label %foreach.cond

foreach.cond:                                     ; preds = %foreach.inc, %entry
  %1 = load i64, i64* %idx, align 8
  %lt = icmp ult i64 %1, 3
  br i1 %lt, label %foreach.body, label %foreach.exit

foreach.body:                                     ; preds = %foreach.cond
  %ptroffset = getelementptr inbounds float, [3 x float]* %foo, i64 %1
  %2 = load float, float* %ptroffset, align 4
  store float %2, float* %a, align 4
  %3 = load float, float* %a, align 4
  %fpfpext = fpext float %3 to double
  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), double %fpfpext)
  br label %foreach.inc

foreach.inc:                                      ; preds = %foreach.body
  %4 = load i64, i64* %idx, align 8
  %5 = add i64 %4, 1
  store i64 %5, i64* %idx, align 8
  br label %foreach.cond

foreach.exit:                                     ; preds = %foreach.cond
  store i64 0, i64* %idx1, align 8
  br label %foreach.cond3

foreach.cond3:                                    ; preds = %foreach.inc8, %foreach.exit
  %6 = load i64, i64* %idx1, align 8
  %lt4 = icmp ult i64 %6, 3
  br i1 %lt4, label %foreach.body5, label %foreach.exit9

foreach.body5:                                    ; preds = %foreach.cond3
  %ptroffset6 = getelementptr inbounds float, [3 x float]* %foo, i64 %6
  store float* %ptroffset6, float** %a2, align 8
  %7 = load float*, float** %a2, align 8
  %8 = load float, float* %7, align 8
  %fmul = fmul float %8, 2.000000e+00
  store float %fmul, float* %7, align 8
  %9 = load float*, float** %a2, align 8
  %10 = load float, float* %9, align 8
  %fpfpext7 = fpext float %10 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 %foreach.inc8

foreach.inc8:                                     ; preds = %foreach.body5
  %11 = load i64, i64* %idx1, align 8
  %12 = add i64 %11, 1
  store i64 %12, i64* %idx1, align 8
  br label %foreach.cond3

foreach.exit9:                                    ; preds = %foreach.cond3
  store i64 0, i64* %idx10, align 8
  br label %foreach.cond12

foreach.cond12:                                   ; preds = %foreach.inc18, %foreach.exit9
  %13 = load i64, i64* %idx10, align 8
  %lt13 = icmp ult i64 %13, 3
  br i1 %lt13, label %foreach.body14, label %foreach.exit19

foreach.body14:                                   ; preds = %foreach.cond12
  %ptroffset15 = getelementptr inbounds float, [3 x float]* %foo, i64 %13
  %ptrptr = bitcast float* %ptroffset15 to i8*
  store i8* %ptrptr, i8** %a11, align 8
  %14 = load i8*, i8** %a11, align 8
  %ptrptr16 = bitcast i8* %14 to float*
  %15 = load float, float* %ptrptr16, align 8
  %fpfpext17 = fpext float %15 to double
  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), double %fpfpext17)
  br label %foreach.inc18

foreach.inc18:                                    ; preds = %foreach.body14
  %16 = load i64, i64* %idx10, align 8
  %17 = add i64 %16, 1
  store i64 %17, i64* %idx10, align 8
  br label %foreach.cond12

foreach.exit19:                                   ; preds = %foreach.cond12
  store i64 0, i64* %i, align 8
  br label %foreach.cond21

foreach.cond21:                                   ; preds = %foreach.inc26, %foreach.exit19
  %18 = load i64, i64* %i, align 8
  %lt22 = icmp ult i64 %18, 3
  br i1 %lt22, label %foreach.body23, label %foreach.exit27

foreach.body23:                                   ; preds = %foreach.cond21
  %ptroffset24 = getelementptr inbounds float, [3 x float]* %foo, i64 %18
  %19 = load float, float* %ptroffset24, align 4
  store float %19, float* %a20, align 4
  %20 = load i64, i64* %i, align 8
  %21 = load float, float* %a20, align 4
  %fpfpext25 = fpext float %21 to double
  call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i32 0, i32 0), i64 %20, double %fpfpext25)
  br label %foreach.inc26

foreach.inc26:                                    ; preds = %foreach.body23
  %22 = load i64, i64* %i, align 8
  %23 = add i64 %22, 1
  store i64 %23, i64* %i, align 8
  br label %foreach.cond21

foreach.exit27:                                   ; preds = %foreach.cond21
  store i8 0, i8* %i28, align 1
  store i64 0, i64* %idx29, align 8
  br label %foreach.cond31

foreach.cond31:                                   ; preds = %foreach.inc36, %foreach.exit27
  %24 = load i64, i64* %idx29, align 8
  %lt32 = icmp ult i64 %24, 3
  br i1 %lt32, label %foreach.body33, label %foreach.exit37

foreach.body33:                                   ; preds = %foreach.cond31
  %25 = trunc i64 %24 to i8
  store i8 %25, i8* %i28, align 1
  %ptroffset34 = getelementptr inbounds float, [3 x float]* %foo, i64 %24
  %26 = load float, float* %ptroffset34, align 4
  %fpfpext35 = fpext float %26 to double
  store double %fpfpext35, double* %a30, align 8
  %27 = load i8, i8* %i28, align 1
  %uisiext = zext i8 %27 to i32
  %28 = load double, double* %a30, align 8
  call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i32 0, i32 0), i32 %uisiext, double %28)
  br label %foreach.inc36

foreach.inc36:                                    ; preds = %foreach.body33
  %29 = load i64, i64* %idx29, align 8
  %30 = add i64 %29, 1
  store i64 %30, i64* %idx29, align 8
  br label %foreach.cond31

foreach.exit37:                                   ; preds = %foreach.cond31
  store i64 0, i64* %idx38, align 8
  br label %foreach.cond40

foreach.cond40:                                   ; preds = %foreach.inc45, %foreach.exit37
  %31 = load i64, i64* %idx38, align 8
  %lt41 = icmp ult i64 %31, 3
  br i1 %lt41, label %foreach.body42, label %foreach.exit46

foreach.body42:                                   ; preds = %foreach.cond40
  %ptroffset43 = getelementptr inbounds float, [3 x float]* %foo, i64 %31
  %32 = load float, float* %ptroffset43, align 4
  %fpfpext44 = fpext float %32 to double
  store double %fpfpext44, double* %a39, align 8
  %33 = load double, double* %a39, align 8
  call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i32 0, i32 0), double %33)
  br label %foreach.inc45

foreach.inc45:                                    ; preds = %foreach.body42
  %34 = load i64, i64* %idx38, align 8
  %35 = add i64 %34, 1
  store i64 %35, i64* %idx38, align 8
  br label %foreach.cond40

foreach.exit46:                                   ; preds = %foreach.cond40
  ret void
}