Skip to content

Commit ef38833

Browse files
PiJoulesPiJoules
committed
Revert "Reapply "InstCombine: Introduce SimplifyDemandedUseFPClass""
This reverts commit 5a36904. Reverted because this breaks some floating point operations. See the comment on llvm@5a36904c515b.
1 parent f248d0b commit ef38833

File tree

6 files changed

+150
-292
lines changed

6 files changed

+150
-292
lines changed

‎clang/test/Headers/__clang_hip_math.hip

Lines changed: 18 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -231,26 +231,26 @@ extern "C" __device__ uint64_t test___make_mantissa(const char *p) {
231231

232232
// CHECK-LABEL: @test_abs(
233233
// CHECK-NEXT: entry:
234-
// CHECK-NEXT: [[TMP0:%.*]] = tail call noundef i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true)
235-
// CHECK-NEXT: ret i32 [[TMP0]]
234+
// CHECK-NEXT: [[ABS_I:%.*]] = tail call noundef i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true)
235+
// CHECK-NEXT: ret i32 [[ABS_I]]
236236
//
237237
extern "C" __device__ int test_abs(int x) {
238238
return abs(x);
239239
}
240240

241241
// CHECK-LABEL: @test_labs(
242242
// CHECK-NEXT: entry:
243-
// CHECK-NEXT: [[TMP0:%.*]] = tail call noundef i64 @llvm.abs.i64(i64 [[X:%.*]], i1 true)
244-
// CHECK-NEXT: ret i64 [[TMP0]]
243+
// CHECK-NEXT: [[ABS_I:%.*]] = tail call noundef i64 @llvm.abs.i64(i64 [[X:%.*]], i1 true)
244+
// CHECK-NEXT: ret i64 [[ABS_I]]
245245
//
246246
extern "C" __device__ long test_labs(long x) {
247247
return labs(x);
248248
}
249249

250250
// CHECK-LABEL: @test_llabs(
251251
// CHECK-NEXT: entry:
252-
// CHECK-NEXT: [[TMP0:%.*]] = tail call noundef i64 @llvm.abs.i64(i64 [[X:%.*]], i1 true)
253-
// CHECK-NEXT: ret i64 [[TMP0]]
252+
// CHECK-NEXT: [[ABS_I:%.*]] = tail call noundef i64 @llvm.abs.i64(i64 [[X:%.*]], i1 true)
253+
// CHECK-NEXT: ret i64 [[ABS_I]]
254254
//
255255
extern "C" __device__ long long test_llabs(long x) {
256256
return llabs(x);
@@ -2557,65 +2557,33 @@ extern "C" __device__ double test_nan(const char *tag) {
25572557
return nan(tag);
25582558
}
25592559

2560-
// DEFAULT-LABEL: @test_nanf_emptystr(
2561-
// DEFAULT-NEXT: entry:
2562-
// DEFAULT-NEXT: ret float 0x7FF8000000000000
2563-
//
2564-
// FINITEONLY-LABEL: @test_nanf_emptystr(
2565-
// FINITEONLY-NEXT: entry:
2566-
// FINITEONLY-NEXT: ret float poison
2567-
//
2568-
// APPROX-LABEL: @test_nanf_emptystr(
2569-
// APPROX-NEXT: entry:
2570-
// APPROX-NEXT: ret float 0x7FF8000000000000
2560+
// CHECK-LABEL: @test_nanf_emptystr(
2561+
// CHECK-NEXT: entry:
2562+
// CHECK-NEXT: ret float 0x7FF8000000000000
25712563
//
25722564
extern "C" __device__ float test_nanf_emptystr() {
25732565
return nanf("");
25742566
}
25752567

2576-
// DEFAULT-LABEL: @test_nan_emptystr(
2577-
// DEFAULT-NEXT: entry:
2578-
// DEFAULT-NEXT: ret double 0x7FF8000000000000
2579-
//
2580-
// FINITEONLY-LABEL: @test_nan_emptystr(
2581-
// FINITEONLY-NEXT: entry:
2582-
// FINITEONLY-NEXT: ret double poison
2583-
//
2584-
// APPROX-LABEL: @test_nan_emptystr(
2585-
// APPROX-NEXT: entry:
2586-
// APPROX-NEXT: ret double 0x7FF8000000000000
2568+
// CHECK-LABEL: @test_nan_emptystr(
2569+
// CHECK-NEXT: entry:
2570+
// CHECK-NEXT: ret double 0x7FF8000000000000
25872571
//
25882572
extern "C" __device__ double test_nan_emptystr() {
25892573
return nan("");
25902574
}
25912575

2592-
// DEFAULT-LABEL: @test_nanf_fill(
2593-
// DEFAULT-NEXT: entry:
2594-
// DEFAULT-NEXT: ret float 0x7FF8000000000000
2595-
//
2596-
// FINITEONLY-LABEL: @test_nanf_fill(
2597-
// FINITEONLY-NEXT: entry:
2598-
// FINITEONLY-NEXT: ret float poison
2599-
//
2600-
// APPROX-LABEL: @test_nanf_fill(
2601-
// APPROX-NEXT: entry:
2602-
// APPROX-NEXT: ret float 0x7FF8000000000000
2576+
// CHECK-LABEL: @test_nanf_fill(
2577+
// CHECK-NEXT: entry:
2578+
// CHECK-NEXT: ret float 0x7FF8000000000000
26032579
//
26042580
extern "C" __device__ float test_nanf_fill() {
26052581
return nanf("0x456");
26062582
}
26072583

2608-
// DEFAULT-LABEL: @test_nan_fill(
2609-
// DEFAULT-NEXT: entry:
2610-
// DEFAULT-NEXT: ret double 0x7FF8000000000000
2611-
//
2612-
// FINITEONLY-LABEL: @test_nan_fill(
2613-
// FINITEONLY-NEXT: entry:
2614-
// FINITEONLY-NEXT: ret double poison
2615-
//
2616-
// APPROX-LABEL: @test_nan_fill(
2617-
// APPROX-NEXT: entry:
2618-
// APPROX-NEXT: ret double 0x7FF8000000000000
2584+
// CHECK-LABEL: @test_nan_fill(
2585+
// CHECK-NEXT: entry:
2586+
// CHECK-NEXT: ret double 0x7FF8000000000000
26192587
//
26202588
extern "C" __device__ double test_nan_fill() {
26212589
return nan("0x123");

‎llvm/include/llvm/Analysis/ValueTracking.h

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -240,10 +240,6 @@ struct KnownFPClass {
240240
/// definitely set or false if the sign bit is definitely unset.
241241
std::optional<bool> SignBit;
242242

243-
bool operator==(KnownFPClass Other) const {
244-
return KnownFPClasses == Other.KnownFPClasses && SignBit == Other.SignBit;
245-
}
246-
247243
/// Return true if it's known this can never be one of the mask entries.
248244
bool isKnownNever(FPClassTest Mask) const {
249245
return (KnownFPClasses & Mask) == fcNone;

‎llvm/lib/Transforms/InstCombine/InstCombineInternal.h

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -548,15 +548,6 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
548548
APInt &UndefElts, unsigned Depth = 0,
549549
bool AllowMultipleUsers = false) override;
550550

551-
/// Attempts to replace V with a simpler value based on the demanded
552-
/// floating-point classes
553-
Value *SimplifyDemandedUseFPClass(Value *V, FPClassTest DemandedMask,
554-
KnownFPClass &Known, unsigned Depth,
555-
Instruction *CxtI);
556-
bool SimplifyDemandedFPClass(Instruction *I, unsigned Op,
557-
FPClassTest DemandedMask, KnownFPClass &Known,
558-
unsigned Depth = 0);
559-
560551
/// Canonicalize the position of binops relative to shufflevector.
561552
Instruction *foldVectorBinop(BinaryOperator &Inst);
562553
Instruction *foldVectorSelect(SelectInst &Sel);

‎llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

Lines changed: 1 addition & 139 deletions
Original file line numberDiff line numberDiff line change
@@ -461,8 +461,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
461461
if (InputKnown.isNonNegative() ||
462462
DemandedMask.getActiveBits() <= SrcBitWidth) {
463463
// Convert to ZExt cast.
464-
CastInst *NewCast = new ZExtInst(I->getOperand(0), VTy);
465-
NewCast->takeName(I);
464+
CastInst *NewCast = new ZExtInst(I->getOperand(0), VTy, I->getName());
466465
return InsertNewInstWith(NewCast, I->getIterator());
467466
}
468467

@@ -771,7 +770,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
771770
BinaryOperator *LShr = BinaryOperator::CreateLShr(I->getOperand(0),
772771
I->getOperand(1));
773772
LShr->setIsExact(cast<BinaryOperator>(I)->isExact());
774-
LShr->takeName(I);
775773
return InsertNewInstWith(LShr, I->getIterator());
776774
} else if (Known.One[BitWidth-ShiftAmt-1]) { // New bits are known one.
777775
Known.One |= HighBits;
@@ -1783,139 +1781,3 @@ Value *InstCombinerImpl::SimplifyDemandedVectorElts(Value *V,
17831781

17841782
return MadeChange ? I : nullptr;
17851783
}
1786-
1787-
/// For floating-point classes that resolve to a single bit pattern, return that
1788-
/// value.
1789-
static Constant *getFPClassConstant(Type *Ty, FPClassTest Mask) {
1790-
switch (Mask) {
1791-
case fcPosZero:
1792-
return ConstantFP::getZero(Ty);
1793-
case fcNegZero:
1794-
return ConstantFP::getZero(Ty, true);
1795-
case fcPosInf:
1796-
return ConstantFP::getInfinity(Ty);
1797-
case fcNegInf:
1798-
return ConstantFP::getInfinity(Ty, true);
1799-
case fcNone:
1800-
return PoisonValue::get(Ty);
1801-
default:
1802-
return nullptr;
1803-
}
1804-
}
1805-
1806-
Value *InstCombinerImpl::SimplifyDemandedUseFPClass(
1807-
Value *V, const FPClassTest DemandedMask, KnownFPClass &Known,
1808-
unsigned Depth, Instruction *CxtI) {
1809-
assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
1810-
Type *VTy = V->getType();
1811-
1812-
assert(Known == KnownFPClass() && "expected uninitialized state");
1813-
1814-
if (DemandedMask == fcNone)
1815-
return isa<UndefValue>(V) ? nullptr : PoisonValue::get(VTy);
1816-
1817-
if (Depth == MaxAnalysisRecursionDepth)
1818-
return nullptr;
1819-
1820-
Instruction *I = dyn_cast<Instruction>(V);
1821-
if (!I) {
1822-
// Handle constants and arguments
1823-
Known = computeKnownFPClass(V, fcAllFlags, CxtI, Depth + 1);
1824-
Value *FoldedToConst =
1825-
getFPClassConstant(VTy, DemandedMask & Known.KnownFPClasses);
1826-
return FoldedToConst == V ? nullptr : FoldedToConst;
1827-
}
1828-
1829-
if (!I->hasOneUse())
1830-
return nullptr;
1831-
1832-
// TODO: Should account for nofpclass/FastMathFlags on current instruction
1833-
switch (I->getOpcode()) {
1834-
case Instruction::FNeg: {
1835-
if (SimplifyDemandedFPClass(I, 0, llvm::fneg(DemandedMask), Known,
1836-
Depth + 1))
1837-
return I;
1838-
Known.fneg();
1839-
break;
1840-
}
1841-
case Instruction::Call: {
1842-
CallInst *CI = cast<CallInst>(I);
1843-
switch (CI->getIntrinsicID()) {
1844-
case Intrinsic::fabs:
1845-
if (SimplifyDemandedFPClass(I, 0, llvm::inverse_fabs(DemandedMask), Known,
1846-
Depth + 1))
1847-
return I;
1848-
Known.fabs();
1849-
break;
1850-
case Intrinsic::arithmetic_fence:
1851-
if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, Depth + 1))
1852-
return I;
1853-
break;
1854-
case Intrinsic::copysign: {
1855-
// Flip on more potentially demanded classes
1856-
const FPClassTest DemandedMaskAnySign = llvm::unknown_sign(DemandedMask);
1857-
if (SimplifyDemandedFPClass(I, 0, DemandedMaskAnySign, Known, Depth + 1))
1858-
return I;
1859-
1860-
if ((DemandedMask & fcPositive) == fcNone) {
1861-
// Roundabout way of replacing with fneg(fabs)
1862-
I->setOperand(1, ConstantFP::get(VTy, -1.0));
1863-
return I;
1864-
}
1865-
1866-
if ((DemandedMask & fcNegative) == fcNone) {
1867-
// Roundabout way of replacing with fabs
1868-
I->setOperand(1, ConstantFP::getZero(VTy));
1869-
return I;
1870-
}
1871-
1872-
KnownFPClass KnownSign =
1873-
computeKnownFPClass(I->getOperand(1), fcAllFlags, CxtI, Depth + 1);
1874-
Known.copysign(KnownSign);
1875-
break;
1876-
}
1877-
default:
1878-
Known = computeKnownFPClass(I, ~DemandedMask, CxtI, Depth + 1);
1879-
break;
1880-
}
1881-
1882-
break;
1883-
}
1884-
case Instruction::Select: {
1885-
KnownFPClass KnownLHS, KnownRHS;
1886-
if (SimplifyDemandedFPClass(I, 2, DemandedMask, KnownRHS, Depth + 1) ||
1887-
SimplifyDemandedFPClass(I, 1, DemandedMask, KnownLHS, Depth + 1))
1888-
return I;
1889-
1890-
if (KnownLHS.isKnownNever(DemandedMask))
1891-
return I->getOperand(2);
1892-
if (KnownRHS.isKnownNever(DemandedMask))
1893-
return I->getOperand(1);
1894-
1895-
// TODO: Recognize clamping patterns
1896-
Known = KnownLHS | KnownRHS;
1897-
break;
1898-
}
1899-
default:
1900-
Known = computeKnownFPClass(I, ~DemandedMask, CxtI, Depth + 1);
1901-
break;
1902-
}
1903-
1904-
return getFPClassConstant(VTy, DemandedMask & Known.KnownFPClasses);
1905-
}
1906-
1907-
bool InstCombinerImpl::SimplifyDemandedFPClass(Instruction *I, unsigned OpNo,
1908-
FPClassTest DemandedMask,
1909-
KnownFPClass &Known,
1910-
unsigned Depth) {
1911-
Use &U = I->getOperandUse(OpNo);
1912-
Value *NewVal =
1913-
SimplifyDemandedUseFPClass(U.get(), DemandedMask, Known, Depth, I);
1914-
if (!NewVal)
1915-
return false;
1916-
if (Instruction *OpInst = dyn_cast<Instruction>(U))
1917-
salvageDebugInfo(*OpInst);
1918-
1919-
replaceUse(U, NewVal);
1920-
return true;
1921-
}

‎llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

Lines changed: 2 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -2748,22 +2748,8 @@ Instruction *InstCombinerImpl::visitFree(CallInst &FI, Value *Op) {
27482748
}
27492749

27502750
Instruction *InstCombinerImpl::visitReturnInst(ReturnInst &RI) {
2751-
Value *RetVal = RI.getReturnValue();
2752-
if (!RetVal || !AttributeFuncs::isNoFPClassCompatibleType(RetVal->getType()))
2753-
return nullptr;
2754-
2755-
Function *F = RI.getFunction();
2756-
FPClassTest ReturnClass = F->getAttributes().getRetNoFPClass();
2757-
if (ReturnClass == fcNone)
2758-
return nullptr;
2759-
2760-
KnownFPClass KnownClass;
2761-
Value *Simplified =
2762-
SimplifyDemandedUseFPClass(RetVal, ~ReturnClass, KnownClass, 0, &RI);
2763-
if (!Simplified)
2764-
return nullptr;
2765-
2766-
return ReturnInst::Create(RI.getContext(), Simplified);
2751+
// Nothing for now.
2752+
return nullptr;
27672753
}
27682754

27692755
// WARNING: keep in sync with SimplifyCFGOpt::simplifyUnreachable()!

0 commit comments

Comments
 (0)