RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-21 01:06:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[ValueTracking] readonly (const) is a requirement for converting sqrt to llvm.sqrt; nnan is not

Browse Source 
As discussed in D39204, this is effectively a revert of rL265521 which required nnan 
to vectorize sqrt libcalls based on the old LangRef definition of llvm.sqrt. Now that
the definition has been updated so the libcall and intrinsic have the same semantics
apart from potentially setting errno, we can remove the nnan requirement.

We have the right check to know that errno is not set:

if (!ICS.onlyReadsMemory())

...ahead of the switch.

This will solve https://bugs.llvm.org/show_bug.cgi?id=27435 assuming that's being 
built for a target with -fno-math-errno.

Differential Revision: https://reviews.llvm.org/D39642


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@317519 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2017-11-06 22:40:09 +00:00
parent e209a1a12d
commit 618cf29088
2 changed files with 39 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/Analysis/ValueTracking.cpp
View File

@ -2579,9 +2579,7 @@ Intrinsic::ID llvm::getIntrinsicForCallSite(ImmutableCallSite ICS,
case LibFunc_sqrt:
case LibFunc_sqrtf:
case LibFunc_sqrtl:
if (ICS->hasNoNaNs())
return Intrinsic::sqrt;
return Intrinsic::not_intrinsic;
return Intrinsic::sqrt;
}
return Intrinsic::not_intrinsic;

45
test/Transforms/SLPVectorizer/X86/call.ll
View File

@ -91,11 +91,14 @@ define void @exp_libm(double* %a, double* %b) {
ret void
}
define void @sqrt_libm(double* %a, double* %b) {
; CHECK-LABEL: @sqrt_libm(
; No fast-math-flags are required to convert sqrt library calls to an intrinsic.
; We just need to know that errno is not set (readnone).
define void @sqrt_libm_no_errno(double* %a, double* %b) {
; CHECK-LABEL: @sqrt_libm_no_errno(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast double* %a to <2 x double>*
; CHECK-NEXT: [[TMP2:%.*]] = load <2 x double>, <2 x double>* [[TMP1]], align 8
; CHECK-NEXT: [[TMP3:%.*]] = call nnan <2 x double> @llvm.sqrt.v2f64(<2 x double> [[TMP2]])
; CHECK-NEXT: [[TMP3:%.*]] = call <2 x double> @llvm.sqrt.v2f64(<2 x double> [[TMP2]])
; CHECK-NEXT: [[TMP4:%.*]] = bitcast double* %b to <2 x double>*
; CHECK-NEXT: store <2 x double> [[TMP3]], <2 x double>* [[TMP4]], align 8
; CHECK-NEXT: ret void
@ -103,8 +106,36 @@ define void @sqrt_libm(double* %a, double* %b) {
%a0 = load double, double* %a, align 8
%idx1 = getelementptr inbounds double, double* %a, i64 1
%a1 = load double, double* %idx1, align 8
%sqrt1 = tail call nnan double @sqrt(double %a0) nounwind readnone
%sqrt2 = tail call nnan double @sqrt(double %a1) nounwind readnone
%sqrt1 = tail call double @sqrt(double %a0) nounwind readnone
%sqrt2 = tail call double @sqrt(double %a1) nounwind readnone
store double %sqrt1, double* %b, align 8
%idx2 = getelementptr inbounds double, double* %b, i64 1
store double %sqrt2, double* %idx2, align 8
ret void
}
; The sqrt intrinsic does not set errno, but a non-constant sqrt call might, so this can't vectorize.
; The nnan on the call does not matter because there's no guarantee in the C standard that a negative
; input would result in a nan output ("On a domain error, the function returns an
; implementation-defined value.")
define void @sqrt_libm_errno(double* %a, double* %b) {
; CHECK-LABEL: @sqrt_libm_errno(
; CHECK-NEXT: [[A0:%.*]] = load double, double* %a, align 8
; CHECK-NEXT: [[IDX1:%.*]] = getelementptr inbounds double, double* %a, i64 1
; CHECK-NEXT: [[A1:%.*]] = load double, double* [[IDX1]], align 8
; CHECK-NEXT: [[SQRT1:%.*]] = tail call nnan double @sqrt(double [[A0]]) #2
; CHECK-NEXT: [[SQRT2:%.*]] = tail call nnan double @sqrt(double [[A1]]) #2
; CHECK-NEXT: store double [[SQRT1]], double* %b, align 8
; CHECK-NEXT: [[IDX2:%.*]] = getelementptr inbounds double, double* %b, i64 1
; CHECK-NEXT: store double [[SQRT2]], double* [[IDX2]], align 8
; CHECK-NEXT: ret void
;
%a0 = load double, double* %a, align 8
%idx1 = getelementptr inbounds double, double* %a, i64 1
%a1 = load double, double* %idx1, align 8
%sqrt1 = tail call nnan double @sqrt(double %a0) nounwind
%sqrt2 = tail call nnan double @sqrt(double %a1) nounwind
store double %sqrt1, double* %b, align 8
%idx2 = getelementptr inbounds double, double* %b, i64 1
store double %sqrt2, double* %idx2, align 8
@ -117,8 +148,8 @@ define void @round_custom(i64* %a, i64* %b) {
; CHECK-NEXT: [[A0:%.*]] = load i64, i64* %a, align 8
; CHECK-NEXT: [[IDX1:%.*]] = getelementptr inbounds i64, i64* %a, i64 1
; CHECK-NEXT: [[A1:%.*]] = load i64, i64* [[IDX1]], align 8
; CHECK-NEXT: [[ROUND1:%.*]] = tail call i64 @round(i64 [[A0]]) #2
; CHECK-NEXT: [[ROUND2:%.*]] = tail call i64 @round(i64 [[A1]]) #2
; CHECK-NEXT: [[ROUND1:%.*]] = tail call i64 @round(i64 [[A0]]) #3
; CHECK-NEXT: [[ROUND2:%.*]] = tail call i64 @round(i64 [[A1]]) #3
; CHECK-NEXT: store i64 [[ROUND1]], i64* %b, align 8
; CHECK-NEXT: [[IDX2:%.*]] = getelementptr inbounds i64, i64* %b, i64 1
; CHECK-NEXT: store i64 [[ROUND2]], i64* [[IDX2]], align 8