ValueLattice, LVI, SCCP: Use floating point constant ranges

[jvesely]

Summary

This is enough to make existing tests pass, some with improved behaviour.

[jvesely]

There were few issues in SCCP tests.

• apint-load -- the result of the division operation of the original operands depends on rounding mode. it's represented as a range rather than a constant.
• apint-ipsccp4 -- we can now deduce the starting range of v1 in ssa_copy intrinsic as [-Inf, 2.999] which then gets merged with more accurate information from the function call. The original behaviour started with unknown which then gets combined with more accurate information. Thus having less information at the beginning gives a better result. changing the comparison condition check to only allow Icmp works around the issue and keeps the old behaviour.
• float-nan-simplification -- NaNs with different payloads/sign are not tracked separately, so one case returns +NaN while the other one returns -NaN. I've adjusted the comment in the test to explain the situation.

let me know what other tests you'd like me to add.

[fhahn]

Very interesting! On a high-level, it would probably be good to split those changes into 3 (ValueLattice, LVI & SCCP); not sure how tricky that's going to be given adding automatic support in markConstant & co. If it's too tricky splitting LVI & SCCP would be great.

Also, the existing tests cover very little floating point stuff, at least for SCCP (and probably LVI too), It would be good to add FP versions of llvm/tests/Transforms/{ip-ranges-binaryops.ll, ip-ranges-casts.ll, ip-ranges-select.ll ip-constant-ranges.ll, conditions-ranges.ll, conditions-ranges-with-undef.ll} for example.

[jvesely]

In D78224#1984569, @fhahn wrote:

Very interesting! On a high-level, it would probably be good to split those changes into 3 (ValueLattice, LVI & SCCP); not sure how tricky that's going to be given adding automatic support in markConstant & co. If it's too tricky splitting LVI & SCCP would be great.

the original implementation for llvm-10 split the changes in 3 patches. I wasn't able to cleanly do this in llvm 11, since changing value lattice to represent floats as ranges breaks sccp's assumptions that range is only used for int types.
splitting it would still mean changes in the other places to avoid crashes, and include test regressions. I can take another try.

Also, the existing tests cover very little floating point stuff, at least for SCCP (and probably LVI too), It would be good to add FP versions of llvm/tests/Transforms/{ip-ranges-binaryops.ll, ip-ranges-casts.ll, ip-ranges-select.ll ip-constant-ranges.ll, conditions-ranges.ll, conditions-ranges-with-undef.ll} for example.

thanks. I'll add those and update.

[fhahn]

I think there are outstanding comments and/or a rebase is needed. Marking as changes requested to clear up review queue.

llvm/include/llvm/Analysis/ValueLattice.h

bool isConstantRangeIncludingUndef() const {
     return Tag == constantrange_including_undef;
   }
   /// Returns true if this value is a constant range. Use \p UndefAllowed to
   /// exclude non-singleton constant ranges that may also be undef. Note that
   /// this function also returns true if the range may include undef, but only
   /// contains a single element. In that case, it can be replaced by a constant.
   bool isConstantRange(bool UndefAllowed = true) const {
     return Tag == constantrange || (Tag == constantrange_including_undef &&
-                                    (UndefAllowed || Range.isSingleElement()));
+                                    (UndefAllowed || Range.isSingleElement() ||
+                                                     Range.isSingleElementFP()));
   }
   bool isOverdefined() const { return Tag == overdefined; }
 
   Constant *getConstant() const {
     assert(isConstant() && "Cannot get the constant of a non-constant!");
     return ConstVal;
   }
 
bool markConstant(Constant *V, bool MayIncludeUndef = false) {
 
     if (isConstant()) {
       assert(getConstant() == V && "Marking constant with different value");
       return false;
     }
 
     if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
       return markConstantRange(ConstantRange(CI->getValue()), MayIncludeUndef);
+    if (ConstantFP *CFP = dyn_cast<ConstantFP>(V))
+      return markConstantRange(ConstantRange(CFP->getValueAPF()), MayIncludeUndef);
 
     assert(isUnknown() || isUndef());
     Tag = constant;
     ConstVal = V;
     return true;
   }
 
   bool markNotConstant(Constant *V) {
     assert(V && "Marking constant with NULL");
     if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
       return markConstantRange(
           ConstantRange(CI->getValue() + 1, CI->getValue()));
+    if (ConstantFP *CFP = dyn_cast<ConstantFP>(V))
+      return markConstantRange(ConstantRange(CFP->getValueAPF()).inverse());
 
     if (isa<UndefValue>(V))
       return false;
 
     if (isNotConstant()) {
       assert(getNotConstant() == V && "Marking !constant with different value");
       return false;
     }
Constant *getCompare(CmpInst::Predicate Pred, Type *Ty,
 
     // Integer constants are represented as ConstantRanges with single
     // elements.
     if (!isConstantRange() || !Other.isConstantRange())
       return nullptr;
 
     const auto &CR = getConstantRange();
     const auto &OtherCR = Other.getConstantRange();
+    if (CR.getIsFloat()) {
+      assert(OtherCR.getIsFloat());
+      if (ConstantRange::makeSatisfyingFCmpRegion(Pred, OtherCR).contains(CR))
+        return ConstantInt::getTrue(Ty);
+      if (ConstantRange::makeSatisfyingFCmpRegion(
+              CmpInst::getInversePredicate(Pred), OtherCR)
+              .contains(CR))
+        return ConstantInt::getFalse(Ty);
+    } else {
+      assert(!OtherCR.getIsFloat());
       if (ConstantRange::makeSatisfyingICmpRegion(Pred, OtherCR).contains(CR))
         return ConstantInt::getTrue(Ty);
       if (ConstantRange::makeSatisfyingICmpRegion(
               CmpInst::getInversePredicate(Pred), OtherCR)
               .contains(CR))
         return ConstantInt::getFalse(Ty);
+    }
 
     return nullptr;
   }
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeElement &Val);
 
 } // end namespace llvm
 #endif

llvm/lib/Analysis/LazyValueInfo.cpp

 
 AnalysisKey LazyValueAnalysis::Key;
 
 /// Returns true if this lattice value represents at most one possible value.
 /// This is as precise as any lattice value can get while still representing
 /// reachable code.
 static bool hasSingleValue(const ValueLatticeElement &Val) {
   if (Val.isConstantRange() &&
-      Val.getConstantRange().isSingleElement())
-    // Integer constants are single element ranges
+      (Val.getConstantRange().isSingleElement() ||
+       Val.getConstantRange().isSingleElementFP()))
+    // Integer and FP constants are single element ranges
     return true;
   if (Val.isConstant())
     // Non integer constants
     return true;
   return false;
 }
 
 /// Combine two sets of facts about the same value into a single set of
bool LazyValueInfoImpl::solveBlockValueImpl(ValueLatticeElement &Res,
   // This does mean that we have a sensitivity to where the defining
   // instruction is placed, even if it could legally be hoisted much higher.
   // That is unfortunate.
   PointerType *PT = dyn_cast<PointerType>(BBI->getType());
   if (PT && isKnownNonZero(BBI, DL)) {
     Res = ValueLatticeElement::getNot(ConstantPointerNull::get(PT));
     return true;
   }
+  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(BBI))
+    return solveBlockValueBinaryOp(Res, BO, BB);
+
   if (BBI->getType()->isIntegerTy()) {
     if (auto *CI = dyn_cast<CastInst>(BBI))
       return solveBlockValueCast(Res, CI, BB);
 
-    if (BinaryOperator *BO = dyn_cast<BinaryOperator>(BBI))
-      return solveBlockValueBinaryOp(Res, BO, BB);
-
     if (auto *EVI = dyn_cast<ExtractValueInst>(BBI))
       return solveBlockValueExtractValue(Res, EVI, BB);
 
     if (auto *II = dyn_cast<IntrinsicInst>(BBI))
       return solveBlockValueIntrinsic(Res, II, BB);
   }
 
   LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
ValueLatticeElement Result =
       getImpl(PImpl, AC, &DL, DT).getValueInBlock(V, BB, CxtI);
 
   if (Result.isConstant())
     return Result.getConstant();
   if (Result.isConstantRange()) {
     const ConstantRange &CR = Result.getConstantRange();
     if (const APInt *SingleVal = CR.getSingleElement())
       return ConstantInt::get(V->getContext(), *SingleVal);
+    if (const APFloat *SingleVal = CR.getSingleElementFP())
+      return ConstantFP::get(V->getContext(), *SingleVal);
   }
   return nullptr;
 }
 
 ConstantRange LazyValueInfo::getConstantRange(Value *V, BasicBlock *BB,
                                               Instruction *CxtI,
                                               bool UndefAllowed) {
   assert(V->getType()->isIntegerTy());
ValueLatticeElement Result =
       getImpl(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
 
   if (Result.isConstant())
     return Result.getConstant();
   if (Result.isConstantRange()) {
     const ConstantRange &CR = Result.getConstantRange();
     if (const APInt *SingleVal = CR.getSingleElement())
       return ConstantInt::get(V->getContext(), *SingleVal);
+    if (const APFloat *SingleVal = CR.getSingleElementFP())
+      return ConstantFP::get(V->getContext(), *SingleVal);
   }
   return nullptr;
 }
 
 ConstantRange LazyValueInfo::getConstantRangeOnEdge(Value *V,
                                                     BasicBlock *FromBB,
                                                     BasicBlock *ToBB,
                                                     Instruction *CxtI) {
   unsigned Width = V->getType()->getIntegerBitWidth();
   const DataLayout &DL = FromBB->getModule()->getDataLayout();
   ValueLatticeElement Result =
       getImpl(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
 
   if (Result.isUnknown())
     return ConstantRange::getEmpty(Width);
   if (Result.isConstantRange())
     return Result.getConstantRange();
   // We represent ConstantInt constants as constant ranges but other kinds
   // of integer constants, i.e. ConstantExpr will be tagged as constants
-  assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&
-         "ConstantInt value must be represented as constantrange");
+  assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant()) &&
+           isa<ConstantFP>(Result.getConstant())  ) &&
+         "ConstantInt and ConstantFP values must be represented as constantrange");
   return ConstantRange::getFull(Width);
 }
 
 static LazyValueInfo::Tristate
 getPredicateResult(unsigned Pred, Constant *C, const ValueLatticeElement &Val,
                    const DataLayout &DL, TargetLibraryInfo *TLI) {
   // If we know the value is a constant, evaluate the conditional.
   Constant *Res = nullptr;
   if (Val.isConstant()) {
     Res = ConstantFoldCompareInstOperands(Pred, Val.getConstant(), C, DL, TLI);
     if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
       return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
     return LazyValueInfo::Unknown;
   }
 
   if (Val.isConstantRange()) {
     ConstantInt *CI = dyn_cast<ConstantInt>(C);
-    if (!CI) return LazyValueInfo::Unknown;
+    ConstantFP *CFP = dyn_cast<ConstantFP>(C);
+    if (!CI && !CFP) return LazyValueInfo::Unknown;
 
     const ConstantRange &CR = Val.getConstantRange();
     if (Pred == ICmpInst::ICMP_EQ) {
       if (!CR.contains(CI->getValue()))
         return LazyValueInfo::False;
 
       if (CR.isSingleElement())
         return LazyValueInfo::True;
     } else if (Pred == ICmpInst::ICMP_NE) {
       if (!CR.contains(CI->getValue()))
         return LazyValueInfo::True;
 
       if (CR.isSingleElement())
         return LazyValueInfo::False;
     } else {
       // Handle more complex predicates.
+      if (CI) {
         ConstantRange TrueValues = ConstantRange::makeExactICmpRegion(
             (ICmpInst::Predicate)Pred, CI->getValue());
         if (TrueValues.contains(CR))
           return LazyValueInfo::True;
         if (TrueValues.inverse().contains(CR))
           return LazyValueInfo::False;
       }
+      // Handle floating point prdicates
+      if (CFP) {
+  ConstantRange TrueValues = ConstantRange::makeExactFCmpRegion(
+            (FCmpInst::Predicate)Pred, CFP->getValueAPF());
+  if (TrueValues.contains(CR))
+    return LazyValueInfo::True;
+  ConstantRange FalseValues = ConstantRange::makeExactFCmpRegion(
+            FCmpInst::getInversePredicate((FCmpInst::Predicate)Pred),
+            CFP->getValueAPF());
+  if (FalseValues.contains(CR))
+    return LazyValueInfo::False;
+      }
+    }
     return LazyValueInfo::Unknown;
   }
 
   if (Val.isNotConstant()) {
     // If this is an equality comparison, we can try to fold it knowing that
     // "V != C1".
     if (Pred == ICmpInst::ICMP_EQ) {
       // !C1 == C -> false iff C1 == C.

llvm/lib/Analysis/ValueLattice.cpp

raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeElement &Val) {
   if (Val.isUndef())
     return OS << "undef";
   if (Val.isOverdefined())
     return OS << "overdefined";
 
   if (Val.isNotConstant())
     return OS << "notconstant<" << *Val.getNotConstant() << ">";
 
-  if (Val.isConstantRangeIncludingUndef())
-    return OS << "constantrange incl. undef <"
-              << Val.getConstantRange(true).getLower() << ", "
-              << Val.getConstantRange(true).getUpper() << ">";
-
-  if (Val.isConstantRange())
-    return OS << "constantrange<" << Val.getConstantRange().getLower() << ", "
-              << Val.getConstantRange().getUpper() << ">";
+  if (Val.isConstantRangeIncludingUndef()) {
+    const ConstantRange &CR = Val.getConstantRange(true);
+    if (CR.getIsFloat()) {
+      return OS << "constantrange-fp incl. undef <" << CR << ">";
+    } else {
+      return OS << "constantrange incl. undef <" << CR.getLower() << ", "
+                                                 << CR.getUpper() << ">";
+    }
+  }
+
+  if (Val.isConstantRange()) {
+    const ConstantRange &CR = Val.getConstantRange(true);
+    if (CR.getIsFloat()) {
+      return OS << "constantrange-fp<" << CR << ">";
+    } else {
+      return OS << "constantrange<" << CR.getLower() << ", "
+                                    << CR.getUpper() << ">";
+    }
+  }
+
   return OS << "constant<" << *Val.getConstant() << ">";
 }
 } // end namespace llvm

llvm/lib/IR/ConstantRange.cpp

ConstantRange ConstantRange::fromKnownBits(const KnownBits &Known,
   APInt Lower = Known.getMinValue(), Upper = Known.getMaxValue();
   Lower.setSignBit();
   Upper.clearSignBit();
   return ConstantRange(Lower, Upper + 1);
 }
 
 ConstantRange ConstantRange::makeAllowedFCmpRegion(CmpInst::Predicate Pred,
                                                    const ConstantRange &CR) {
+//  dbgs() << "Make allowed FCmp region '" << CmpInst::getPredicateName(Pred) << "' " << CR << "\n";
   assert(CR.isFloat);
   if (CR.isEmptySet())
     return CR;
 
   // Nothing is ordered wrt NaN
   if (CR.LowerFP.isNaN() && CmpInst::isOrdered(Pred))
     return CR.getEmpty();
   // Everything is unordered wrt NaN
case Instruction::AShr:
     return ashr(Other);
   case Instruction::And:
     return binaryAnd(Other);
   case Instruction::Or:
     return binaryOr(Other);
   case Instruction::Xor:
     return binaryXor(Other);
   case Instruction::FAdd:
-    if (isFloat) // We don't support vector types
-      return fadd(Other);
+    if (isFloat) { // We don't support vector types
+      auto ret = fadd(Other);
+//      dbgs() << "FADD: " << *this << " + " << Other << " = " << ret << "\n";
+      return ret;
+    }
     // Fallthrough
   case Instruction::FSub:
     if (isFloat) // We don't support vector types
       return fsub(Other);
     // Fallthrough
   case Instruction::FMul:
     if (isFloat) // We don't support vector types
       return fmultiply(Other);

llvm/lib/Transforms/Scalar/SCCP.cpp

 namespace {
 
 // Helper to check if \p LV is either a constant or a constant
 // range with a single element. This should cover exactly the same cases as the
 // old ValueLatticeElement::isConstant() and is intended to be used in the
 // transition to ValueLatticeElement.
 bool isConstant(const ValueLatticeElement &LV) {
   return LV.isConstant() ||
-         (LV.isConstantRange() && LV.getConstantRange().isSingleElement());
+         (LV.isConstantRange() &&
+          (LV.getConstantRange().isSingleElement() ||
+           LV.getConstantRange().isSingleElementFP()));
 }
 
 // Helper to check if \p LV is either overdefined or a constant range with more
 // than a single element. This should cover exactly the same cases as the old
 // ValueLatticeElement::isOverdefined() and is intended to be used in the
 // transition to ValueLatticeElement.
 bool isOverdefined(const ValueLatticeElement &LV) {
   return LV.isOverdefined() ||
-         (LV.isConstantRange() && !LV.getConstantRange().isSingleElement());
+         (LV.isConstantRange() && !LV.getConstantRange().isSingleElement() &&
+          !LV.getConstantRange().isSingleElementFP());
 }
 
 //===----------------------------------------------------------------------===//
 //
 /// SCCPSolver - This class is a general purpose solver for Sparse Conditional
 /// Constant Propagation.
 ///
 class SCCPSolver : public InstVisitor<SCCPSolver> {
public:
   Constant *getConstant(const ValueLatticeElement &LV) const {
     if (LV.isConstant())
       return LV.getConstant();
 
     if (LV.isConstantRange()) {
       auto &CR = LV.getConstantRange();
       if (CR.getSingleElement())
         return ConstantInt::get(Ctx, *CR.getSingleElement());
+      if (CR.getSingleElementFP())
+        return ConstantFP::get(Ctx, *CR.getSingleElementFP());
     }
     return nullptr;
   }
 
 private:
   ConstantInt *getConstantInt(const ValueLatticeElement &IV) const {
     return dyn_cast_or_null<ConstantInt>(getConstant(IV));
   }
if (Constant *OpC = getConstant(OpSt)) {
     markConstant(&I, C);
   } else if (OpSt.isConstantRange() && I.getDestTy()->isIntegerTy()) {
     auto &LV = getValueState(&I);
     ConstantRange OpRange = OpSt.getConstantRange();
     Type *DestTy = I.getDestTy();
     ConstantRange Res =
         OpRange.castOp(I.getOpcode(), DL.getTypeSizeInBits(DestTy));
     mergeInValue(LV, &I, ValueLatticeElement::getRange(Res));
+  } else if (OpSt.isConstantRange() && I.getDestTy()->isFloatingPointTy()) {
+    auto &LV = getValueState(&I);
+    ConstantRange OpRange = OpSt.getConstantRange();
+    Type *DestTy = I.getDestTy();
+    ConstantRange Res =
+        OpRange.castOp(I.getOpcode(), DestTy->getFltSemantics());
+    mergeInValue(LV, &I, ValueLatticeElement::getRange(Res));
   } else if (!OpSt.isUnknownOrUndef())
     markOverdefined(&I);
 }
 
 void SCCPSolver::visitExtractValueInst(ExtractValueInst &EVI) {
   // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
   // discover a concrete value later.
   if (isOverdefined(ValueState[&EVI]))
if (C) {
       // after one of the operands go to overdefined, e.g. due to one operand
       // being a special floating value.
       ValueLatticeElement NewV;
       NewV.markConstant(C, /*MayIncludeUndef=*/true);
       return (void)mergeInValue(&I, NewV);
     }
   }
 
-  // Only use ranges for binary operators on integers.
-  if (!I.getType()->isIntegerTy())
+  auto IType = I.getType();
+  // Only use ranges for binary operators on integers and floating point
+  if (!IType->isIntegerTy() && !IType->isFloatingPointTy())
     return markOverdefined(&I);
 
   // Try to simplify to a constant range.
-  ConstantRange A = ConstantRange::getFull(I.getType()->getScalarSizeInBits());
-  ConstantRange B = ConstantRange::getFull(I.getType()->getScalarSizeInBits());
+  ConstantRange A = IType->isFloatingPointTy() ?
+      ConstantRange::getFull(IType->getFltSemantics()):
+      ConstantRange::getFull(IType->getScalarSizeInBits());
+  ConstantRange B = A;
   if (V1State.isConstantRange())
     A = V1State.getConstantRange();
   if (V2State.isConstantRange())
     B = V2State.getConstantRange();
 
   ConstantRange R = A.binaryOp(cast<BinaryOperator>(&I)->getOpcode(), B);
   mergeInValue(&I, ValueLatticeElement::getRange(R));
 
if (II->getIntrinsicID() == Intrinsic::ssa_copy) {
       auto *PI = getPredicateInfoFor(I);
       auto *PBranch = dyn_cast_or_null<PredicateBranch>(PI);
       if (!PI || !PBranch) {
         mergeInValue(ValueState[I], I, getValueState(CopyOf));
         return;
       }
 
       // Everything below relies on the condition being a comparison.
-      auto *Cmp = dyn_cast<CmpInst>(PBranch->Condition);
+      // FIXME: This is restricted to integer comparisons.
+      //        FP comaprisons introduce a rather large range first,
+      //        ehich then doesn't get reduced.
+      auto *Cmp = dyn_cast<ICmpInst>(PBranch->Condition);
       if (!Cmp) {
         mergeInValue(ValueState[I], I, getValueState(CopyOf));
         return;
       }
 
       Value *CmpOp0 = Cmp->getOperand(0);
       Value *CmpOp1 = Cmp->getOperand(1);
       if (CopyOf != CmpOp0 && CopyOf != CmpOp1) {
if (II->getIntrinsicID() == Intrinsic::ssa_copy) {
 
       if (!PBranch->TrueEdge)
         Pred = CmpInst::getInversePredicate(Pred);
 
       ValueLatticeElement CondVal = getValueState(CmpOp1);
       ValueLatticeElement &IV = ValueState[I];
       ValueLatticeElement OriginalVal = getValueState(CopyOf);
       if (CondVal.isConstantRange() || OriginalVal.isConstantRange()) {
-        auto NewCR =
-            ConstantRange::getFull(DL.getTypeSizeInBits(CopyOf->getType()));
+        auto CoType = CopyOf->getType();
+        auto NewCR = CoType->isFloatingPointTy() ?
+            ConstantRange::getFull(CoType->getFltSemantics()):
+            ConstantRange::getFull(DL.getTypeSizeInBits(CoType));
+
+        auto OriginalCR = OriginalVal.isConstantRange()
+                              ? OriginalVal.getConstantRange() : NewCR;
 
         // Get the range imposed by the condition.
-        if (CondVal.isConstantRange())
-          NewCR = ConstantRange::makeAllowedICmpRegion(
-              Pred, CondVal.getConstantRange());
+        if (CondVal.isConstantRange()) {
+           ConstantRange CR = CondVal.getConstantRange();
+           NewCR = CR.getIsFloat() ?
+              ConstantRange::makeAllowedFCmpRegion(Pred, CR):
+              ConstantRange::makeAllowedICmpRegion(Pred, CR);
+  }
 
         // Combine range info for the original value with the new range from the
         // condition.
-        auto OriginalCR = OriginalVal.isConstantRange()
-                              ? OriginalVal.getConstantRange()
-                              : ConstantRange::getFull(
-                                    DL.getTypeSizeInBits(CopyOf->getType()));
         NewCR = NewCR.intersectWith(OriginalCR);
 
         addAdditionalUser(CmpOp1, I);
         // TODO: Actually filp MayIncludeUndef for the created range to false,
         // once most places in the optimizer respect the branches on
         // undef/poison are UB rule. The reason why the new range cannot be
         // undef is as follows below:
         // The new range is based on a branch condition. That guarantees that

llvm/test/Transforms/CorrelatedValuePropagation/select.ll

 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:    [[PVAL:%.*]] = load i32, i32* [[P:%.*]]
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i32 [[PVAL]], 255
 ; CHECK-NEXT:    br i1 [[CMP1]], label [[NEXT:%.*]], label [[EXIT:%.*]]
 ; CHECK:       next:
 ; CHECK-NEXT:    [[MIN:%.*]] = select i1 [[UNKNOWN:%.*]], double 1.000000e+00, double 0.000000e+00
 ; CHECK-NEXT:    br label [[NEXT2:%.*]]
 ; CHECK:       next2:
-; CHECK-NEXT:    [[RES:%.*]] = fcmp oeq double [[MIN]], 3.000000e+02
+; CHECK-NEXT:    [[RES:%.*]] = fcmp oeq double [[MIN]], 5.000000e-01
 ; CHECK-NEXT:    ret i1 [[RES]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 true
 ;
   %pval = load i32, i32* %p
   %cmp1 = icmp slt i32 %pval, 255
   br i1 %cmp1, label %next, label %exit
 
 next:
   %min = select i1 %unknown, double 1.0, double 0.0
   ;; TODO: This pointless branch shouldn't be neccessary
   br label %next2
 next2:
-  %res = fcmp oeq double %min, 300.0
+  %res = fcmp oeq double %min, 0.5
   ret i1 %res
 
 exit:
   ret i1 true
 }
 
 ;; Using the condition to clamp the result
 ;;

llvm/test/Transforms/SCCP/apint-load.ll

 ; This test makes sure that these instructions are properly constant propagated.
 
 ; RUN: opt < %s -ipsccp -S | not grep load
 ; RUN: opt < %s -ipsccp -S | not grep fdiv
 
 @X = constant i212 42
-@Y = constant [2 x { i212, float }] [ { i212, float } { i212 12, float 1.0 }, 
+@Y = constant [2 x { i212, float }] [ { i212, float } { i212 16, float 1.0 },
                                      { i212, float } { i212 37, float 0x3FF3B2FEC0000000 } ]
 define i212 @test1() {
   %B = load i212, i212* @X
   ret i212 %B
 }
 
 define internal float @test2() {
   %A = getelementptr [2 x { i212, float}], [2 x { i212, float}]* @Y, i32 0, i32 1, i32 1
   %B = load float, float* %A
   ret float %B
 }
 
 define internal i212 @test3() {
   %A = getelementptr [2 x { i212, float}], [2 x { i212, float}]* @Y, i32 0, i32 0, i32 0
   %B = load i212, i212* %A
   ret i212 %B
 }
 
 define float @All()
 {
    %A = call float @test2()
    %B = call i212 @test3()
-   %C = mul i212 %B, -1234567
+   %C = mul i212 %B, -16
    %D = sitofp i212 %C to float
    %E = fdiv float %A, %D
    ret float %E
 }
 
 

llvm/test/Transforms/SCCP/float-nan-simplification.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -sccp -S %s | FileCheck %s
 
 ; When marking the edge from bb2 -> exit as executable first, %p will be NaN
-; first and %v.1 will simplify to NaN. But when marking bb1 -> exit executable,
-; %p will we overdefined and %v.1 will be simplified to 0.0. Make sure we go to
-; overdefined, instead of crashing.
-; TODO: Can we do better, i.e. choose the 'conservative' 0.0 initially?
+; first and %v.1 will simplify to NaN. Note that this will be a positive NaN.
+; Operations with two NaNs return the first one, so the returned value is
+; positive NaN. But when marking bb1 -> exit executable, %p will we
+; overdefined (full set) and %v.1 will be simplified to 0.0 or NaN.
+; This will be combined with neg NaN, which is the returend.
+; TODO: Can we do better, i.e. track pos and neg NaN separately?
 define float @test1(float %a, i1 %bc) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[BC:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[P:%.*]] = phi float [ [[A:%.*]], [[BB1]] ], [ 0x7FF8000000000000, [[BB2]] ]
 ; CHECK-NEXT:    [[V_1:%.*]] = fmul float [[P]], 0.000000e+00
-; CHECK-NEXT:    [[V_2:%.*]] = fadd float [[V_1]], 0xFFF8000000000000
-; CHECK-NEXT:    ret float [[V_2]]
+; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
 entry:
   br i1 %bc, label %bb1, label %bb2
 
 bb1:
   br label %exit
 
 bb2:

llvm/unittests/Analysis/ValueLatticeTest.cpp

protected:
   LLVMContext Context;
 };
 
 TEST_F(ValueLatticeTest, ValueLatticeGetters) {
   auto I32Ty = IntegerType::get(Context, 32);
   auto *C1 = ConstantInt::get(I32Ty, 1);
 
   EXPECT_TRUE(ValueLatticeElement::get(C1).isConstantRange());
+  EXPECT_TRUE(ValueLatticeElement::getNot(C1).isConstantRange());
   EXPECT_TRUE(
       ValueLatticeElement::getRange({C1->getValue()}).isConstantRange());
   EXPECT_TRUE(ValueLatticeElement::getOverdefined().isOverdefined());
 
   auto FloatTy = Type::getFloatTy(Context);
-  auto *C2 = ConstantFP::get(FloatTy, 1.1);
-  EXPECT_TRUE(ValueLatticeElement::get(C2).isConstant());
-  EXPECT_TRUE(ValueLatticeElement::getNot(C2).isNotConstant());
+  auto *C2 = dyn_cast<ConstantFP>(ConstantFP::get(FloatTy, 1.1));
+  EXPECT_TRUE(ValueLatticeElement::get(C2).isConstantRange());
+  EXPECT_TRUE(ValueLatticeElement::getNot(C2).isConstantRange());
+  EXPECT_TRUE(
+      ValueLatticeElement::getRange({C2->getValueAPF()}).isConstantRange());
 }
 
 TEST_F(ValueLatticeTest, MarkConstantRange) {
   auto LV1 =
       ValueLatticeElement::getRange({APInt(32, 10, true), APInt(32, 20, true)});
 
   // Test markConstantRange() with an equal range.
   EXPECT_FALSE(
TEST_F(ValueLatticeTest, getCompareFloat) {
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV2)->isOneValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV2)->isZeroValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2)->isZeroValue());
   EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV2)->isZeroValue());
 
   EXPECT_TRUE(
       LV1.mergeIn(ValueLatticeElement::get(ConstantFP::get(FloatTy, 2.2))));
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OEQ, I1Ty, LV2), nullptr);
-  EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV2), nullptr);
+  // [1.0, 2.2] is always >= 1.0
+  EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OGE, I1Ty, LV2)->isOneValue());
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OLE, I1Ty, LV2), nullptr);
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_ONE, I1Ty, LV2), nullptr);
-  EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2), nullptr);
+  // [1.0, 2.2] is never < 1.0
+  EXPECT_TRUE(LV1.getCompare(CmpInst::FCMP_OLT, I1Ty, LV2)->isZeroValue());
   EXPECT_EQ(LV1.getCompare(CmpInst::FCMP_OGT, I1Ty, LV2), nullptr);
 }
 
 TEST_F(ValueLatticeTest, getCompareUndef) {
   auto *I32Ty = IntegerType::get(Context, 32);
   auto *I1Ty = IntegerType::get(Context, 1);
 
   auto LV1 = ValueLatticeElement::get(UndefValue::get(I32Ty));