Test Failure: Transforms/LoopVectorize/PowerPC/massv-calls.ll

Test source: git

Log:

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

----------------------------------------
declare double @cbrt(double)

define void @cbrt_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 @cbrt(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 3. InjectTLIMappings

----------------------------------------
declare double @cbrt(double)

define void @cbrt_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 @cbrt(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 4. LoopVectorizePass

----------------------------------------
declare double @cbrt(double)

define void @cbrt_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 @cbrt(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 5. LoopVectorizePass

----------------------------------------
declare double @cbrt(double)

define void @cbrt_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 @cbrt(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__cbrtd2(<2 x double>)
declare double @cbrt(double)

define void @cbrt_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> @__cbrtd2(<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 4
  %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 @cbrt(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @cbrt

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

----------------------------------------
declare float @cbrtf(float)

define void @cbrt_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 @cbrtf(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 @cbrtf(float)

define void @cbrt_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 @cbrtf(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 @cbrtf(float)

define void @cbrt_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 @cbrtf(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 @cbrtf(float)

define void @cbrt_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 @cbrtf(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> @__cbrtf4(<4 x float>)
declare float @cbrtf(float)

define void @cbrt_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> @__cbrtf4(<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 @cbrtf(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: @cbrtf

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

----------------------------------------
declare double @pow(double, double)

define void @pow_f64(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @pow(double %conv, double %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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)

-- 15. InjectTLIMappings

----------------------------------------
declare double @pow(double, double)

define void @pow_f64(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @pow(double %conv, double %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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)

-- 16. LoopVectorizePass

----------------------------------------
declare double @pow(double, double)

define void @pow_f64(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @pow(double %conv, double %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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)

-- 17. LoopVectorizePass

----------------------------------------
declare double @pow(double, double)

define void @pow_f64(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @pow(double %conv, double %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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 <2 x double> @__powd2(<2 x double>, <2 x double>)
declare double @pow(double, double)

define void @pow_f64(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%entry:
  %exp2 = ptrtoint ptr nocapture nowrite %exp to i64
  %varray1 = ptrtoint ptr nocapture %varray to i64
  br i1 0, label %scalar.ph, label %vector.memcheck

%vector.memcheck:
  %0 = sub i64 %varray1, %exp2
  %diff.check = icmp ult i64 %0, 192
  br i1 %diff.check, 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 ]
  %1 = add i64 %index, 0
  %2 = sitofp <2 x i32> %vec.ind to <2 x double>
  %3 = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %1
  %4 = gep inbounds ptr %3, 8 x i32 0
  %wide.load = load <2 x double>, ptr %4, align 4
  %5 = call <2 x double> @__powd2(<2 x double> %2, <2 x double> %wide.load)
  %6 = gep inbounds ptr nocapture %varray, 8 x i64 %1
  %7 = gep inbounds ptr %6, 8 x i32 0
  store <2 x double> %5, ptr %7, align 4
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %8 = icmp eq i64 %index.next, 1000
  br i1 %8, 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 ], [ 0, %vector.memcheck ]
  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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @pow(double %conv, double %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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: @pow

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

----------------------------------------
declare double @llvm.pow.f64(double, double)

define void @pow_f64_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @llvm.pow.f64(double %conv, double %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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 double @llvm.pow.f64(double, double)

define void @pow_f64_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @llvm.pow.f64(double %conv, double %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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 double @llvm.pow.f64(double, double)

define void @pow_f64_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @llvm.pow.f64(double %conv, double %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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 double @llvm.pow.f64(double, double)

define void @pow_f64_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @llvm.pow.f64(double %conv, double %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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 <2 x double> @__powd2(<2 x double>, <2 x double>)
declare double @llvm.pow.f64(double, double)

define void @pow_f64_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%entry:
  %exp2 = ptrtoint ptr nocapture nowrite %exp to i64
  %varray1 = ptrtoint ptr nocapture %varray to i64
  br i1 0, label %scalar.ph, label %vector.memcheck

%vector.memcheck:
  %0 = sub i64 %varray1, %exp2
  %diff.check = icmp ult i64 %0, 192
  br i1 %diff.check, 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 ]
  %1 = add i64 %index, 0
  %2 = sitofp <2 x i32> %vec.ind to <2 x double>
  %3 = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %1
  %4 = gep inbounds ptr %3, 8 x i32 0
  %wide.load = load <2 x double>, ptr %4, align 4
  %5 = call <2 x double> @__powd2(<2 x double> %2, <2 x double> %wide.load)
  %6 = gep inbounds ptr nocapture %varray, 8 x i64 %1
  %7 = gep inbounds ptr %6, 8 x i32 0
  store <2 x double> %5, ptr %7, align 4
  %index.next = add nuw i64 %index, 2
  %vec.ind.next = add <2 x i32> %vec.ind, { 2, 2 }
  %8 = icmp eq i64 %index.next, 1000
  br i1 %8, 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 ], [ 0, %vector.memcheck ]
  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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 8 x i64 %iv
  %tmp1 = load double, ptr %arrayidx, align 4
  %tmp2 = call double @llvm.pow.f64(double %conv, double %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %tmp2, ptr %arrayidx2, 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!

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

----------------------------------------
declare float @powf(float, float)

define void @pow_f32(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @powf(float %conv, float %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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)

-- 27. InjectTLIMappings

----------------------------------------
declare float @powf(float, float)

define void @pow_f32(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @powf(float %conv, float %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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)

-- 28. LoopVectorizePass

----------------------------------------
declare float @powf(float, float)

define void @pow_f32(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @powf(float %conv, float %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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)

-- 29. LoopVectorizePass

----------------------------------------
declare float @powf(float, float)

define void @pow_f32(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @powf(float %conv, float %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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> @__powf4(<4 x float>, <4 x float>)
declare float @powf(float, float)

define void @pow_f32(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%entry:
  %exp2 = ptrtoint ptr nocapture nowrite %exp to i64
  %varray1 = ptrtoint ptr nocapture %varray to i64
  br i1 0, label %scalar.ph, label %vector.memcheck

%vector.memcheck:
  %0 = sub i64 %varray1, %exp2
  %diff.check = icmp ult i64 %0, 192
  br i1 %diff.check, 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 ]
  %1 = add i64 %index, 0
  %2 = sitofp <4 x i32> %vec.ind to <4 x float>
  %3 = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %1
  %4 = gep inbounds ptr %3, 4 x i32 0
  %wide.load = load <4 x float>, ptr %4, align 4
  %5 = call <4 x float> @__powf4(<4 x float> %2, <4 x float> %wide.load)
  %6 = gep inbounds ptr nocapture %varray, 4 x i64 %1
  %7 = gep inbounds ptr %6, 4 x i32 0
  store <4 x float> %5, ptr %7, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %8 = icmp eq i64 %index.next, 1000
  br i1 %8, 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 ], [ 0, %vector.memcheck ]
  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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @powf(float %conv, float %tmp1)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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: @powf

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

----------------------------------------
declare float @llvm.pow.f32(float, float)

define void @pow_f32_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @llvm.pow.f32(float %conv, float %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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 @llvm.pow.f32(float, float)

define void @pow_f32_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @llvm.pow.f32(float %conv, float %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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 @llvm.pow.f32(float, float)

define void @pow_f32_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @llvm.pow.f32(float %conv, float %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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 @llvm.pow.f32(float, float)

define void @pow_f32_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @llvm.pow.f32(float %conv, float %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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> @__powf4(<4 x float>, <4 x float>)
declare float @llvm.pow.f32(float, float)

define void @pow_f32_intrinsic(ptr nocapture %varray, ptr nocapture nowrite %exp) {
%entry:
  %exp2 = ptrtoint ptr nocapture nowrite %exp to i64
  %varray1 = ptrtoint ptr nocapture %varray to i64
  br i1 0, label %scalar.ph, label %vector.memcheck

%vector.memcheck:
  %0 = sub i64 %varray1, %exp2
  %diff.check = icmp ult i64 %0, 192
  br i1 %diff.check, 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 ]
  %1 = add i64 %index, 0
  %2 = sitofp <4 x i32> %vec.ind to <4 x float>
  %3 = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %1
  %4 = gep inbounds ptr %3, 4 x i32 0
  %wide.load = load <4 x float>, ptr %4, align 4
  %5 = call <4 x float> @__powf4(<4 x float> %2, <4 x float> %wide.load)
  %6 = gep inbounds ptr nocapture %varray, 4 x i64 %1
  %7 = gep inbounds ptr %6, 4 x i32 0
  store <4 x float> %5, ptr %7, align 4
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <4 x i32> %vec.ind, { 4, 4, 4, 4 }
  %8 = icmp eq i64 %index.next, 1000
  br i1 %8, 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 ], [ 0, %vector.memcheck ]
  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
  %arrayidx = gep inbounds ptr nocapture nowrite %exp, 4 x i64 %iv
  %tmp1 = load float, ptr %arrayidx, align 4
  %tmp2 = call float @llvm.pow.f32(float %conv, float %tmp1) nofree willreturn memory(none)
  %arrayidx2 = gep inbounds ptr nocapture %varray, 4 x i64 %iv
  store float %tmp2, ptr %arrayidx2, 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!

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

----------------------------------------
declare double @sqrt(double)

define void @sqrt_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
  assume_welldefined double %conv
  %call = sqrt double %conv
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 39. InjectTLIMappings

----------------------------------------
declare double @sqrt(double)

define void @sqrt_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
  assume_welldefined double %conv
  %call = sqrt double %conv
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 40. LoopVectorizePass

----------------------------------------
declare double @sqrt(double)

define void @sqrt_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
  assume_welldefined double %conv
  %call = sqrt double %conv
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 41. LoopVectorizePass

----------------------------------------
declare double @sqrt(double)

define void @sqrt_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
  assume_welldefined double %conv
  %call = sqrt double %conv
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

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

----------------------------------------
declare float @sqrtf(float)

define void @sqrt_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
  assume_welldefined float %conv
  %call = sqrt 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 @sqrtf(float)

define void @sqrt_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
  assume_welldefined float %conv
  %call = sqrt 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 @sqrtf(float)

define void @sqrt_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
  assume_welldefined float %conv
  %call = sqrt 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 @sqrtf(float)

define void @sqrt_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
  assume_welldefined float %conv
  %call = sqrt 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)

-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. 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 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)

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

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

-- 53. 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 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 <2 x double> @__expd2(<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> @__expd2(<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 4
  %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 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: @exp

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

----------------------------------------
declare double @llvm.exp.f64(double)

define void @exp_f64_intrinsic(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 @llvm.exp.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 double @llvm.exp.f64(double)

define void @exp_f64_intrinsic(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 @llvm.exp.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 double @llvm.exp.f64(double)

define void @exp_f64_intrinsic(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 @llvm.exp.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 double @llvm.exp.f64(double)

define void @exp_f64_intrinsic(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 @llvm.exp.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__expd2(<2 x double>)
declare double @llvm.exp.f64(double)

define void @exp_f64_intrinsic(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> @__expd2(<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 4
  %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 @llvm.exp.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. 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)

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

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

-- 65. 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> @__expf4(<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> @__expf4(<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

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

----------------------------------------
declare float @llvm.exp.f32(float)

define void @exp_f32_intrinsic(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 @llvm.exp.f32(float %conv) nofree willreturn memory(none)
  %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 @llvm.exp.f32(float)

define void @exp_f32_intrinsic(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 @llvm.exp.f32(float %conv) nofree willreturn memory(none)
  %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 @llvm.exp.f32(float)

define void @exp_f32_intrinsic(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 @llvm.exp.f32(float %conv) nofree willreturn memory(none)
  %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 @llvm.exp.f32(float)

define void @exp_f32_intrinsic(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 @llvm.exp.f32(float %conv) nofree willreturn memory(none)
  %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> @__expf4(<4 x float>)
declare float @llvm.exp.f32(float)

define void @exp_f32_intrinsic(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> @__expf4(<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 @llvm.exp.f32(float %conv) nofree willreturn memory(none)
  %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!

-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. 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 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)

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

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

-- 77. 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 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 <2 x double> @__exp2d2(<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> @__exp2d2(<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 4
  %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 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: @exp2

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

----------------------------------------
declare double @llvm.exp2.f64(double)

define void @exp2_f64_intrinsic(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 @llvm.exp2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 double @llvm.exp2.f64(double)

define void @exp2_f64_intrinsic(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 @llvm.exp2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 double @llvm.exp2.f64(double)

define void @exp2_f64_intrinsic(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 @llvm.exp2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 double @llvm.exp2.f64(double)

define void @exp2_f64_intrinsic(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 @llvm.exp2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__exp2d2(<2 x double>)
declare double @llvm.exp2.f64(double)

define void @exp2_f64_intrinsic(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> @__exp2d2(<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 4
  %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 @llvm.exp2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. 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)

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

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

-- 89. 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> @__exp2f4(<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> @__exp2f4(<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

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

----------------------------------------
declare float @llvm.exp2.f32(float)

define void @exp2_f32_intrinsic(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 @llvm.exp2.f32(float %conv) nofree willreturn memory(none)
  %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 @llvm.exp2.f32(float)

define void @exp2_f32_intrinsic(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 @llvm.exp2.f32(float %conv) nofree willreturn memory(none)
  %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 @llvm.exp2.f32(float)

define void @exp2_f32_intrinsic(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 @llvm.exp2.f32(float %conv) nofree willreturn memory(none)
  %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 @llvm.exp2.f32(float)

define void @exp2_f32_intrinsic(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 @llvm.exp2.f32(float %conv) nofree willreturn memory(none)
  %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> @__exp2f4(<4 x float>)
declare float @llvm.exp2.f32(float)

define void @exp2_f32_intrinsic(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> @__exp2f4(<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 @llvm.exp2.f32(float %conv) nofree willreturn memory(none)
  %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!

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

----------------------------------------
declare double @expm1(double)

define void @expm1_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 @expm1(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 99. InjectTLIMappings

----------------------------------------
declare double @expm1(double)

define void @expm1_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 @expm1(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 100. LoopVectorizePass

----------------------------------------
declare double @expm1(double)

define void @expm1_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 @expm1(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 101. LoopVectorizePass

----------------------------------------
declare double @expm1(double)

define void @expm1_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 @expm1(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__expm1d2(<2 x double>)
declare double @expm1(double)

define void @expm1_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> @__expm1d2(<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 4
  %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 @expm1(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @expm1

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

----------------------------------------
declare float @expm1f(float)

define void @expm1_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 @expm1f(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 @expm1f(float)

define void @expm1_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 @expm1f(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 @expm1f(float)

define void @expm1_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 @expm1f(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 @expm1f(float)

define void @expm1_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 @expm1f(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> @__expm1f4(<4 x float>)
declare float @expm1f(float)

define void @expm1_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> @__expm1f4(<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 @expm1f(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: @expm1f

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

----------------------------------------
declare double @log(double)

define void @log_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 @log(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 111. InjectTLIMappings

----------------------------------------
declare double @log(double)

define void @log_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 @log(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 112. LoopVectorizePass

----------------------------------------
declare double @log(double)

define void @log_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 @log(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 113. LoopVectorizePass

----------------------------------------
declare double @log(double)

define void @log_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 @log(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__logd2(<2 x double>)
declare double @log(double)

define void @log_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> @__logd2(<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 4
  %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 @log(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @log

-- 114. PassManager<Function> : Skipping NOP
-- 115. PassManager<Function> : Skipping NOP
-- 116. InjectTLIMappings

----------------------------------------
declare double @llvm.log.f64(double)

define void @log_f64_intrinsic(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 @llvm.log.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 117. InjectTLIMappings

----------------------------------------
declare double @llvm.log.f64(double)

define void @log_f64_intrinsic(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 @llvm.log.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 118. LoopVectorizePass

----------------------------------------
declare double @llvm.log.f64(double)

define void @log_f64_intrinsic(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 @llvm.log.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 119. LoopVectorizePass

----------------------------------------
declare double @llvm.log.f64(double)

define void @log_f64_intrinsic(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 @llvm.log.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__logd2(<2 x double>)
declare double @llvm.log.f64(double)

define void @log_f64_intrinsic(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> @__logd2(<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 4
  %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 @llvm.log.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InjectTLIMappings

----------------------------------------
declare float @logf(float)

define void @log_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 @logf(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)

-- 123. InjectTLIMappings

----------------------------------------
declare float @logf(float)

define void @log_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 @logf(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)

-- 124. LoopVectorizePass

----------------------------------------
declare float @logf(float)

define void @log_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 @logf(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)

-- 125. LoopVectorizePass

----------------------------------------
declare float @logf(float)

define void @log_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 @logf(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> @__logf4(<4 x float>)
declare float @logf(float)

define void @log_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> @__logf4(<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 @logf(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: @logf

-- 126. PassManager<Function> : Skipping NOP
-- 127. PassManager<Function> : Skipping NOP
-- 128. InjectTLIMappings

----------------------------------------
declare float @llvm.log.f32(float)

define void @log_f32_intrinsic(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 @llvm.log.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 129. InjectTLIMappings

----------------------------------------
declare float @llvm.log.f32(float)

define void @log_f32_intrinsic(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 @llvm.log.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 130. LoopVectorizePass

----------------------------------------
declare float @llvm.log.f32(float)

define void @log_f32_intrinsic(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 @llvm.log.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 131. LoopVectorizePass

----------------------------------------
declare float @llvm.log.f32(float)

define void @log_f32_intrinsic(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 @llvm.log.f32(float %conv) nofree willreturn memory(none)
  %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> @__logf4(<4 x float>)
declare float @llvm.log.f32(float)

define void @log_f32_intrinsic(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> @__logf4(<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 @llvm.log.f32(float %conv) nofree willreturn memory(none)
  %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!

-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InjectTLIMappings

----------------------------------------
declare double @log1p(double)

define void @log1p_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 @log1p(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 135. InjectTLIMappings

----------------------------------------
declare double @log1p(double)

define void @log1p_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 @log1p(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 136. LoopVectorizePass

----------------------------------------
declare double @log1p(double)

define void @log1p_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 @log1p(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 137. LoopVectorizePass

----------------------------------------
declare double @log1p(double)

define void @log1p_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 @log1p(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__log1pd2(<2 x double>)
declare double @log1p(double)

define void @log1p_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> @__log1pd2(<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 4
  %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 @log1p(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @log1p

-- 138. PassManager<Function> : Skipping NOP
-- 139. PassManager<Function> : Skipping NOP
-- 140. InjectTLIMappings

----------------------------------------
declare float @log1pf(float)

define void @log1p_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 @log1pf(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)

-- 141. InjectTLIMappings

----------------------------------------
declare float @log1pf(float)

define void @log1p_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 @log1pf(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)

-- 142. LoopVectorizePass

----------------------------------------
declare float @log1pf(float)

define void @log1p_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 @log1pf(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)

-- 143. LoopVectorizePass

----------------------------------------
declare float @log1pf(float)

define void @log1p_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 @log1pf(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> @__log1pf4(<4 x float>)
declare float @log1pf(float)

define void @log1p_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> @__log1pf4(<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 @log1pf(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: @log1pf

-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InjectTLIMappings

----------------------------------------
declare double @log10(double)

define void @log10_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 @log10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 147. InjectTLIMappings

----------------------------------------
declare double @log10(double)

define void @log10_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 @log10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 148. LoopVectorizePass

----------------------------------------
declare double @log10(double)

define void @log10_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 @log10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 149. LoopVectorizePass

----------------------------------------
declare double @log10(double)

define void @log10_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 @log10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__log10d2(<2 x double>)
declare double @log10(double)

define void @log10_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> @__log10d2(<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 4
  %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 @log10(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @log10

-- 150. PassManager<Function> : Skipping NOP
-- 151. PassManager<Function> : Skipping NOP
-- 152. InjectTLIMappings

----------------------------------------
declare double @llvm.log10.f64(double)

define void @log10_f64_intrinsic(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 @llvm.log10.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 153. InjectTLIMappings

----------------------------------------
declare double @llvm.log10.f64(double)

define void @log10_f64_intrinsic(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 @llvm.log10.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 154. LoopVectorizePass

----------------------------------------
declare double @llvm.log10.f64(double)

define void @log10_f64_intrinsic(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 @llvm.log10.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 155. LoopVectorizePass

----------------------------------------
declare double @llvm.log10.f64(double)

define void @log10_f64_intrinsic(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 @llvm.log10.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__log10d2(<2 x double>)
declare double @llvm.log10.f64(double)

define void @log10_f64_intrinsic(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> @__log10d2(<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 4
  %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 @llvm.log10.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InjectTLIMappings

----------------------------------------
declare float @log10f(float)

define void @log10_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 @log10f(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)

-- 159. InjectTLIMappings

----------------------------------------
declare float @log10f(float)

define void @log10_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 @log10f(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)

-- 160. LoopVectorizePass

----------------------------------------
declare float @log10f(float)

define void @log10_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 @log10f(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)

-- 161. LoopVectorizePass

----------------------------------------
declare float @log10f(float)

define void @log10_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 @log10f(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> @__log10f4(<4 x float>)
declare float @log10f(float)

define void @log10_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> @__log10f4(<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 @log10f(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: @log10f

-- 162. PassManager<Function> : Skipping NOP
-- 163. PassManager<Function> : Skipping NOP
-- 164. InjectTLIMappings

----------------------------------------
declare float @llvm.log10.f32(float)

define void @log10_f32_intrinsic(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 @llvm.log10.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 165. InjectTLIMappings

----------------------------------------
declare float @llvm.log10.f32(float)

define void @log10_f32_intrinsic(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 @llvm.log10.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 166. LoopVectorizePass

----------------------------------------
declare float @llvm.log10.f32(float)

define void @log10_f32_intrinsic(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 @llvm.log10.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 167. LoopVectorizePass

----------------------------------------
declare float @llvm.log10.f32(float)

define void @log10_f32_intrinsic(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 @llvm.log10.f32(float %conv) nofree willreturn memory(none)
  %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> @__log10f4(<4 x float>)
declare float @llvm.log10.f32(float)

define void @log10_f32_intrinsic(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> @__log10f4(<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 @llvm.log10.f32(float %conv) nofree willreturn memory(none)
  %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!

-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InjectTLIMappings

----------------------------------------
declare double @log2(double)

define void @log2_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 @log2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 171. InjectTLIMappings

----------------------------------------
declare double @log2(double)

define void @log2_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 @log2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 172. LoopVectorizePass

----------------------------------------
declare double @log2(double)

define void @log2_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 @log2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 173. LoopVectorizePass

----------------------------------------
declare double @log2(double)

define void @log2_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 @log2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__log2d2(<2 x double>)
declare double @log2(double)

define void @log2_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> @__log2d2(<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 4
  %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 @log2(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @log2

-- 174. PassManager<Function> : Skipping NOP
-- 175. PassManager<Function> : Skipping NOP
-- 176. InjectTLIMappings

----------------------------------------
declare double @llvm.log2.f64(double)

define void @log2_f64_intrinsic(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 @llvm.log2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 177. InjectTLIMappings

----------------------------------------
declare double @llvm.log2.f64(double)

define void @log2_f64_intrinsic(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 @llvm.log2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 178. LoopVectorizePass

----------------------------------------
declare double @llvm.log2.f64(double)

define void @log2_f64_intrinsic(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 @llvm.log2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 179. LoopVectorizePass

----------------------------------------
declare double @llvm.log2.f64(double)

define void @log2_f64_intrinsic(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 @llvm.log2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__log2d2(<2 x double>)
declare double @llvm.log2.f64(double)

define void @log2_f64_intrinsic(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> @__log2d2(<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 4
  %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 @llvm.log2.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InjectTLIMappings

----------------------------------------
declare float @log2f(float)

define void @log2_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 @log2f(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)

-- 183. InjectTLIMappings

----------------------------------------
declare float @log2f(float)

define void @log2_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 @log2f(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)

-- 184. LoopVectorizePass

----------------------------------------
declare float @log2f(float)

define void @log2_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 @log2f(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)

-- 185. LoopVectorizePass

----------------------------------------
declare float @log2f(float)

define void @log2_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 @log2f(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> @__log2f4(<4 x float>)
declare float @log2f(float)

define void @log2_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> @__log2f4(<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 @log2f(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: @log2f

-- 186. PassManager<Function> : Skipping NOP
-- 187. PassManager<Function> : Skipping NOP
-- 188. InjectTLIMappings

----------------------------------------
declare float @llvm.log2.f32(float)

define void @log2_f32_intrinsic(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 @llvm.log2.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 189. InjectTLIMappings

----------------------------------------
declare float @llvm.log2.f32(float)

define void @log2_f32_intrinsic(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 @llvm.log2.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 190. LoopVectorizePass

----------------------------------------
declare float @llvm.log2.f32(float)

define void @log2_f32_intrinsic(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 @llvm.log2.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 191. LoopVectorizePass

----------------------------------------
declare float @llvm.log2.f32(float)

define void @log2_f32_intrinsic(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 @llvm.log2.f32(float %conv) nofree willreturn memory(none)
  %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> @__log2f4(<4 x float>)
declare float @llvm.log2.f32(float)

define void @log2_f32_intrinsic(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> @__log2f4(<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 @llvm.log2.f32(float %conv) nofree willreturn memory(none)
  %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!

-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InjectTLIMappings

----------------------------------------
declare double @sin(double)

define void @sin_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 @sin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 195. InjectTLIMappings

----------------------------------------
declare double @sin(double)

define void @sin_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 @sin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 196. LoopVectorizePass

----------------------------------------
declare double @sin(double)

define void @sin_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 @sin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 197. LoopVectorizePass

----------------------------------------
declare double @sin(double)

define void @sin_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 @sin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__sind2(<2 x double>)
declare double @sin(double)

define void @sin_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> @__sind2(<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 4
  %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 @sin(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @sin

-- 198. PassManager<Function> : Skipping NOP
-- 199. PassManager<Function> : Skipping NOP
-- 200. InjectTLIMappings

----------------------------------------
declare double @llvm.sin.f64(double)

define void @sin_f64_intrinsic(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 @llvm.sin.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 201. InjectTLIMappings

----------------------------------------
declare double @llvm.sin.f64(double)

define void @sin_f64_intrinsic(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 @llvm.sin.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 202. LoopVectorizePass

----------------------------------------
declare double @llvm.sin.f64(double)

define void @sin_f64_intrinsic(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 @llvm.sin.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 203. LoopVectorizePass

----------------------------------------
declare double @llvm.sin.f64(double)

define void @sin_f64_intrinsic(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 @llvm.sin.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__sind2(<2 x double>)
declare double @llvm.sin.f64(double)

define void @sin_f64_intrinsic(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> @__sind2(<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 4
  %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 @llvm.sin.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 204. PassManager<Function> : Skipping NOP
-- 205. PassManager<Function> : Skipping NOP
-- 206. InjectTLIMappings

----------------------------------------
declare float @sinf(float)

define void @sin_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 @sinf(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)

-- 207. InjectTLIMappings

----------------------------------------
declare float @sinf(float)

define void @sin_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 @sinf(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)

-- 208. LoopVectorizePass

----------------------------------------
declare float @sinf(float)

define void @sin_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 @sinf(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)

-- 209. LoopVectorizePass

----------------------------------------
declare float @sinf(float)

define void @sin_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 @sinf(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> @__sinf4(<4 x float>)
declare float @sinf(float)

define void @sin_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> @__sinf4(<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 @sinf(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: @sinf

-- 210. PassManager<Function> : Skipping NOP
-- 211. PassManager<Function> : Skipping NOP
-- 212. InjectTLIMappings

----------------------------------------
declare float @llvm.sin.f32(float)

define void @sin_f32_intrinsic(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 @llvm.sin.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 213. InjectTLIMappings

----------------------------------------
declare float @llvm.sin.f32(float)

define void @sin_f32_intrinsic(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 @llvm.sin.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 214. LoopVectorizePass

----------------------------------------
declare float @llvm.sin.f32(float)

define void @sin_f32_intrinsic(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 @llvm.sin.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 215. LoopVectorizePass

----------------------------------------
declare float @llvm.sin.f32(float)

define void @sin_f32_intrinsic(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 @llvm.sin.f32(float %conv) nofree willreturn memory(none)
  %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> @__sinf4(<4 x float>)
declare float @llvm.sin.f32(float)

define void @sin_f32_intrinsic(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> @__sinf4(<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 @llvm.sin.f32(float %conv) nofree willreturn memory(none)
  %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!

-- 216. PassManager<Function> : Skipping NOP
-- 217. PassManager<Function> : Skipping NOP
-- 218. 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 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)

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

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

-- 221. 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 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 <2 x double> @__cosd2(<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> @__cosd2(<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 4
  %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 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: @cos

-- 222. PassManager<Function> : Skipping NOP
-- 223. PassManager<Function> : Skipping NOP
-- 224. InjectTLIMappings

----------------------------------------
declare double @llvm.cos.f64(double)

define void @cos_f64_intrinsic(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 @llvm.cos.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 225. InjectTLIMappings

----------------------------------------
declare double @llvm.cos.f64(double)

define void @cos_f64_intrinsic(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 @llvm.cos.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 226. LoopVectorizePass

----------------------------------------
declare double @llvm.cos.f64(double)

define void @cos_f64_intrinsic(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 @llvm.cos.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 227. LoopVectorizePass

----------------------------------------
declare double @llvm.cos.f64(double)

define void @cos_f64_intrinsic(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 @llvm.cos.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__cosd2(<2 x double>)
declare double @llvm.cos.f64(double)

define void @cos_f64_intrinsic(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> @__cosd2(<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 4
  %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 @llvm.cos.f64(double %conv) nofree willreturn memory(none)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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!

-- 228. PassManager<Function> : Skipping NOP
-- 229. PassManager<Function> : Skipping NOP
-- 230. 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)

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

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

-- 233. 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> @__cosf4(<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> @__cosf4(<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

-- 234. PassManager<Function> : Skipping NOP
-- 235. PassManager<Function> : Skipping NOP
-- 236. InjectTLIMappings

----------------------------------------
declare float @llvm.cos.f32(float)

define void @cos_f32_intrinsic(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 @llvm.cos.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 237. InjectTLIMappings

----------------------------------------
declare float @llvm.cos.f32(float)

define void @cos_f32_intrinsic(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 @llvm.cos.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 238. LoopVectorizePass

----------------------------------------
declare float @llvm.cos.f32(float)

define void @cos_f32_intrinsic(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 @llvm.cos.f32(float %conv) nofree willreturn memory(none)
  %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)

-- 239. LoopVectorizePass

----------------------------------------
declare float @llvm.cos.f32(float)

define void @cos_f32_intrinsic(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 @llvm.cos.f32(float %conv) nofree willreturn memory(none)
  %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> @__cosf4(<4 x float>)
declare float @llvm.cos.f32(float)

define void @cos_f32_intrinsic(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> @__cosf4(<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 @llvm.cos.f32(float %conv) nofree willreturn memory(none)
  %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!

-- 240. PassManager<Function> : Skipping NOP
-- 241. PassManager<Function> : Skipping NOP
-- 242. InjectTLIMappings

----------------------------------------
declare double @tan(double)

define void @tan_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 @tan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 243. InjectTLIMappings

----------------------------------------
declare double @tan(double)

define void @tan_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 @tan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 244. LoopVectorizePass

----------------------------------------
declare double @tan(double)

define void @tan_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 @tan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 245. LoopVectorizePass

----------------------------------------
declare double @tan(double)

define void @tan_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 @tan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__tand2(<2 x double>)
declare double @tan(double)

define void @tan_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> @__tand2(<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 4
  %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 @tan(double %conv)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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: @tan

-- 246. PassManager<Function> : Skipping NOP
-- 247. PassManager<Function> : Skipping NOP
-- 248. InjectTLIMappings

----------------------------------------
declare float @tanf(float)

define void @tan_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 @tanf(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)

-- 249. InjectTLIMappings

----------------------------------------
declare float @tanf(float)

define void @tan_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 @tanf(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)

-- 250. LoopVectorizePass

----------------------------------------
declare float @tanf(float)

define void @tan_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 @tanf(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)

-- 251. LoopVectorizePass

----------------------------------------
declare float @tanf(float)

define void @tan_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 @tanf(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> @__tanf4(<4 x float>)
declare float @tanf(float)

define void @tan_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> @__tanf4(<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 @tanf(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: @tanf

-- 252. PassManager<Function> : Skipping NOP
-- 253. PassManager<Function> : Skipping NOP
-- 254. 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 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)

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

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

-- 257. 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 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 <2 x double> @__asind2(<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> @__asind2(<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 4
  %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 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: @asin

-- 258. PassManager<Function> : Skipping NOP
-- 259. PassManager<Function> : Skipping NOP
-- 260. 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)

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

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

-- 263. 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> @__asinf4(<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> @__asinf4(<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

-- 264. PassManager<Function> : Skipping NOP
-- 265. PassManager<Function> : Skipping NOP
-- 266. 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 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)

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

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

-- 269. 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 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 <2 x double> @__acosd2(<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> @__acosd2(<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 4
  %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 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: @acos

-- 270. PassManager<Function> : Skipping NOP
-- 271. PassManager<Function> : Skipping NOP
-- 272. 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)

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

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

-- 275. 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> @__acosf4(<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> @__acosf4(<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

-- 276. PassManager<Function> : Skipping NOP
-- 277. PassManager<Function> : Skipping NOP
-- 278. 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 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)

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

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

-- 281. 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 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 <2 x double> @__atand2(<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> @__atand2(<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 4
  %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 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: @atan

-- 282. PassManager<Function> : Skipping NOP
-- 283. PassManager<Function> : Skipping NOP
-- 284. 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)

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

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

-- 287. 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> @__atanf4(<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> @__atanf4(<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

-- 288. PassManager<Function> : Skipping NOP
-- 289. PassManager<Function> : Skipping NOP
-- 290. InjectTLIMappings

----------------------------------------
declare double @atan2(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)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 291. InjectTLIMappings

----------------------------------------
declare double @atan2(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)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 292. LoopVectorizePass

----------------------------------------
declare double @atan2(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)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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)

-- 293. LoopVectorizePass

----------------------------------------
declare double @atan2(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)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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 <2 x double> @__atan2d2(<2 x double>)
declare double @atan2(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> @__atan2d2(<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 4
  %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)
  %arrayidx = gep inbounds ptr nocapture %varray, 8 x i64 %iv
  store double %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! (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: 4	alloc type: 0	address: 0
Block 1 >	size: 0	align: 1	alloc type: 0	address: 1
Block 2 >	size: 0	align: 4	alloc type: 0	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 @__atan2d2 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=MASSV' '-mtriple=powerpc64le-unknown-linux-gnu' '-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_uvucrbft_xZ6C.bc"


------------------- SMT STATS -------------------
Num queries: 133
Num invalid: 0
Num skips:   0
Num trivial: 105 (44.1%)
Num timeout: 0 (0.0%)
Num errors:  0 (0.0%)
Num SAT:     132 (99.2%)
Num UNSAT:   1 (0.8%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 1'
+ /home/nlopes/alive2/build/opt-alive.sh -vector-library=MASSV -mtriple=powerpc64le-unknown-linux-gnu -passes=inject-tli-mappings,loop-vectorize -force-vector-interleave=1 -S
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopVectorize/PowerPC/massv-calls.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/LoopVectorize/PowerPC/massv-calls.ll

<-- Back