Test Failure: Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll

Test source: git

Log:

Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. InjectTLIMappings

----------------------------------------
declare double @acos(double)

define void @acos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @acos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 3. InjectTLIMappings

----------------------------------------
declare double @acos(double)

define void @acos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @acos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 4. LoopVectorizePass

----------------------------------------
declare double @acos(double)

define void @acos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @acos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 5. LoopVectorizePass

----------------------------------------
declare double @acos(double)

define void @acos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @acos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_acos(<2 x double>)
declare double @acos(double)

define void @acos_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_acos(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @acos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @acos

-- 6. PassManager<Function> : Skipping NOP
-- 7. PassManager<Function> : Skipping NOP
-- 8. InjectTLIMappings

----------------------------------------
declare float @acosf(float)

define void @acos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @acosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 9. InjectTLIMappings

----------------------------------------
declare float @acosf(float)

define void @acos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @acosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 10. LoopVectorizePass

----------------------------------------
declare float @acosf(float)

define void @acos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @acosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 11. LoopVectorizePass

----------------------------------------
declare float @acosf(float)

define void @acos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @acosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_acosf(<4 x float>)
declare float @acosf(float)

define void @acos_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_acosf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @acosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @acosf

-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InjectTLIMappings

----------------------------------------
declare double @asin(double)

define void @asin_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @asin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 15. InjectTLIMappings

----------------------------------------
declare double @asin(double)

define void @asin_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @asin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 16. LoopVectorizePass

----------------------------------------
declare double @asin(double)

define void @asin_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @asin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 17. LoopVectorizePass

----------------------------------------
declare double @asin(double)

define void @asin_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @asin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_asin(<2 x double>)
declare double @asin(double)

define void @asin_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_asin(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @asin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @asin

-- 18. PassManager<Function> : Skipping NOP
-- 19. PassManager<Function> : Skipping NOP
-- 20. InjectTLIMappings

----------------------------------------
declare float @asinf(float)

define void @asin_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @asinf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 21. InjectTLIMappings

----------------------------------------
declare float @asinf(float)

define void @asin_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @asinf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 22. LoopVectorizePass

----------------------------------------
declare float @asinf(float)

define void @asin_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @asinf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 23. LoopVectorizePass

----------------------------------------
declare float @asinf(float)

define void @asin_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @asinf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_asinf(<4 x float>)
declare float @asinf(float)

define void @asin_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_asinf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @asinf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @asinf

-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InjectTLIMappings

----------------------------------------
declare double @atan(double)

define void @atan_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 27. InjectTLIMappings

----------------------------------------
declare double @atan(double)

define void @atan_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 28. LoopVectorizePass

----------------------------------------
declare double @atan(double)

define void @atan_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 29. LoopVectorizePass

----------------------------------------
declare double @atan(double)

define void @atan_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_atan(<2 x double>)
declare double @atan(double)

define void @atan_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_atan(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @atan

-- 30. PassManager<Function> : Skipping NOP
-- 31. PassManager<Function> : Skipping NOP
-- 32. InjectTLIMappings

----------------------------------------
declare float @atanf(float)

define void @atan_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 33. InjectTLIMappings

----------------------------------------
declare float @atanf(float)

define void @atan_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 34. LoopVectorizePass

----------------------------------------
declare float @atanf(float)

define void @atan_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 35. LoopVectorizePass

----------------------------------------
declare float @atanf(float)

define void @atan_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_atanf(<4 x float>)
declare float @atanf(float)

define void @atan_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_atanf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @atanf

-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InjectTLIMappings

----------------------------------------
declare double @atan2(double, double)

define void @atan2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan2(double %conv, double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 39. InjectTLIMappings

----------------------------------------
declare double @atan2(double, double)

define void @atan2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan2(double %conv, double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 40. LoopVectorizePass

----------------------------------------
declare double @atan2(double, double)

define void @atan2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan2(double %conv, double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 41. LoopVectorizePass

----------------------------------------
declare double @atan2(double, double)

define void @atan2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan2(double %conv, double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2vv_atan2(<2 x double>, <2 x double>)
declare double @atan2(double, double)

define void @atan2_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2vv_atan2(<2 x double> %#1, <2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atan2(double %conv, double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @atan2

-- 42. PassManager<Function> : Skipping NOP
-- 43. PassManager<Function> : Skipping NOP
-- 44. InjectTLIMappings

----------------------------------------
declare float @atan2f(float, float)

define void @atan2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atan2f(float %conv, float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 45. InjectTLIMappings

----------------------------------------
declare float @atan2f(float, float)

define void @atan2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atan2f(float %conv, float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 46. LoopVectorizePass

----------------------------------------
declare float @atan2f(float, float)

define void @atan2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atan2f(float %conv, float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 47. LoopVectorizePass

----------------------------------------
declare float @atan2f(float, float)

define void @atan2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atan2f(float %conv, float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4vv_atan2f(<4 x float>, <4 x float>)
declare float @atan2f(float, float)

define void @atan2_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4vv_atan2f(<4 x float> %#1, <4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atan2f(float %conv, float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @atan2f

-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InjectTLIMappings

----------------------------------------
declare double @atanh(double)

define void @atanh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atanh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 51. InjectTLIMappings

----------------------------------------
declare double @atanh(double)

define void @atanh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atanh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 52. LoopVectorizePass

----------------------------------------
declare double @atanh(double)

define void @atanh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atanh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 53. LoopVectorizePass

----------------------------------------
declare double @atanh(double)

define void @atanh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atanh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_atanh(<2 x double>)
declare double @atanh(double)

define void @atanh_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_atanh(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @atanh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @atanh

-- 54. PassManager<Function> : Skipping NOP
-- 55. PassManager<Function> : Skipping NOP
-- 56. InjectTLIMappings

----------------------------------------
declare float @atanhf(float)

define void @atanh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanhf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 57. InjectTLIMappings

----------------------------------------
declare float @atanhf(float)

define void @atanh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanhf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 58. LoopVectorizePass

----------------------------------------
declare float @atanhf(float)

define void @atanh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanhf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 59. LoopVectorizePass

----------------------------------------
declare float @atanhf(float)

define void @atanh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanhf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_atanhf(<4 x float>)
declare float @atanhf(float)

define void @atanh_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_atanhf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @atanhf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @atanhf

-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InjectTLIMappings

----------------------------------------
declare double @cos(double)

define void @cos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 63. InjectTLIMappings

----------------------------------------
declare double @cos(double)

define void @cos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 64. LoopVectorizePass

----------------------------------------
declare double @cos(double)

define void @cos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 65. LoopVectorizePass

----------------------------------------
declare double @cos(double)

define void @cos_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_cos(<2 x double>)
declare double @cos(double)

define void @cos_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_cos(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cos(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @cos

-- 66. PassManager<Function> : Skipping NOP
-- 67. PassManager<Function> : Skipping NOP
-- 68. InjectTLIMappings

----------------------------------------
declare float @cosf(float)

define void @cos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @cosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 69. InjectTLIMappings

----------------------------------------
declare float @cosf(float)

define void @cos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @cosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 70. LoopVectorizePass

----------------------------------------
declare float @cosf(float)

define void @cos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @cosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 71. LoopVectorizePass

----------------------------------------
declare float @cosf(float)

define void @cos_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @cosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_cosf(<4 x float>)
declare float @cosf(float)

define void @cos_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_cosf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @cosf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @cosf

-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InjectTLIMappings

----------------------------------------
declare double @cosh(double)

define void @cosh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cosh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 75. InjectTLIMappings

----------------------------------------
declare double @cosh(double)

define void @cosh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cosh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 76. LoopVectorizePass

----------------------------------------
declare double @cosh(double)

define void @cosh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cosh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 77. LoopVectorizePass

----------------------------------------
declare double @cosh(double)

define void @cosh_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cosh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_cosh(<2 x double>)
declare double @cosh(double)

define void @cosh_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_cosh(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @cosh(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @cosh

-- 78. PassManager<Function> : Skipping NOP
-- 79. PassManager<Function> : Skipping NOP
-- 80. InjectTLIMappings

----------------------------------------
declare float @coshf(float)

define void @cosh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @coshf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 81. InjectTLIMappings

----------------------------------------
declare float @coshf(float)

define void @cosh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @coshf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 82. LoopVectorizePass

----------------------------------------
declare float @coshf(float)

define void @cosh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @coshf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 83. LoopVectorizePass

----------------------------------------
declare float @coshf(float)

define void @cosh_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @coshf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_coshf(<4 x float>)
declare float @coshf(float)

define void @cosh_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_coshf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @coshf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @coshf

-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InjectTLIMappings

----------------------------------------
declare double @exp(double)

define void @exp_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 87. InjectTLIMappings

----------------------------------------
declare double @exp(double)

define void @exp_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 88. LoopVectorizePass

----------------------------------------
declare double @exp(double)

define void @exp_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 89. LoopVectorizePass

----------------------------------------
declare double @exp(double)

define void @exp_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_exp(<2 x double>)
declare double @exp(double)

define void @exp_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_exp(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @exp

-- 90. PassManager<Function> : Skipping NOP
-- 91. PassManager<Function> : Skipping NOP
-- 92. InjectTLIMappings

----------------------------------------
declare float @expf(float)

define void @exp_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @expf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 93. InjectTLIMappings

----------------------------------------
declare float @expf(float)

define void @exp_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @expf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 94. LoopVectorizePass

----------------------------------------
declare float @expf(float)

define void @exp_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @expf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 95. LoopVectorizePass

----------------------------------------
declare float @expf(float)

define void @exp_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @expf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_expf(<4 x float>)
declare float @expf(float)

define void @exp_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_expf(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @expf(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @expf

-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InjectTLIMappings

----------------------------------------
declare double @exp2(double)

define void @exp2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 99. InjectTLIMappings

----------------------------------------
declare double @exp2(double)

define void @exp2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 100. LoopVectorizePass

----------------------------------------
declare double @exp2(double)

define void @exp2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 101. LoopVectorizePass

----------------------------------------
declare double @exp2(double)

define void @exp2_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_exp2(<2 x double>)
declare double @exp2(double)

define void @exp2_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_exp2(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @exp2

-- 102. PassManager<Function> : Skipping NOP
-- 103. PassManager<Function> : Skipping NOP
-- 104. InjectTLIMappings

----------------------------------------
declare float @exp2f(float)

define void @exp2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @exp2f(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 105. InjectTLIMappings

----------------------------------------
declare float @exp2f(float)

define void @exp2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @exp2f(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 106. LoopVectorizePass

----------------------------------------
declare float @exp2f(float)

define void @exp2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @exp2f(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 107. LoopVectorizePass

----------------------------------------
declare float @exp2f(float)

define void @exp2_f32(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @exp2f(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <4 x float> @_ZGVnN4v_exp2f(<4 x float>)
declare float @exp2f(float)

define void @exp2_f32(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <4 x i32> [ { 0, 1, 2, 3 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <4 x i32> %vec.ind to <4 x float>
  %#2 = call <4 x float> @_ZGVnN4v_exp2f(<4 x float> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 4 x i64 %#0
  %#4 = gep inbounds ptr %#3, 4 x i32 0
  store <4 x float> %#2, ptr %#4, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to float
  %call = call float @exp2f(float %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %call, ptr %arrayidx, align 4
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @exp2f

-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InjectTLIMappings

----------------------------------------
declare double @exp10(double)

define void @exp10_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 111. InjectTLIMappings

----------------------------------------
declare double @exp10(double)

define void @exp10_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 112. LoopVectorizePass

----------------------------------------
declare double @exp10(double)

define void @exp10_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 113. LoopVectorizePass

----------------------------------------
declare double @exp10(double)

define void @exp10_f64(ptr nocapture %varray) {
entry:
  br label %for.body

for.body:
  %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
=>
declare <2 x double> @_ZGVnN2v_exp10(<2 x double>)
declare double @exp10(double)

define void @exp10_f64(ptr nocapture %varray) {
entry:
  br i1 0, label %scalar.ph, label %vector.ph

vector.ph:
  br label %vector.body

vector.body:
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i32> [ { 0, 1 }, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %#0 = add i64 %index, 0
  %#1 = sitofp <2 x i32> %vec.ind to <2 x double>
  %#2 = call <2 x double> @_ZGVnN2v_exp10(<2 x double> %#1)
  %#3 = gep inbounds ptr nocapture %varray, 8 x i64 %#0
  %#4 = gep inbounds ptr %#3, 8 x i32 0
  store <2 x double> %#2, ptr %#4, align 8
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %#5 = icmp eq i64 %index.next, 1000
  br i1 %#5, label %middle.block, label %vector.body

middle.block:
  br i1 1, label %for.end, label %scalar.ph

scalar.ph:
  %bc.resume.val = phi i64 [ 1000, %middle.block ], [ 0, %entry ]
  br label %for.body

for.body:
  %iv = phi i64 [ %bc.resume.val, %scalar.ph ], [ %iv.next, %for.body ]
  %tmp = trunc i64 %iv to i32
  %conv = sitofp i32 %tmp to double
  %call = call double @exp10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %call, ptr %arrayidx, align 8
  %iv.next = add nsw nuw i64 %iv, 1
  %exitcond = icmp eq i64 %iv.next, 1000
  br i1 %exitcond, label %for.end, label %for.body

for.end:
  ret void
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target

Example:
ptr nocapture %varray = poison

Source:
  >> Jump to %for.body
i64 %iv = #x0000000000000000 (0)
i32 %tmp = #x00000000 (0)
double %conv = #x0000000000000000 (+0.0)
double %call = function did not return!

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 8	alloc type: 0	alive: false	address: 0
Block 1 >	size: 0	align: 1	alloc type: 0	alive: true	address: 1
Block 2 >	size: 0	align: 8	alloc type: 0	alive: true	address: 0

Target:
  >> Jump to %vector.ph
  >> Jump to %vector.body
i64 %index = #x0000000000000000 (0)
<2 x i32> %vec.ind = < #x00000000 (0), #x00000001 (1) >
i64 %#0 = #x0000000000000000 (0)
<2 x double> %#1 = < #x0000000000000000 (+0.0), #x3ff0000000000000 (1) >
Function @_ZGVnN2v_exp10 triggered UB


Pass: LoopVectorizePass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-vector-library=sleefgnuabi' '-passes=inject-tli-mappings,loop-vectorize' '-force-vector-interleave=1' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_m6xLHIp9_hhEF.bc"


------------------- SMT STATS -------------------
Num queries: 84
Num invalid: 0
Num skips:   0
Num trivial: 9 (9.7%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     83 (98.8%)
Num UNSAT:   1 (1.2%)
Alive2: Transform doesn't verify; aborting!

stderr:

RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh -vector-library=sleefgnuabi -passes=inject-tli-mappings,loop-vectorize -force-vector-interleave=1 -S < /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll --check-prefix=NEON
+ /home/nlopes/alive2/build/opt-alive.sh -vector-library=sleefgnuabi -passes=inject-tli-mappings,loop-vectorize -force-vector-interleave=1 -S
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll --check-prefix=NEON

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopVectorize/AArch64/sleef-calls-aarch64.ll --check-prefix=NEON

<-- Back