IR/ConstantRange: Add support for FP ranges

[jvesely]

Summary

The FP Range follows the same pattern as integer range, with two major differences.

1. It's inclusive
2. NaNs are tracked separately from the range.

This patch implements; construction, printing, fadd, fsub, fmul, fdiv, minimum, maximum, cast, makeAllowedRegion, makeSatisfyingRegion.
Rounding of operations is conservative and returns a potentially larger region.

Floating point vectors are still tracked as integer ranges.

Includes exhaustive testing for all supported operations.

[nikic]

I would strongly recommend to implement this as a separate type (FloatRange for example), rather than combining it into ConstantRange. There's a couple reasons for that, the main ones would be a) float ranges have significantly different semantics, in particular the fact that they are inclusive and b) ConstantRange is a size critical structure, because it is used in value lattice elements. As implement, this change is going to skyrocket memory consumption during SCCP.

It would also be nice to have some general context on where you plan to use this.

[jvesely]

In D78220#1984311, @nikic wrote:

I would strongly recommend to implement this as a separate type (FloatRange for example), rather than combining it into ConstantRange. There's a couple reasons for that, the main ones would be a) float ranges have significantly different semantics, in particular the fact that they are inclusive and b) ConstantRange is a size critical structure, because it is used in value lattice elements. As implement, this change is going to skyrocket memory consumption during SCCP.

The point of having one combined range is to allow simplification of logic for users. you don't have to check for the type just do the same operations union/intersect/binop/contains/...
I'm not sure how splitting it to a separate class would address the memory concerns. Tracking fp ranges will require two APFloats irrespective of the structure.
If keeping both APFloat and APint bounds is a problem I can put them in a union since they are used exclusively and an instance never switches between float and int.
The difference in semantics shouldn't impact users much. they should use contains/isEmpty/isFull/isSingleElement/getABCrange instead of checking the bounds manually.
The application to valluelattice/lvi/sccp is in D78224, to keep diff simple it hasn't implemented cleanups that are allowed by having one range class, yet.

It would also be nice to have some general context on where you plan to use this.

Other than the usual uses of range propagation, floating point ranges can be used to safely apply fast-math optimizations if operands are known to not require special handling
There's already rudimentary support for NaN tracking, using ranges allows to safely apply nosignedzeros, noinfs, nonans, denorms are zero optimizations.

moreover, gpu backends can generate special instructions if there's advanced knowledge of fp operands.
for example ptx backend can use different fdiv implementation based on the range of inputs [0]. amdgpu can eliminate canonicalize instructions if it knows the range of inputs[1].

[0] https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-div
[1] https://reviews.llvm.org/D35335

[fhahn]

In D78220#1985031, @jvesely wrote:

In D78220#1984311, @nikic wrote:

I would strongly recommend to implement this as a separate type (FloatRange for example), rather than combining it into ConstantRange. There's a couple reasons for that, the main ones would be a) float ranges have significantly different semantics, in particular the fact that they are inclusive and b) ConstantRange is a size critical structure, because it is used in value lattice elements. As implement, this change is going to skyrocket memory consumption during SCCP.

+1, I think there is a strong case for not increasing the size here. We should rather try to reduce the size of the existing ConstantRange (using the 2 APInts means we store the same bit width twice :()

The point of having one combined range is to allow simplification of logic for users. you don't have to check for the type just do the same operations union/intersect/binop/contains/...
I'm not sure how splitting it to a separate class would address the memory concerns. Tracking fp ranges will require two APFloats irrespective of the structure.
If keeping both APFloat and APint bounds is a problem I can put them in a union since they are used exclusively and an instance never switches between float and int.

Even with a union, you still need extra space for the bits to distinguish between FP/integers (and other FP related flags, like canBeNaN. It should be possible to achieve the same level of convenience to this patch, but separating integer and FP ranges into separate classes. E.g. add ConstantRangeIntStorage & ConstantRangeFloatStorage which use APInt/APFloat respectively. The shared logic can be implemented in a ConstantRangeCommon template, which can be instantiated with either ConstantRangeIntStorage/ConstantRangeFPStorage. ConstantRange would turn into an instantiation of ConstantRangeCommon<ConstantRangeIntStorage>. Of course that would require updating code to make use of the FP version of ConstantRange. That might be a benefit actually, because there probably are various places that assume ConstantRange only contains integers.

When using the FP version of the constant range in ValueLattice, that would allow us to keep the size the same, if no extra bits (like canBeNaN) are added.

It might be that there is no impact on compile-time/memory usage overall with the current version (using a union), but it would be good to collect data.

It would also be nice to have some general context on where you plan to use this.

Other than the usual uses of range propagation, floating point ranges can be used to safely apply fast-math optimizations if operands are known to not require special handling
There's already rudimentary support for NaN tracking, using ranges allows to safely apply nosignedzeros, noinfs, nonans, denorms are zero optimizations.

FWIW I think it might be good to bring up the NaN tracking & co in separate patches.

[jvesely]

In D78220#1986237, @fhahn wrote:

In D78220#1985031, @jvesely wrote:

In D78220#1984311, @nikic wrote:

I would strongly recommend to implement this as a separate type (FloatRange for example), rather than combining it into ConstantRange. There's a couple reasons for that, the main ones would be a) float ranges have significantly different semantics, in particular the fact that they are inclusive and b) ConstantRange is a size critical structure, because it is used in value lattice elements. As implement, this change is going to skyrocket memory consumption during SCCP.

+1, I think there is a strong case for not increasing the size here. We should rather try to reduce the size of the existing ConstantRange (using the 2 APInts means we store the same bit width twice :()

The point of having one combined range is to allow simplification of logic for users. you don't have to check for the type just do the same operations union/intersect/binop/contains/...
I'm not sure how splitting it to a separate class would address the memory concerns. Tracking fp ranges will require two APFloats irrespective of the structure.
If keeping both APFloat and APint bounds is a problem I can put them in a union since they are used exclusively and an instance never switches between float and int.

Even with a union, you still need extra space for the bits to distinguish between FP/integers (and other FP related flags, like canBeNaN. It should be possible to achieve the same level of convenience to this patch, but separating integer and FP ranges into separate classes. E.g. add ConstantRangeIntStorage & ConstantRangeFloatStorage which use APInt/APFloat respectively. The shared logic can be implemented in a ConstantRangeCommon template, which can be instantiated with either ConstantRangeIntStorage/ConstantRangeFPStorage. ConstantRange would turn into an instantiation of ConstantRangeCommon<ConstantRangeIntStorage>. Of course that would require updating code to make use of the FP version of ConstantRange. That might be a benefit actually, because there probably are various places that assume ConstantRange only contains integers.

When using the FP version of the constant range in ValueLattice, that would allow us to keep the size the same, if no extra bits (like canBeNaN) are added.

OK, I'll take a stab at separating the backend, but I don't see a good way to reduce memory usage.

the current situation:
sizeof(APInt) == 16 and there are two of them so sizeof(ConstantRange) == 32, ValueLattice includes ConstantRange as member + extra tags givining it the size of 33 (aligned to 40).

possible implementations of fp tracking:
a) using unions for Lower/LowerFP, Upper/UpperFP:
sizeof(APFloat) == 32 x2 + 2 for tags => sizeof(ConstantRange) == 66 (aligned up to 72). ValueLattice includes ConstantRange as member bringing the size to 73 (aligned to 80).

b) union backend:
sizeof (ConstantRangeBackendInt) == 32, sizeof(ConstantRangeBackendFP) == 65 (2x APFloat + bool NaN, aligned up to 72), sizeof ConstantRange == 72). ValueLattice includes ConstantRange as member bring s the size to 73 (aligned to 80)

c) separate classes for int and float ranges:
sizeof(ConstantRangeInt) == 32, sizeof(ConstantRangeFP) == 65 (aligns up to 72). ValueLattice includes both variants in a union bringing the size to 73 (aligned to 80).

The memory overhead is 2x, which is consistent with tracking more information.
As long as we have one flag, adding another another is free because of the alignment. (I used 8B alignment, but 4B align is not going to change the sizes much).

Unless we use pointers and an extra level of indirection the end sizes for users like ValueLattice end up the same irrespective of where the union is (lower+upper vs. backend vs. user).

If memory usage is a concern, dropping ConstantRange from ValueLattice structure (so it's not taking up space for unknown/overdefined tags) might be a better target.

It might be that there is no impact on compile-time/memory usage overall with the current version (using a union), but it would be good to collect data.

Is there a test suite that I can use to collect this? Are there any integer heavy/only use cases that would only suffer overhead without any benefit to fp range tracking?

It would also be nice to have some general context on where you plan to use this.

Other than the usual uses of range propagation, floating point ranges can be used to safely apply fast-math optimizations if operands are known to not require special handling
There's already rudimentary support for NaN tracking, using ranges allows to safely apply nosignedzeros, noinfs, nonans, denorms are zero optimizations.

FWIW I think it might be good to bring up the NaN tracking & co in separate patches.

NaNs can be created as a result of normal operations (like Inf - Inf, or 0/0) so detecting NaN producing operations is required to track regular ranges. storing it in a flag is a minimal change.

[nikic]

In D78220#1987284, @jvesely wrote:

Unless we use pointers and an extra level of indirection the end sizes for users like ValueLattice end up the same irrespective of where the union is (lower+upper vs. backend vs. user).

I'd expect that this is indeed what we want to do. Given that the float range is just so much larger, we'll want to allocate it out of line.

If memory usage is a concern, dropping ConstantRange from ValueLattice structure (so it's not taking up space for unknown/overdefined tags) might be a better target.

That's also a possibility (LVI for example uses a separate set for overdefined values to reduce memory usage), but fairly orthogonal. Even if ConstantRange is allocated out of line as well, we'll still want to be able to allocate the smaller integer only structure.

In any case, it's really not just a matter of memory usage, but also semantics. Integer and float constant ranges cannot interact in any meaningful way, you can't take the union of an integer and float range for example. Your patch already asserts that range types match in many places. It is better if these invariants get enforced more robustly by the type system.

In D78220#1986237, @fhahn wrote:

Even with a union, you still need extra space for the bits to distinguish between FP/integers (and other FP related flags, like canBeNaN. It should be possible to achieve the same level of convenience to this patch, but separating integer and FP ranges into separate classes. E.g. add ConstantRangeIntStorage & ConstantRangeFloatStorage which use APInt/APFloat respectively. The shared logic can be implemented in a ConstantRangeCommon template, which can be instantiated with either ConstantRangeIntStorage/ConstantRangeFPStorage. ConstantRange would turn into an instantiation of ConstantRangeCommon<ConstantRangeIntStorage>. Of course that would require updating code to make use of the FP version of ConstantRange. That might be a benefit actually, because there probably are various places that assume ConstantRange only contains integers.

I expect that there is very little logic that can be meaningfully shared between these -- it's mostly a matter of some API names being the same, while the implementation is different. I wouldn't try too many gymnastics to share anything between them.

[jvesely]

In D78220#1987377, @nikic wrote:

In D78220#1987284, @jvesely wrote:

Unless we use pointers and an extra level of indirection the end sizes for users like ValueLattice end up the same irrespective of where the union is (lower+upper vs. backend vs. user).

I'd expect that this is indeed what we want to do. Given that the float range is just so much larger, we'll want to allocate it out of line.

wouldn't the indirection needlessly penalize fp oriented targets? GPUs often use runtime compilers so performance here is more important than memory usage (gpu kernels tend to be smaller than offline compiled programs).

If memory usage is a concern, dropping ConstantRange from ValueLattice structure (so it's not taking up space for unknown/overdefined tags) might be a better target.

That's also a possibility (LVI for example uses a separate set for overdefined values to reduce memory usage), but fairly orthogonal. Even if ConstantRange is allocated out of line as well, we'll still want to be able to allocate the smaller integer only structure.

In any case, it's really not just a matter of memory usage, but also semantics. Integer and float constant ranges cannot interact in any meaningful way, you can't take the union of an integer and float range for example. Your patch already asserts that range types match in many places. It is better if these invariants get enforced more robustly by the type system.

In D78220#1986237, @fhahn wrote:

Even with a union, you still need extra space for the bits to distinguish between FP/integers (and other FP related flags, like canBeNaN. It should be possible to achieve the same level of convenience to this patch, but separating integer and FP ranges into separate classes. E.g. add ConstantRangeIntStorage & ConstantRangeFloatStorage which use APInt/APFloat respectively. The shared logic can be implemented in a ConstantRangeCommon template, which can be instantiated with either ConstantRangeIntStorage/ConstantRangeFPStorage. ConstantRange would turn into an instantiation of ConstantRangeCommon<ConstantRangeIntStorage>. Of course that would require updating code to make use of the FP version of ConstantRange. That might be a benefit actually, because there probably are various places that assume ConstantRange only contains integers.

I expect that there is very little logic that can be meaningfully shared between these -- it's mostly a matter of some API names being the same, while the implementation is different. I wouldn't try too many gymnastics to share anything between them.

The logic is separate as most operations are either int or float with limited number of transitions (fptoint/inttofp). The point is to have a single instance that can handle both. the user should be able to do getFull(Type*)/getEmpty(Type*)/isSingleElement()/getSingleElementConstant(...)/getSatisfyingRange(CmpInst).contains(item1.getRange()) without having to duplicate the logic for integer and floating point types.
Separate classes impose extra complexity on every user that wants to track floating point values. it's not just handling of storage in a union (which at least for ValueLattice is mostly in place), but every single function that currently returns a ConstantRange will need to be duplicated. this leads to error-prone code structure.

The current version of the patches intentionally keeps things separate for reviewing, but the plan is to unify most of the duplicated code paths introduced in D78224. Even in D78224 the codepaths that only deal with ranges are unified, the separation is mainly for range creation or extracting single values.

[fhahn]

In D78220#1987284, @jvesely wrote:

In D78220#1986237, @fhahn wrote:

Even with a union, you still need extra space for the bits to distinguish between FP/integers (and other FP related flags, like canBeNaN. It should be possible to achieve the same level of convenience to this patch, but separating integer and FP ranges into separate classes. E.g. add ConstantRangeIntStorage & ConstantRangeFloatStorage which use APInt/APFloat respectively. The shared logic can be implemented in a ConstantRangeCommon template, which can be instantiated with either ConstantRangeIntStorage/ConstantRangeFPStorage. ConstantRange would turn into an instantiation of ConstantRangeCommon<ConstantRangeIntStorage>. Of course that would require updating code to make use of the FP version of ConstantRange. That might be a benefit actually, because there probably are various places that assume ConstantRange only contains integers.

When using the FP version of the constant range in ValueLattice, that would allow us to keep the size the same, if no extra bits (like canBeNaN) are added.

OK, I'll take a stab at separating the backend, but I don't see a good way to reduce memory usage.

the current situation:
sizeof(APInt) == 16 and there are two of them so sizeof(ConstantRange) == 32, ValueLattice includes ConstantRange as member + extra tags givining it the size of 33 (aligned to 40).

possible implementations of fp tracking:
a) using unions for Lower/LowerFP, Upper/UpperFP:
sizeof(APFloat) == 32 x2 + 2 for tags => sizeof(ConstantRange) == 66 (aligned up to 72). ValueLattice includes ConstantRange as member bringing the size to 73 (aligned to 80).

b) union backend:
sizeof (ConstantRangeBackendInt) == 32, sizeof(ConstantRangeBackendFP) == 65 (2x APFloat + bool NaN, aligned up to 72), sizeof ConstantRange == 72). ValueLattice includes ConstantRange as member bring s the size to 73 (aligned to 80)

c) separate classes for int and float ranges:
sizeof(ConstantRangeInt) == 32, sizeof(ConstantRangeFP) == 65 (aligns up to 72). ValueLattice includes both variants in a union bringing the size to 73 (aligned to 80).

The memory overhead is 2x, which is consistent with tracking more information.
As long as we have one flag, adding another another is free because of the alignment. (I used 8B alignment, but 4B align is not going to change the sizes much).

Unless we use pointers and an extra level of indirection the end sizes for users like ValueLattice end up the same irrespective of where the union is (lower+upper vs. backend vs. user).

If memory usage is a concern, dropping ConstantRange from ValueLattice structure (so it's not taking up space for unknown/overdefined tags) might be a better target.

I think there are 2 ways to stage the introduction: 1) extending ConstantRange as in this patch is overall less work in terms of patches, but will probably require more analysis on the impact and/or more convincing as ConstantRange is widely used. 2) Introducing a ConstantRangeFP first allows clients to migrate step-by-step and would probably be easier to get in incrementally and things can unified later, once any outstanding issues are addressed.

It might be that there is no impact on compile-time/memory usage overall with the current version (using a union), but it would be good to collect data.

Is there a test suite that I can use to collect this? Are there any integer heavy/only use cases that would only suffer overhead without any benefit to fp range tracking?

Not sure about specific test cases, but people commonly use CTMark (from test-suite) and/or various versions of SPEC.

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/include/llvm/IR/ConstantRange.h

 // unsigned ranges.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_CONSTANTRANGE_H
 #define LLVM_IR_CONSTANTRANGE_H
 
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/Support/Compiler.h"
 #include <cstdint>
 
 namespace llvm {
 
 class MDNode;
 class raw_ostream;
 struct KnownBits;
 
 /// This class represents a range of values.
 class LLVM_NODISCARD ConstantRange {
   APInt Lower, Upper;
+  APFloat LowerFP = APFloat(0.0), UpperFP = APFloat(0.0);
+  bool isFloat = false;
+  bool canBeNaN = false;
+
+  /// Create full constant FP range with the same semantics
+  ConstantRange getFullFP(bool CanBeNan=true) const {
+    assert(isFloat);
+    return getFull(LowerFP.getSemantics(), CanBeNan);
+  }
 
-  /// Create empty constant range with same bitwidth.
+  /// Create empty constant range with same bitwidth/semantics.
   ConstantRange getEmpty() const {
+    if (isFloat) return getEmpty(LowerFP.getSemantics());
     return ConstantRange(getBitWidth(), false);
   }
 
   /// Create full constant range with same bitwidth.
   ConstantRange getFull() const {
+    if (isFloat) return getFull(LowerFP.getSemantics(), true);
     return ConstantRange(getBitWidth(), true);
   }
 
 public:
   /// Initialize a full or empty set for the specified bit width.
   explicit ConstantRange(uint32_t BitWidth, bool isFullSet);
 
   /// Initialize a range to hold the single specified value.
   ConstantRange(APInt Value);
+  ConstantRange(const APFloat &Value);
 
   /// Initialize a range of values explicitly. This will assert out if
   /// Lower==Upper and Lower != Min or Max value for its type. It will also
   /// assert out if the two APInt's are not the same bit width.
   ConstantRange(APInt Lower, APInt Upper);
+  ConstantRange(APFloat Lower, APFloat Upper, bool canBeNaN = false);
 
   /// Create empty constant range with the given bit width.
   static ConstantRange getEmpty(uint32_t BitWidth) {
     return ConstantRange(BitWidth, false);
   }
 
+  /// Create empty float constant range with the given semantics.
+  static ConstantRange getEmpty(const fltSemantics &Sem) {
+    return ConstantRange(APFloat::getNaN(Sem), APFloat::getNaN(Sem), false);
+  }
+
   /// Create full constant range with the given bit width.
   static ConstantRange getFull(uint32_t BitWidth) {
     return ConstantRange(BitWidth, true);
   }
 
+  /// Create full constant range with the given bit width.
+  static ConstantRange getFull(const fltSemantics &Sem, bool CanBeNan=true) {
+    return ConstantRange(APFloat::getInf(Sem, true),
+                         APFloat::getInf(Sem, false), CanBeNan);
+  }
+
   /// Create non-empty constant range with the given bounds. If Lower and
   /// Upper are the same, a full range is returned.
   static ConstantRange getNonEmpty(APInt Lower, APInt Upper) {
     if (Lower == Upper)
       return getFull(Lower.getBitWidth());
     return ConstantRange(std::move(Lower), std::move(Upper));
   }
 
   /// Initialize a range based on a known bits constraint. The IsSigned flag
   /// indicates whether the constant range should not wrap in the signed or
   /// unsigned domain.
   static ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned);
 
   /// Produce the smallest range such that all values that may satisfy the given
   /// predicate with any value contained within Other is contained in the
   /// returned range.  Formally, this returns a superset of
   /// 'union over all y in Other . { x : icmp op x y is true }'.  If the exact
   /// answer is not representable as a ConstantRange, the return value will be a
   /// proper superset of the above.
   ///
   /// Example: Pred = ult and Other = i8 [2, 5) returns Result = [0, 4)
   static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred,
                                              const ConstantRange &Other);
 
+  /// Produce the smallest range such that all values that may satisfy the given
+  /// predicate with any value contained within Other is contained in the
+  /// returned range.  Formally, this returns a superset of
+  /// 'union over all y in Other . { x : icmp op x y is true }'.  If the exact
+  /// answer is not representable as a ConstantRange, the return value will be a
+  /// proper superset of the above.
+  static ConstantRange makeAllowedFCmpRegion(CmpInst::Predicate Pred,
+                                             const ConstantRange &Other);
+
   /// Produce the largest range such that all values in the returned range
   /// satisfy the given predicate with all values contained within Other.
   /// Formally, this returns a subset of
   /// 'intersection over all y in Other . { x : icmp op x y is true }'.  If the
   /// exact answer is not representable as a ConstantRange, the return value
   /// will be a proper subset of the above.
   ///
   /// Example: Pred = ult and Other = i8 [2, 5) returns [0, 2)
   static ConstantRange makeSatisfyingICmpRegion(CmpInst::Predicate Pred,
                                                 const ConstantRange &Other);
 
+  /// Produce the largest range such that all values in the returned range
+  /// satisfy the given predicate with all values contained within Other.
+  /// Formally, this returns a subset of
+  /// 'intersection over all y in Other . { x : fcmp op x y is true }'.  If the
+  /// exact answer is not representable as a ConstantRange, the return value
+  /// will be a proper subset of the above.
+  static ConstantRange makeSatisfyingFCmpRegion(CmpInst::Predicate Pred,
+                                                const ConstantRange &Other);
+
   /// Produce the exact range such that all values in the returned range satisfy
   /// the given predicate with any value contained within Other. Formally, this
   /// returns the exact answer when the superset of 'union over all y in Other
   /// is exactly same as the subset of intersection over all y in Other.
   /// { x : icmp op x y is true}'.
   ///
   /// Example: Pred = ult and Other = i8 3 returns [0, 3)
   static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred,
                                            const APInt &Other);
 
+  /// Produce the exact range such that all values in the returned range satisfy
+  /// the given predicate with any value contained within Other. Formally, this
+  /// returns the exact answer when the superset of 'union over all y in Other
+  /// is exactly same as the subset of intersection over all y in Other.
+  /// { x : fcmp op x y is true}'.
+  static ConstantRange makeExactFCmpRegion(CmpInst::Predicate Pred,
+                                           const APFloat &Other);
+
   /// Produce the largest range containing all X such that "X BinOp Y" is
   /// guaranteed not to wrap (overflow) for *all* Y in Other. However, there may
   /// be *some* Y in Other for which additional X not contained in the result
   /// also do not overflow.
   ///
   /// NoWrapKind must be one of OBO::NoUnsignedWrap or OBO::NoSignedWrap.
   ///
   /// Examples:
static ConstantRange makeExactNoWrapRegion(Instruction::BinaryOps BinOp,
                                              unsigned NoWrapKind);
 
   /// Set up \p Pred and \p RHS such that
   /// ConstantRange::makeExactICmpRegion(Pred, RHS) == *this.  Return true if
   /// successful.
   bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const;
 
   /// Return the lower value for this range.
-  const APInt &getLower() const { return Lower; }
+  const APInt &getLower() const { assert(!isFloat); return Lower; }
 
   /// Return the upper value for this range.
-  const APInt &getUpper() const { return Upper; }
+  const APInt &getUpper() const { assert(!isFloat); return Upper; }
+
+  /// Return the lower value for this range.
+  const APFloat &getLowerFP() const { assert(isFloat); return LowerFP; }
+
+  /// Return the upper value for this range.
+  const APFloat &getUpperFP() const { assert(isFloat); return UpperFP; }
+
+  bool getIsFloat() const { return isFloat; }
+  bool getCanBeNaN() const { return isFloat && canBeNaN; }
 
   /// Get the bit width of this ConstantRange.
-  uint32_t getBitWidth() const { return Lower.getBitWidth(); }
+  uint32_t getBitWidth() const {
+    if (isFloat) return APFloat::getSizeInBits(LowerFP.getSemantics());
+      else return Lower.getBitWidth();
+  }
 
   /// Return true if this set contains all of the elements possible
   /// for this data-type.
   bool isFullSet() const;
 
   /// Return true if this set contains no members.
   bool isEmptySet() const;
 
public:
   ///  * Empty set: Not wrapped.
   ///  * Full set: Not wrapped.
   ///  * [X, SignedMin): Wrapped.
   bool isUpperSignWrapped() const;
 
   /// Return true if the specified value is in the set.
   bool contains(const APInt &Val) const;
 
+  /// Return true if the specified value is in the set.
+  bool contains(const APFloat &Val) const;
+
   /// Return true if the other range is a subset of this one.
   bool contains(const ConstantRange &CR) const;
 
   /// If this set contains a single element, return it, otherwise return null.
   const APInt *getSingleElement() const {
-    if (Upper == Lower + 1)
+    if (!isFloat && (Upper == Lower + 1))
       return &Lower;
     return nullptr;
   }
 
+  /// If this set contains a single FP element, return it, otherwise return null.
+  const APFloat *getSingleElementFP() const {
+    if (isFloat && !isEmptySet() && UpperFP.bitwiseIsEqual(LowerFP) &&
+        (canBeNaN == LowerFP.isNaN()))
+      return &LowerFP;
+    return nullptr;
+  }
+
   /// If this set contains all but a single element, return it, otherwise return
   /// null.
   const APInt *getSingleMissingElement() const {
+    assert(!isFloat);
     if (Lower == Upper + 1)
       return &Upper;
     return nullptr;
   }
 
-  /// Return true if this set contains exactly one member.
+  /// Return true if this set contains exactly one integer member.
   bool isSingleElement() const { return getSingleElement() != nullptr; }
 
+  /// Return true if this set contains exactly one floating point member.
+  bool isSingleElementFP() const { return getSingleElementFP() != nullptr; }
+
   /// Compare set size of this range with the range CR.
   bool isSizeStrictlySmallerThan(const ConstantRange &CR) const;
 
   /// Compare set size of this range with Value.
   bool isSizeLargerThan(uint64_t MaxSize) const;
 
   /// Return true if all values in this range are negative.
   bool isAllNegative() const;
public:
   /// Return the largest signed value contained in the ConstantRange.
   APInt getSignedMax() const;
 
   /// Return the smallest signed value contained in the ConstantRange.
   APInt getSignedMin() const;
 
   /// Return true if this range is equal to another range.
   bool operator==(const ConstantRange &CR) const {
-    return Lower == CR.Lower && Upper == CR.Upper;
+    if (isFloat)
+      return isFloat == CR.isFloat && canBeNaN == CR.canBeNaN &&
+             (LowerFP.bitwiseIsEqual(CR.LowerFP) || (LowerFP.isNaN() && CR.LowerFP.isNaN())) &&
+             (UpperFP.bitwiseIsEqual(CR.UpperFP) || (UpperFP.isNaN() && CR.UpperFP.isNaN()));
+    else
+      return isFloat == CR.isFloat && Lower == CR.Lower && Upper == CR.Upper;
   }
   bool operator!=(const ConstantRange &CR) const {
     return !operator==(CR);
   }
 
   /// Subtract the specified constant from the endpoints of this constant range.
   ConstantRange subtract(const APInt &CI) const;
 
public:
   /// elements of both sets, but may contain more.  For example, [3, 9) union
   /// [12,15) is [3, 15), which includes 9, 10, and 11, which were not included
   /// in either set before.
   ConstantRange unionWith(const ConstantRange &CR,
                           PreferredRangeType Type = Smallest) const;
 
   /// Return a new range representing the possible values resulting
   /// from an application of the specified cast operator to this range. \p
-  /// BitWidth is the target bitwidth of the cast.  For casts which don't
-  /// change bitwidth, it must be the same as the source bitwidth.  For casts
+  /// BitWidth is the target bitwidth of the cast. For casts which don't
+  /// change bitwidth, it must be the same as the source bitwidth. For casts
   /// which do change bitwidth, the bitwidth must be consistent with the
-  /// requested cast and source bitwidth.
+  /// requested cast and source bitwidth. Casts to floating point type are not
+  /// handled by this function.
   ConstantRange castOp(Instruction::CastOps CastOp,
                        uint32_t BitWidth) const;
+  /// Return a new range representing the possible values resulting
+  /// from an application of the specified cast operator to this range. \p
+  /// Sem is target floating point semantics.
+  ConstantRange castOp(Instruction::CastOps CastOp,
+                       const llvm::fltSemantics &Sem) const;
 
   /// Return a new range in the specified integer type, which must
   /// be strictly larger than the current type.  The returned range will
   /// correspond to the possible range of values if the source range had been
   /// zero extended to BitWidth.
   ConstantRange zeroExtend(uint32_t BitWidth) const;
 
   /// Return a new range in the specified integer type, which must
ConstantRange overflowingBinaryOp(Instruction::BinaryOps BinOp,
                                     const ConstantRange &Other,
                                     unsigned NoWrapKind) const;
 
   /// Return a new range representing the possible values resulting
   /// from an addition of a value in this range and a value in \p Other.
   ConstantRange add(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
+  /// from an addition of a value in this range and a value in \p Other.
+  ConstantRange fadd(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
   /// from an addition with wrap type \p NoWrapKind of a value in this
   /// range and a value in \p Other.
   /// If the result range is disjoint, the preferred range is determined by the
   /// \p PreferredRangeType.
   ConstantRange addWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind,
                               PreferredRangeType RangeType = Smallest) const;
 
   /// Return a new range representing the possible values resulting
   /// from a subtraction of a value in this range and a value in \p Other.
   ConstantRange sub(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
   /// from an subtraction with wrap type \p NoWrapKind of a value in this
   /// range and a value in \p Other.
   /// If the result range is disjoint, the preferred range is determined by the
   /// \p PreferredRangeType.
   ConstantRange subWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind,
                               PreferredRangeType RangeType = Smallest) const;
 
   /// Return a new range representing the possible values resulting
+  /// from a subtraction of a value in this range and a value in \p Other.
+  ConstantRange fsub(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
   /// from a multiplication of a value in this range and a value in \p Other,
   /// treating both this and \p Other as unsigned ranges.
   ConstantRange multiply(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
+  /// from a multiplication of a value in this range and a value in \p Other.
+  ConstantRange fmultiply(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
+  /// from a division of a value in this range and a value in \p Other.
+  ConstantRange fdivide(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
+  /// from a maximum of a value in this range and a value in \p Other.
+  ConstantRange fmax(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
+  /// from a minimum of a value in this range and a value in \p Other.
+  ConstantRange fmin(const ConstantRange &Other) const;
+
+  /// Return a new range representing the possible values resulting
   /// from a signed maximum of a value in this range and a value in \p Other.
   ConstantRange smax(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting
   /// from an unsigned maximum of a value in this range and a value in \p Other.
   ConstantRange umax(const ConstantRange &Other) const;
 
   /// Return a new range representing the possible values resulting

llvm/lib/IR/ConstantRange.cpp

 #include "llvm/Support/KnownBits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 
 using namespace llvm;
 
+static APFloat ZeroNext(APFloat X, bool Neg) {
+  if (X.isZero() && X.isNegative() != Neg)
+    X.changeSign();
+  else
+    X.next(Neg);
+  return X;
+}
+
 ConstantRange::ConstantRange(uint32_t BitWidth, bool Full)
     : Lower(Full ? APInt::getMaxValue(BitWidth) : APInt::getMinValue(BitWidth)),
       Upper(Lower) {}
 
 ConstantRange::ConstantRange(APInt V)
     : Lower(std::move(V)), Upper(Lower + 1) {}
 
 ConstantRange::ConstantRange(APInt L, APInt U)
     : Lower(std::move(L)), Upper(std::move(U)) {
   assert(Lower.getBitWidth() == Upper.getBitWidth() &&
          "ConstantRange with unequal bit widths");
   assert((Lower != Upper || (Lower.isMaxValue() || Lower.isMinValue())) &&
          "Lower == Upper, but they aren't min or max value!");
 }
 
+ConstantRange::ConstantRange(const APFloat &Const)
+    : LowerFP(Const), UpperFP(Const), isFloat(true), canBeNaN(Const.isNaN()) {}
+
+ConstantRange::ConstantRange(APFloat Lower, APFloat Upper, bool canBeNaN)
+    : LowerFP(std::move(Lower)), UpperFP(std::move(Upper)), isFloat(true),
+      canBeNaN(canBeNaN) {
+  assert(&Lower.getSemantics() == &Upper.getSemantics() &&
+         "ConstantRange with mismatched FP semantics");
+  assert(LowerFP.isNaN() == UpperFP.isNaN());
+  // Check if we are wrapped range with no values outside
+  APFloat Tmp = ZeroNext(LowerFP, true);
+  if (!LowerFP.bitwiseIsEqual(UpperFP) && Tmp.bitwiseIsEqual(UpperFP) && !Tmp.isNaN()) {
+    LowerFP = APFloat::getInf(LowerFP.getSemantics(), true); // NegInf
+    UpperFP = APFloat::getInf(LowerFP.getSemantics(), false); // PosInf
+  }
+}
+
 ConstantRange ConstantRange::fromKnownBits(const KnownBits &Known,
                                            bool IsSigned) {
   assert(!Known.hasConflict() && "Expected valid KnownBits");
 
   if (Known.isUnknown())
     return getFull(Known.getBitWidth());
 
   // For unsigned ranges, or signed ranges with known sign bit, create a simple
   // range between the smallest and largest possible value.
   if (!IsSigned || Known.isNegative() || Known.isNonNegative())
     return ConstantRange(Known.getMinValue(), Known.getMaxValue() + 1);
 
   // If we don't know the sign bit, pick the lower bound as a negative number
   // and the upper bound as a non-negative one.
   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) {
+  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
+  if (CR.canBeNaN && CmpInst::isUnordered(Pred))
+      return CR.getFull();
+
+  // Useful constants
+  APFloat PosInf = APFloat::getInf(CR.LowerFP.getSemantics(), false);
+  APFloat NegInf = APFloat::getInf(CR.LowerFP.getSemantics(), true);
+  APFloat NaN = APFloat::getNaN(CR.LowerFP.getSemantics());
+
+  switch (Pred) {
+  default:
+    llvm_unreachable("Invalid FCmp predicate to makeAllowedFCmpRegion()");
+  case CmpInst::FCMP_UNO:
+    // CR.canBeNaN is handled above, so only NaN compares UNO to CR.
+    return ConstantRange(NaN);
+  case CmpInst::FCMP_ORD:
+    // isnan(CR) is handled above, return no-nan range
+    return ConstantRange(std::move(NegInf), std::move(PosInf), false);
+  case CmpInst::FCMP_UEQ:
+  case CmpInst::FCMP_OEQ: {
+    // Return the sames ordered part as CR, extend boundaries if zero.
+    APFloat LowerFP = CR.LowerFP.isZero() ? APFloat::getZero(CR.LowerFP.getSemantics(), true) : CR.LowerFP;
+    APFloat UpperFP = CR.UpperFP.isZero() ? APFloat::getZero(CR.UpperFP.getSemantics(), false) : CR.UpperFP;
+    return ConstantRange(std::move(LowerFP), std::move(UpperFP), CmpInst::isUnordered(Pred));
+  }
+  case CmpInst::FCMP_UNE:
+  case CmpInst::FCMP_ONE:
+    // bitwiseIsEqual covers singleElement + canBeNaN
+    // [-0,0] should be trated as single value wrt != operator
+    if (CR.LowerFP.bitwiseIsEqual(CR.UpperFP) ||
+        (CR.LowerFP.isNegZero() && CR.UpperFP.isPosZero())) {
+      ConstantRange Inv = CR.inverse();
+      Inv.canBeNaN = CmpInst::isUnordered(Pred);
+      // Handle +/- 0
+      if (Inv.LowerFP.isPosZero()) // The original included -0.0
+        Inv.LowerFP.next(false);
+      if (Inv.UpperFP.isNegZero()) // The original included 0.0
+        Inv.UpperFP.next(true);
+      return Inv;
+    }
+    return ConstantRange(std::move(NegInf), std::move(PosInf), CmpInst::isUnordered(Pred));
+  case CmpInst::FCMP_OLT:
+  case CmpInst::FCMP_ULT: {
+    // Nothing is LT -Inf, but NaN is unordered
+    if (CR.UpperFP.bitwiseIsEqual(CR.LowerFP) &&
+        CR.UpperFP.isNegative() && CR.UpperFP.isInfinity())
+      return ConstantRange(NaN, NaN, CmpInst::isUnordered(Pred));
+    // Almost everything is LT +Inf
+    APFloat Upper = CR.contains(PosInf) ? PosInf : CR.UpperFP;
+    Upper.next(true);
+    return ConstantRange(std::move(NegInf), std::move(Upper), CmpInst::isUnordered(Pred));
+  }
+  case CmpInst::FCMP_OGT:
+  case CmpInst::FCMP_UGT: {
+    // Nothing is GT +Inf, but NaN unordered
+    if (CR.UpperFP.bitwiseIsEqual(CR.LowerFP) &&
+        !CR.UpperFP.isNegative() && CR.UpperFP.isInfinity())
+      return ConstantRange(NaN, NaN, CmpInst::isUnordered(Pred));
+    // Almost everything is LT -Inf
+    APFloat Lower = CR.contains(NegInf) ? NegInf : CR.LowerFP;
+    Lower.next(false);
+    return ConstantRange(std::move(Lower), std::move(PosInf), CmpInst::isUnordered(Pred));
+  }
+  case CmpInst::FCMP_OLE:
+  case CmpInst::FCMP_ULE: {
+    // Everything is LE than +Inf, and NaN is unordered
+    if (CR.contains(PosInf))
+      return ConstantRange(std::move(NegInf), std::move(PosInf), CmpInst::isUnordered(Pred));
+    APFloat Upper = CR.UpperFP.isZero() ? APFloat::getZero(CR.UpperFP.getSemantics()) : CR.UpperFP;
+    return ConstantRange(std::move(NegInf), std::move(Upper), CmpInst::isUnordered(Pred));
+  }
+  case CmpInst::FCMP_OGE:
+  case CmpInst::FCMP_UGE: {
+    // Everything is GE than -Inf, and NaN is unordered
+    if (CR.contains(NegInf))
+      return ConstantRange(std::move(NegInf), std::move(PosInf), CmpInst::isUnordered(Pred));
+    APFloat Lower = CR.LowerFP.isZero() ? APFloat::getZero(CR.LowerFP.getSemantics(), true) : CR.LowerFP;
+    return ConstantRange(std::move(Lower), std::move(PosInf), CmpInst::isUnordered(Pred));
+  }
+  }
+}
+
+ConstantRange ConstantRange::makeSatisfyingFCmpRegion(CmpInst::Predicate Pred,
+                                                      const ConstantRange &CR) {
+  // Follows from De-Morgan's laws:
+  //
+  // ~(~A union ~B) == A intersect B.
+  //
+  return makeAllowedFCmpRegion(CmpInst::getInversePredicate(Pred), CR)
+      .inverse();
+}
+
+ConstantRange ConstantRange::makeExactFCmpRegion(CmpInst::Predicate Pred,
+                                                 const APFloat &C) {
+  // Computes the exact range that is equal to both the constant ranges returned
+  // by makeAllowedFCmpRegion and makeSatisfyingICmpRegion. This is always true
+  // when RHS is a singleton such as an APFloat and so the assert is valid.
+  //
+  assert(makeAllowedFCmpRegion(Pred, C) == makeSatisfyingFCmpRegion(Pred, C));
+  return makeAllowedFCmpRegion(Pred, C);
+}
+
 ConstantRange ConstantRange::makeAllowedICmpRegion(CmpInst::Predicate Pred,
                                                    const ConstantRange &CR) {
   if (CR.isEmptySet())
     return CR;
 
   uint32_t W = CR.getBitWidth();
   switch (Pred) {
   default:
ConstantRange ConstantRange::makeExactICmpRegion(CmpInst::Predicate Pred,
   //
   assert(makeAllowedICmpRegion(Pred, C) == makeSatisfyingICmpRegion(Pred, C));
   return makeAllowedICmpRegion(Pred, C);
 }
 
 bool ConstantRange::getEquivalentICmp(CmpInst::Predicate &Pred,
                                       APInt &RHS) const {
   bool Success = false;
+  assert(!isFloat);
 
   if (isFullSet() || isEmptySet()) {
     Pred = isEmptySet() ? CmpInst::ICMP_ULT : CmpInst::ICMP_UGE;
     RHS = APInt(getBitWidth(), 0);
     Success = true;
   } else if (auto *OnlyElt = getSingleElement()) {
     Pred = CmpInst::ICMP_EQ;
     RHS = *OnlyElt;
ConstantRange ConstantRange::makeExactNoWrapRegion(Instruction::BinaryOps BinOp,
                                                    const APInt &Other,
                                                    unsigned NoWrapKind) {
   // makeGuaranteedNoWrapRegion() is exact for single-element ranges, as
   // "for all" and "for any" coincide in this case.
   return makeGuaranteedNoWrapRegion(BinOp, ConstantRange(Other), NoWrapKind);
 }
 
 bool ConstantRange::isFullSet() const {
+  if (isFloat)
+    return LowerFP.isInfinity() && LowerFP.isNegative() &&
+     UpperFP.isInfinity() && !UpperFP.isNegative() && canBeNaN;
+  else
     return Lower == Upper && Lower.isMaxValue();
 }
 
 bool ConstantRange::isEmptySet() const {
+  if (isFloat)
+    return LowerFP.isNaN() && UpperFP.isNaN() && !canBeNaN;
   return Lower == Upper && Lower.isMinValue();
 }
 
 bool ConstantRange::isWrappedSet() const {
+  if (isFloat) // Float version is the same as isUpperWrapped
+    return isUpperWrapped();
   return Lower.ugt(Upper) && !Upper.isNullValue();
 }
 
 bool ConstantRange::isUpperWrapped() const {
+  if (isFloat)
+    return LowerFP.compare(UpperFP) == APFloat::cmpGreaterThan;
   return Lower.ugt(Upper);
 }
 
 bool ConstantRange::isSignWrappedSet() const {
+  assert(!isFloat);
   return Lower.sgt(Upper) && !Upper.isMinSignedValue();
 }
 
 bool ConstantRange::isUpperSignWrapped() const {
+  assert(!isFloat);
   return Lower.sgt(Upper);
 }
 
 bool
 ConstantRange::isSizeStrictlySmallerThan(const ConstantRange &Other) const {
   assert(getBitWidth() == Other.getBitWidth());
+  assert(!isFloat);
   if (isFullSet())
     return false;
   if (Other.isFullSet())
     return true;
   return (Upper - Lower).ult(Other.Upper - Other.Lower);
 }
 
 bool
 ConstantRange::isSizeLargerThan(uint64_t MaxSize) const {
   assert(MaxSize && "MaxSize can't be 0.");
+  assert(!isFloat);
   // If this a full set, we need special handling to avoid needing an extra bit
   // to represent the size.
   if (isFullSet())
     return APInt::getMaxValue(getBitWidth()).ugt(MaxSize - 1);
 
   return (Upper - Lower).ugt(MaxSize);
 }
 
 bool ConstantRange::isAllNegative() const {
   // Empty set is all negative, full set is not.
   if (isEmptySet())
     return true;
   if (isFullSet())
     return false;
 
+  assert(!isFloat);
   return !isUpperSignWrapped() && !Upper.isStrictlyPositive();
 }
 
 bool ConstantRange::isAllNonNegative() const {
   // Empty and full set are automatically treated correctly.
   return !isSignWrappedSet() && Lower.isNonNegative();
 }
 
 APInt ConstantRange::getUnsignedMax() const {
+  assert(!isFloat);
   if (isFullSet() || isUpperWrapped())
     return APInt::getMaxValue(getBitWidth());
   return getUpper() - 1;
 }
 
 APInt ConstantRange::getUnsignedMin() const {
+  assert(!isFloat);
   if (isFullSet() || isWrappedSet())
     return APInt::getMinValue(getBitWidth());
   return getLower();
 }
 
 APInt ConstantRange::getSignedMax() const {
+  assert(!isFloat);
   if (isFullSet() || isUpperSignWrapped())
     return APInt::getSignedMaxValue(getBitWidth());
   return getUpper() - 1;
 }
 
 APInt ConstantRange::getSignedMin() const {
+  assert(!isFloat);
   if (isFullSet() || isSignWrappedSet())
     return APInt::getSignedMinValue(getBitWidth());
   return getLower();
 }
 
 bool ConstantRange::contains(const APInt &V) const {
+  assert(!isFloat);
   if (Lower == Upper)
     return isFullSet();
 
   if (!isUpperWrapped())
     return Lower.ule(V) && V.ult(Upper);
   return Lower.ule(V) || V.ult(Upper);
 }
 
+bool ConstantRange::contains(const APFloat &V) const {
+  assert(isFloat);
+  if (V.isNaN())
+    return canBeNaN;
+
+  if (V.bitwiseIsEqual(LowerFP) || V.bitwiseIsEqual(UpperFP))
+    return true;
+
+  // Special handling for signed zeros
+  if (V.isPosZero() && LowerFP.isNegZero() && !UpperFP.isNegZero())
+    return true;
+  if (V.isNegZero() && UpperFP.isPosZero() && !LowerFP.isPosZero())
+    return true;
+
+  if (!isUpperWrapped())
+    return LowerFP < V && V < UpperFP;
+  return UpperFP > V || V > LowerFP;
+}
+
 bool ConstantRange::contains(const ConstantRange &Other) const {
+  assert(isFloat == Other.isFloat);
   if (isFullSet() || Other.isEmptySet()) return true;
   if (isEmptySet() || Other.isFullSet()) return false;
+  if (isFloat && canBeNaN && Other.UpperFP.isNaN()) return true;
 
   if (!isUpperWrapped()) {
     if (Other.isUpperWrapped())
       return false;
 
+    if (isFloat) {
+      auto Lo = LowerFP.compare(Other.LowerFP);
+      auto Hi = UpperFP.compare(Other.UpperFP);
+      return (Lo == APFloat::cmpLessThan ||
+              LowerFP.bitwiseIsEqual(Other.LowerFP) ||
+              (LowerFP.isNegZero() && Other.LowerFP.isPosZero())) &&
+             (Hi == APFloat::cmpGreaterThan ||
+              UpperFP.bitwiseIsEqual(Other.UpperFP) ||
+             (UpperFP.isPosZero() && Other.UpperFP.isNegZero())) &&
+       (canBeNaN || !Other.canBeNaN);
+    }
     return Lower.ule(Other.getLower()) && Other.getUpper().ule(Upper);
   }
 
-  if (!Other.isUpperWrapped())
-    return Other.getUpper().ule(Upper) ||
-           Lower.ule(Other.getLower());
+  if (!Other.isUpperWrapped()) {
+    if (isFloat) {
+      // LHS is UpperWrapped, RHS is not. We can split into two subregions.
+      ConstantRange UpperHalf = ConstantRange(LowerFP,
+                                  APFloat::getInf(LowerFP.getSemantics()),
+          canBeNaN);
+      ConstantRange LowerHalf = ConstantRange(
+                                  APFloat::getInf(LowerFP.getSemantics(), true),
+                                  UpperFP, canBeNaN);
+      return LowerHalf.contains(Other) || UpperHalf.contains(Other);
+    }
+    return Other.getUpper().ule(Upper) || Lower.ule(Other.getLower());
+  }
 
+  assert(!isFloat);
   return Other.getUpper().ule(Upper) && Lower.ule(Other.getLower());
 }
 
 ConstantRange ConstantRange::subtract(const APInt &Val) const {
   assert(Val.getBitWidth() == getBitWidth() && "Wrong bit width");
   // If the set is empty or full, don't modify the endpoints.
   if (Lower == Upper)
     return *this;
static ConstantRange getPreferredRange(
 
   if (CR1.isSizeStrictlySmallerThan(CR2))
     return CR1;
   return CR2;
 }
 
 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR,
                                            PreferredRangeType Type) const {
+  assert(isFloat == CR.isFloat &&
+         "ConstantRange type don't agree!");
   assert(getBitWidth() == CR.getBitWidth() &&
          "ConstantRange types don't agree!");
 
   // Handle common cases.
   if (   isEmptySet() || CR.isFullSet()) return *this;
   if (CR.isEmptySet() ||    isFullSet()) return CR;
 
   if (!isUpperWrapped() && CR.isUpperWrapped())
     return CR.intersectWith(*this, Type);
 
   if (!isUpperWrapped() && !CR.isUpperWrapped()) {
+    if (isFloat) {
+      assert(Type == Smallest);
+      // There are several situations handled in this block,
+      // none of which can result in a wrapped or disjoint result:
+      // this: L--U      | L--U   |  L--U  |  L---U |   L--U |      L--U
+      // CR:        L--U |   L--U | L----U |   L-U  | L--U   | L--U
+      APFloat Upper = llvm::minimum(UpperFP, CR.UpperFP);
+      APFloat Lower = llvm::maximum(LowerFP, CR.LowerFP);
+      auto Res = Lower.compare(Upper);
+      // Explicitly allow [-0, 0]
+      if (Res != APFloat::cmpLessThan && !Lower.bitwiseIsEqual(Upper) &&
+    !(Lower.isNegZero() && Upper.isPosZero()))
+        return ConstantRange(APFloat::getNaN(Lower.getSemantics()),
+                             APFloat::getNaN(Upper.getSemantics()),
+                             canBeNaN && CR.canBeNaN);
+      return ConstantRange(::std::move(Lower), ::std::move(Upper),
+                           canBeNaN && CR.canBeNaN);
+    }
     if (Lower.ult(CR.Lower)) {
       // L---U       : this
       //       L---U : CR
       if (Upper.ule(CR.Lower))
         return getEmpty();
 
       // L---U       : this
       //   L---U     : CR
if (Lower.ult(CR.Upper))
       return ConstantRange(Lower, CR.Upper);
 
     //       L---U : this
     // L---U       : CR
     return getEmpty();
   }
 
   if (isUpperWrapped() && !CR.isUpperWrapped()) {
-    if (CR.Lower.ult(Upper)) {
+    // FP range is inclusive so include it here
+    if ((!isFloat && CR.Lower.ult(Upper)) ||
+        (isFloat && CR.LowerFP <= UpperFP)) {
       // ------U   L--- : this
       //  L--U          : CR
-      if (CR.Upper.ult(Upper))
+      if (!isFloat && CR.Upper.ult(Upper))
         return CR;
+      if (isFloat && CR.UpperFP < UpperFP)
+        return ConstantRange(CR.LowerFP, CR.UpperFP, canBeNaN && CR.canBeNaN);
 
       // ------U   L--- : this
       //  L------U      : CR
-      if (CR.Upper.ule(Lower))
+      if (!isFloat && CR.Upper.ule(Lower))
         return ConstantRange(CR.Lower, Upper);
+      // FP range is inclusive so don't include it here
+      if (isFloat && CR.UpperFP < LowerFP)
+        return ConstantRange(CR.LowerFP, UpperFP, canBeNaN && CR.canBeNaN);
 
       // ------U   L--- : this
       //  L----------U  : CR
+      if (isFloat)
+        return ConstantRange(CR.LowerFP, CR.UpperFP, canBeNaN && CR.canBeNaN);
       return getPreferredRange(*this, CR, Type);
     }
-    if (CR.Lower.ult(Lower)) {
+    if ((!isFloat && CR.Lower.ult(Lower)) ||
+        (isFloat && CR.LowerFP < LowerFP)) {
       // --U      L---- : this
       //     L--U       : CR
-      if (CR.Upper.ule(Lower))
+      if (!isFloat && CR.Upper.ule(Lower))
         return getEmpty();
+      if (isFloat && CR.UpperFP < LowerFP)
+        return ConstantRange(APFloat::getNaN(LowerFP.getSemantics()),
+                             APFloat::getNaN(UpperFP.getSemantics()),
+                             canBeNaN && CR.canBeNaN);
 
       // --U      L---- : this
       //     L------U   : CR
+      if (isFloat)
+        return ConstantRange(LowerFP, CR.UpperFP, canBeNaN && CR.canBeNaN);
       return ConstantRange(Lower, CR.Upper);
     }
 
     // --U  L------ : this
     //        L--U  : CR
+    if (isFloat)
+      return ConstantRange(CR.LowerFP, CR.UpperFP, canBeNaN && CR.canBeNaN);
     return CR;
   }
 
+  // Both are upperWrapped
+  if (isFloat) {
+    assert(Type == Smallest);
+    // Handle disjoint cases
+    if (CR.LowerFP <= UpperFP || LowerFP <= CR.UpperFP)
+      return (CR.LowerFP - CR.UpperFP) > (LowerFP - UpperFP) ? CR : *this;
+    APFloat Upper = llvm::minimum(UpperFP, CR.UpperFP);
+    APFloat Lower = llvm::maximum(LowerFP, CR.LowerFP);
+    return ConstantRange(::std::move(Lower), ::std::move(Upper), canBeNaN && CR.canBeNaN);
+  }
   if (CR.Upper.ult(Upper)) {
     // ------U L-- : this
     // --U L------ : CR
     if (CR.Lower.ult(Upper))
       return getPreferredRange(*this, CR, Type);
 
     // ----U   L-- : this
     // --U   L---- : CR
ConstantRange ConstantRange::intersectWith(const ConstantRange &CR,
 
   // --U L------ : this
   // ------U L-- : CR
   return getPreferredRange(*this, CR, Type);
 }
 
 ConstantRange ConstantRange::unionWith(const ConstantRange &CR,
                                        PreferredRangeType Type) const {
-  assert(getBitWidth() == CR.getBitWidth() &&
-         "ConstantRange types don't agree!");
+  assert(isFloat == CR.isFloat);
 
   if (   isFullSet() || CR.isEmptySet()) return *this;
   if (CR.isFullSet() ||    isEmptySet()) return CR;
+  // Handle union with NaN that is not empty
+  if (CR.UpperFP.isNaN()) return ConstantRange(LowerFP, UpperFP, true);
+  if (UpperFP.isNaN()) return ConstantRange(CR.LowerFP, CR.UpperFP, true);
+
+  assert(getBitWidth() == CR.getBitWidth() &&
+         "ConstantRange types don't agree!");
 
   if (!isUpperWrapped() && CR.isUpperWrapped())
     return CR.unionWith(*this, Type);
 
   if (!isUpperWrapped() && !CR.isUpperWrapped()) {
+    if (isFloat) {
+      return ConstantRange(minimum(LowerFP, CR.LowerFP),
+                           maximum(UpperFP, CR.UpperFP), canBeNaN || CR.canBeNaN);
+    }
     //        L---U  and  L---U        : this
     //  L---U                   L---U  : CR
     // result in one of
     //  L---------U
     // -----U L-----
     if (CR.Upper.ult(Lower) || Upper.ult(CR.Lower))
       return getPreferredRange(
           ConstantRange(Lower, CR.Upper), ConstantRange(CR.Lower, Upper), Type);
 
     APInt L = CR.Lower.ult(Lower) ? CR.Lower : Lower;
     APInt U = (CR.Upper - 1).ugt(Upper - 1) ? CR.Upper : Upper;
 
     if (L.isNullValue() && U.isNullValue())
       return getFull();
 
     return ConstantRange(std::move(L), std::move(U));
   }
 
   if (!CR.isUpperWrapped()) {
     // ------U   L-----  and  ------U   L----- : this
     //   L--U                            L--U  : CR
-    if (CR.Upper.ule(Upper) || CR.Lower.uge(Lower))
+    if (!isFloat && (CR.Upper.ule(Upper) || CR.Lower.uge(Lower)))
       return *this;
+    // Call maximum/minimum to properly handle +/-0 situations.
+    if (isFloat && CR.UpperFP <= UpperFP)
+      return ConstantRange(LowerFP, maximum(UpperFP, CR.UpperFP), canBeNaN || CR.canBeNaN);
+    if (isFloat && CR.LowerFP >= LowerFP)
+      return ConstantRange(minimum(LowerFP, CR.LowerFP), UpperFP, canBeNaN || CR.canBeNaN);
 
     // ------U   L----- : this
     //    L---------U   : CR
-    if (CR.Lower.ule(Upper) && Lower.ule(CR.Upper))
+    if (!isFloat && (CR.Lower.ule(Upper) && Lower.ule(CR.Upper)))
       return getFull();
+    if (isFloat && (CR.LowerFP <= UpperFP && LowerFP <= CR.UpperFP))
+      return getFullFP(canBeNaN || CR.canBeNaN);
 
     // ----U       L---- : this
     //       L---U       : CR
     // results in one of
     // ----------U L----
     // ----U L----------
-    if (Upper.ult(CR.Lower) && CR.Upper.ult(Lower))
+    if (!isFloat && Upper.ult(CR.Lower) && CR.Upper.ult(Lower))
       return getPreferredRange(
           ConstantRange(Lower, CR.Upper), ConstantRange(CR.Lower, Upper), Type);
+    if (isFloat && UpperFP < CR.LowerFP && CR.UpperFP < LowerFP) {
+      assert(Type == Smallest);
+      return CR.LowerFP - UpperFP > LowerFP - CR.UpperFP ?
+             ConstantRange(CR.LowerFP, UpperFP, canBeNaN || CR.canBeNaN):
+             ConstantRange(LowerFP, CR.UpperFP, canBeNaN || CR.canBeNaN);
+    }
 
     // ----U     L----- : this
     //        L----U    : CR
-    if (Upper.ult(CR.Lower) && Lower.ule(CR.Upper))
+    if (!isFloat && Upper.ult(CR.Lower) && Lower.ule(CR.Upper))
       return ConstantRange(CR.Lower, Upper);
+    if (isFloat && UpperFP < CR.LowerFP && LowerFP <= CR.UpperFP)
+      return ConstantRange(CR.LowerFP, UpperFP, canBeNaN || CR.canBeNaN);
 
     // ------U    L---- : this
     //    L-----U       : CR
+    if (isFloat)
+      return ConstantRange(LowerFP, CR.UpperFP, canBeNaN || CR.canBeNaN);
     assert(CR.Lower.ule(Upper) && CR.Upper.ult(Lower) &&
            "ConstantRange::unionWith missed a case with one range wrapped");
     return ConstantRange(Lower, CR.Upper);
   }
 
   // ------U    L----  and  ------U    L---- : this
   // -U  L-----------  and  ------------U  L : CR
-  if (CR.Lower.ule(Upper) || Lower.ule(CR.Upper))
+  if (!isFloat && (CR.Lower.ule(Upper) || Lower.ule(CR.Upper)))
     return getFull();
+  if (isFloat && (CR.LowerFP <= UpperFP || LowerFP <= CR.UpperFP))
+    return getFullFP(canBeNaN || CR.canBeNaN);
 
+  if (isFloat)
+    return ConstantRange(minimum(LowerFP, CR.LowerFP),
+                         maximum(UpperFP, CR.UpperFP), canBeNaN || CR.canBeNaN);
   APInt L = CR.Lower.ult(Lower) ? CR.Lower : Lower;
   APInt U = CR.Upper.ugt(Upper) ? CR.Upper : Upper;
 
   return ConstantRange(std::move(L), std::move(U));
 }
 
 ConstantRange ConstantRange::castOp(Instruction::CastOps CastOp,
                                     uint32_t ResultBitWidth) const {
   switch (CastOp) {
   default:
     llvm_unreachable("unsupported cast type");
   case Instruction::Trunc:
     return truncate(ResultBitWidth);
   case Instruction::SExt:
     return signExtend(ResultBitWidth);
   case Instruction::ZExt:
     return zeroExtend(ResultBitWidth);
   case Instruction::BitCast:
-    return *this;
+    // Bitcast bitwidth needs to match. ppc_fp128 needs special handling
+    assert((getBitWidth() == ResultBitWidth) ||
+           (ResultBitWidth == 128 && (isFloat && &LowerFP.getSemantics() == &APFloat::PPCDoubleDouble())));
+    return isFloat ? getFull(ResultBitWidth) : *this;
   case Instruction::FPToUI:
   case Instruction::FPToSI:
-    if (getBitWidth() == ResultBitWidth)
-      return *this;
-    else
-      return getFull(ResultBitWidth);
-  case Instruction::UIToFP: {
     // TODO: use input range if available
-    auto BW = getBitWidth();
-    APInt Min = APInt::getMinValue(BW).zextOrSelf(ResultBitWidth);
-    APInt Max = APInt::getMaxValue(BW).zextOrSelf(ResultBitWidth);
-    return ConstantRange(std::move(Min), std::move(Max));
-  }
-  case Instruction::SIToFP: {
-    // TODO: use input range if available
-    auto BW = getBitWidth();
-    APInt SMin = APInt::getSignedMinValue(BW).sextOrSelf(ResultBitWidth);
-    APInt SMax = APInt::getSignedMaxValue(BW).sextOrSelf(ResultBitWidth);
-    return ConstantRange(std::move(SMin), std::move(SMax));
-  }
-  case Instruction::FPTrunc:
-  case Instruction::FPExt:
+    return getFull(ResultBitWidth);
   case Instruction::IntToPtr:
   case Instruction::PtrToInt:
   case Instruction::AddrSpaceCast:
     // Conservatively return getFull set.
     return getFull(ResultBitWidth);
   };
 }
 
+ConstantRange ConstantRange::castOp(Instruction::CastOps CastOp,
+                                    const llvm::fltSemantics &Sem) const {
+  switch (CastOp) {
+  default:
+    llvm_unreachable("unsupported cast type");
+  case Instruction::FPTrunc:
+  case Instruction::FPExt: {
+    bool losesInfo1 = false, losesInfo2 = false;
+    APFloat ValL = LowerFP, ValU = UpperFP;
+    if (isUpperWrapped()) {
+      ValL.convert(Sem, APFloat::rmTowardPositive, &losesInfo1);
+      ValU.convert(Sem, APFloat::rmTowardNegative, &losesInfo2);
+    } else {
+      ValL.convert(Sem, APFloat::rmTowardNegative, &losesInfo1);
+      ValU.convert(Sem, APFloat::rmTowardPositive, &losesInfo2);
+    }
+    return ConstantRange(ValL, ValU, canBeNaN);
+  }
+  case Instruction::BitCast:
+    // Bitcast bitwidth needs to match. ppc_fp128 needs special handling
+    assert((getBitWidth() == APFloat::getSizeInBits(Sem)) ||
+           (getBitWidth() == 128 && &Sem == &APFloat::PPCDoubleDouble()));
+    return isFloat ? *this : getFull(Sem);
+  case Instruction::UIToFP:
+  case Instruction::SIToFP:
+    // TODO: use input range if available
+    return getFull(Sem);
+  };
+}
+
 ConstantRange ConstantRange::zeroExtend(uint32_t DstTySize) const {
+  assert(!isFloat);
   if (isEmptySet()) return getEmpty(DstTySize);
 
   unsigned SrcTySize = getBitWidth();
   assert(SrcTySize < DstTySize && "Not a value extension");
   if (isFullSet() || isUpperWrapped()) {
     // Change into [0, 1 << src bit width)
     APInt LowerExt(DstTySize, 0);
     if (!Upper) // special case: [X, 0) -- not really wrapping around
       LowerExt = Lower.zext(DstTySize);
     return ConstantRange(std::move(LowerExt),
                          APInt::getOneBitSet(DstTySize, SrcTySize));
   }
 
   return ConstantRange(Lower.zext(DstTySize), Upper.zext(DstTySize));
 }
 
 ConstantRange ConstantRange::signExtend(uint32_t DstTySize) const {
+  assert(!isFloat);
   if (isEmptySet()) return getEmpty(DstTySize);
 
   unsigned SrcTySize = getBitWidth();
   assert(SrcTySize < DstTySize && "Not a value extension");
 
   // special case: [X, INT_MIN) -- not really wrapping around
   if (Upper.isMinSignedValue())
     return ConstantRange(Lower.sext(DstTySize), Upper.zext(DstTySize));
 
   if (isFullSet() || isSignWrappedSet()) {
     return ConstantRange(APInt::getHighBitsSet(DstTySize,DstTySize-SrcTySize+1),
                          APInt::getLowBitsSet(DstTySize, SrcTySize-1) + 1);
   }
 
   return ConstantRange(Lower.sext(DstTySize), Upper.sext(DstTySize));
 }
 
 ConstantRange ConstantRange::truncate(uint32_t DstTySize) const {
+  assert(!isFloat);
   assert(getBitWidth() > DstTySize && "Not a value truncation");
   if (isEmptySet())
     return getEmpty(DstTySize);
   if (isFullSet())
     return getFull(DstTySize);
 
   APInt LowerDiv(Lower), UpperDiv(Upper);
   ConstantRange Union(DstTySize, /*isFullSet=*/false);
if (UpperDiv.ult(LowerDiv))
       return ConstantRange(LowerDiv.trunc(DstTySize),
                            UpperDiv.trunc(DstTySize)).unionWith(Union);
   }
 
   return getFull(DstTySize);
 }
 
 ConstantRange ConstantRange::zextOrTrunc(uint32_t DstTySize) const {
+  assert(!isFloat);
   unsigned SrcTySize = getBitWidth();
   if (SrcTySize > DstTySize)
     return truncate(DstTySize);
   if (SrcTySize < DstTySize)
     return zeroExtend(DstTySize);
   return *this;
 }
 
 ConstantRange ConstantRange::sextOrTrunc(uint32_t DstTySize) const {
+  assert(!isFloat);
   unsigned SrcTySize = getBitWidth();
   if (SrcTySize > DstTySize)
     return truncate(DstTySize);
   if (SrcTySize < DstTySize)
     return signExtend(DstTySize);
   return *this;
 }
 
ConstantRange ConstantRange::binaryOp(Instruction::BinaryOps BinOp,
   case Instruction::AShr:
     return ashr(Other);
   case Instruction::And:
     return binaryAnd(Other);
   case Instruction::Or:
     return binaryOr(Other);
   case Instruction::Xor:
     return binaryXor(Other);
-  // Note: floating point operations applied to abstract ranges are just
-  // ideal integer operations with a lossy representation
   case Instruction::FAdd:
-    return add(Other);
+    if (isFloat) // We don't support vector types
+      return fadd(Other);
+    // Fallthrough
   case Instruction::FSub:
-    return sub(Other);
+    if (isFloat) // We don't support vector types
+      return fsub(Other);
+    // Fallthrough
   case Instruction::FMul:
-    return multiply(Other);
+    if (isFloat) // We don't support vector types
+      return fmultiply(Other);
+    // Fallthrough
+  case Instruction::FDiv:
+    if (isFloat) // We don't support vector types
+      return fdivide(Other);
+    // Fallthrough
   default:
     // Conservatively return getFull set.
     return getFull();
   }
 }
 
 ConstantRange ConstantRange::overflowingBinaryOp(Instruction::BinaryOps BinOp,
                                                  const ConstantRange &Other,
                                                  unsigned NoWrapKind) const {
   assert(Instruction::isBinaryOp(BinOp) && "Binary operators only!");
 
   switch (BinOp) {
   case Instruction::Add:
     return addWithNoWrap(Other, NoWrapKind);
   case Instruction::Sub:
     return subWithNoWrap(Other, NoWrapKind);
   default:
     // Don't know about this Overflowing Binary Operation.
     // Conservatively fallback to plain binop handling.
     return binaryOp(BinOp, Other);
   }
 }
 
 ConstantRange
+ConstantRange::fadd(const ConstantRange &Other) const {
+  assert(isFloat && Other.isFloat);
+  if (isEmptySet() || Other.isEmptySet())
+    return getEmpty();
+
+  // If one of the operands can only be NaN, it propagates.
+  // Even if the other operand is full set.
+  if (isSingleElementFP() && getSingleElementFP()->isNaN())
+    return *this;
+  if (Other.isSingleElementFP() && Other.getSingleElementFP()->isNaN())
+    return Other;
+
+  if (isFullSet() || Other.isFullSet())
+    return getFull();
+
+  // Adding infinities of oposing signs generates NaN
+  APFloat PosInf = APFloat::getInf(LowerFP.getSemantics(), false);
+  APFloat NegInf = APFloat::getInf(LowerFP.getSemantics(), true);
+  bool ResNaN = (contains(PosInf) && Other.contains(NegInf)) ||
+                (contains(NegInf) && Other.contains(PosInf)) ||
+                canBeNaN || Other.canBeNaN;
+
+  if (isUpperWrapped() || Other.isUpperWrapped())
+    return ConstantRange(std::move(NegInf), std::move(PosInf), ResNaN);
+
+  APFloat NewLower = LowerFP;
+  APFloat NewUpper = UpperFP;
+  NewLower.add(Other.LowerFP, APFloat::rmTowardNegative);
+  NewUpper.add(Other.UpperFP, APFloat::rmTowardPositive);
+  // Give up if any boundaries generate NaN
+  if (NewUpper.isNaN() || NewLower.isNaN())
+    return getFull();
+
+  return ConstantRange(std::move(NewLower), std::move(NewUpper), ResNaN);
+}
+
+ConstantRange
 ConstantRange::add(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   if (isFullSet() || Other.isFullSet())
     return getFull();
 
   APInt NewLower = getLower() + Other.getLower();
   APInt NewUpper = getUpper() + Other.getUpper() - 1;
   if (NewLower == NewUpper)
     return getFull();
 
   ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
   if (X.isSizeStrictlySmallerThan(*this) ||
       X.isSizeStrictlySmallerThan(Other))
     // We've wrapped, therefore, full set.
     return getFull();
   return X;
 }
 
 ConstantRange ConstantRange::addWithNoWrap(const ConstantRange &Other,
                                            unsigned NoWrapKind,
                                            PreferredRangeType RangeType) const {
   // Calculate the range for "X + Y" which is guaranteed not to wrap(overflow).
   // (X is from this, and Y is from Other)
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   if (isFullSet() && Other.isFullSet())
     return getFull();
 
   using OBO = OverflowingBinaryOperator;
   ConstantRange Result = add(Other);
 
   // If an overflow happens for every value pair in these two constant ranges,
   // we must return Empty set. In this case, we get that for free, because we
   // get lucky that intersection of add() with uadd_sat()/sadd_sat() results
   // in an empty set.
 
   if (NoWrapKind & OBO::NoSignedWrap)
     Result = Result.intersectWith(sadd_sat(Other), RangeType);
 
   if (NoWrapKind & OBO::NoUnsignedWrap)
     Result = Result.intersectWith(uadd_sat(Other), RangeType);
 
   return Result;
 }
 
 ConstantRange
+ConstantRange::fsub(const ConstantRange &Other) const {
+  assert(isFloat && Other.isFloat);
+  if (isEmptySet() || Other.isEmptySet())
+    return getEmpty();
+
+  // If one of the operands can only be NaN, it propagates.
+  // Even if the other operand is full set.
+  if (isSingleElementFP() && getSingleElementFP()->isNaN())
+    return *this;
+  if (Other.isSingleElementFP() && Other.getSingleElementFP()->isNaN())
+    return Other;
+
+  if (isFullSet() || Other.isFullSet())
+    return getFull();
+
+  // Subtracting infinities of the same sign generates NaN
+  APFloat PosInf = APFloat::getInf(LowerFP.getSemantics(), false);
+  APFloat NegInf = APFloat::getInf(LowerFP.getSemantics(), true);
+  bool ResNaN = (contains(PosInf) && Other.contains(PosInf)) ||
+                (contains(NegInf) && Other.contains(NegInf)) ||
+                canBeNaN || Other.canBeNaN;
+
+  if (isUpperWrapped() || Other.isUpperWrapped())
+    return ConstantRange(std::move(NegInf), std::move(PosInf), ResNaN);
+
+  APFloat NewLower = LowerFP;
+  APFloat NewUpper = UpperFP;
+  NewLower.subtract(Other.UpperFP, APFloat::rmTowardNegative);
+  NewUpper.subtract(Other.LowerFP, APFloat::rmTowardPositive);
+  // Give up if any boundaries generate NaN
+  if (NewUpper.isNaN() || NewLower.isNaN())
+    return getFull();
+
+  return ConstantRange(std::move(NewLower), std::move(NewUpper), ResNaN);
+}
+
+ConstantRange
 ConstantRange::sub(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   if (isFullSet() || Other.isFullSet())
     return getFull();
 
   APInt NewLower = getLower() - Other.getUpper() + 1;
   APInt NewUpper = getUpper() - Other.getLower();
   if (NewLower == NewUpper)
     return getFull();
 
   ConstantRange X = ConstantRange(std::move(NewLower), std::move(NewUpper));
   if (X.isSizeStrictlySmallerThan(*this) ||
       X.isSizeStrictlySmallerThan(Other))
     // We've wrapped, therefore, full set.
     return getFull();
   return X;
 }
 
 ConstantRange ConstantRange::subWithNoWrap(const ConstantRange &Other,
                                            unsigned NoWrapKind,
                                            PreferredRangeType RangeType) const {
   // Calculate the range for "X - Y" which is guaranteed not to wrap(overflow).
   // (X is from this, and Y is from Other)
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   if (isFullSet() && Other.isFullSet())
     return getFull();
 
   using OBO = OverflowingBinaryOperator;
   ConstantRange Result = sub(Other);
 
if (getUnsignedMax().ult(Other.getUnsignedMin()))
       return getEmpty(); // Always overflows.
     Result = Result.intersectWith(usub_sat(Other), RangeType);
   }
 
   return Result;
 }
 
 ConstantRange
+ConstantRange::fdivide(const ConstantRange &Other) const {
+  assert(isFloat && Other.isFloat);
+  if (isEmptySet() || Other.isEmptySet())
+    return getEmpty();
+
+  // If one of the operands can only be NaN, it propagates.
+  // Even if the other operand is full set.
+  if (isSingleElementFP() && getSingleElementFP()->isNaN())
+    return *this;
+  if (Other.isSingleElementFP() && Other.getSingleElementFP()->isNaN())
+    return Other;
+
+  if (isFullSet() || Other.isFullSet())
+    return getFull();
+
+  // Useful constants
+  APFloat PosInf = APFloat::getInf(LowerFP.getSemantics(), false);
+  APFloat NegInf = APFloat::getInf(LowerFP.getSemantics(), true);
+  APFloat PosZero = APFloat::getZero(LowerFP.getSemantics(), false);
+  APFloat NegZero = APFloat::getZero(LowerFP.getSemantics(), true);
+
+  // Dividing Inf/Inf is NaN, as is 0/0
+  auto ContainsInf = [=](const ConstantRange &CR) {
+    return CR.contains(PosInf) || CR.contains(NegInf);
+  };
+  auto ContainsZero = [=](const ConstantRange &CR) {
+    return CR.contains(PosZero) || CR.contains(NegZero);
+  };
+  bool ResNaN = (ContainsInf(*this) && ContainsInf(Other)) ||
+                (ContainsZero(Other) && ContainsZero(*this)) ||
+                canBeNaN || Other.canBeNaN;
+
+  // Division by +/-Zero:
+  // X / 0 == Inf for X > 0, X / -0 == -Inf for X < -0
+  // X / 0 == -Inf for X < -0, X / -0 == Inf for X > 0
+  bool ResPosInf = (Other.contains(PosZero) && (!LowerFP.isNegative() || !UpperFP.isNegative())) ||
+                   (Other.contains(NegZero) && (LowerFP.isNegative() || UpperFP.isNegative()));
+  bool ResNegInf = (Other.contains(PosZero) && (LowerFP.isNegative() || UpperFP.isNegative())) ||
+                   (Other.contains(NegZero) && (!LowerFP.isNegative() || !UpperFP.isNegative()));
+  if (ResPosInf && ResNegInf)
+    return ConstantRange(std::move(NegInf), std::move(PosInf), ResNaN);
+
+  // Division by Inf. Both bounds are Inf except for [-Inf, Inf]
+  if (Other.LowerFP.isInfinity() && Other.UpperFP.isInfinity() &&
+      !(!Other.UpperFP.isNegative() && Other.LowerFP.isNegative())) {
+    // +/-Inf / +/- Inf can only be NaN
+    if (LowerFP.isInfinity() && UpperFP.isInfinity() &&
+        !(!UpperFP.isNegative() && LowerFP.isNegative()))
+      return ConstantRange(APFloat::getNaN(LowerFP.getSemantics()));
+    // 'this' contains other numbers than +/-Inf
+    return ConstantRange(std::move(NegZero), std::move(PosZero), ResNaN);
+  }
+
+  // If upperWrapped ranges have not been handled by now, give up.
+  if (isUpperWrapped() || Other.isUpperWrapped())
+    return ConstantRange(std::move(NegInf), std::move(PosInf), ResNaN);
+
+  APFloat MyBounds[] = {LowerFP, UpperFP};
+  APFloat OtherBounds[] = {Other.LowerFP, Other.UpperFP};
+  APFloat::roundingMode RoundingModes[] = {APFloat::rmTowardNegative, APFloat::rmTowardPositive};
+
+  SmallVector<APFloat, 8> Bounds;
+  for (const auto &MyBound:MyBounds)
+    for (const auto &OtherBound:OtherBounds)
+     for (auto RM:RoundingModes) {
+       APFloat Res = MyBound;
+       Res.divide(OtherBound, RM);
+       if (!Res.isNaN())
+         Bounds.push_back(std::move(Res));
+     }
+  if (ResPosInf)
+    Bounds.push_back(std::move(PosInf));
+  if (ResNegInf)
+    Bounds.push_back(std::move(PosInf));
+  assert(!Bounds.empty());
+  auto CompareMin = [](const APFloat &A, const APFloat &B) {
+    return llvm::minimum(A, B).bitwiseIsEqual(A); };
+  auto CompareMax = [](const APFloat &A, const APFloat &B) {
+    return llvm::maximum(A, B).bitwiseIsEqual(B); };
+  return ConstantRange(*std::min_element(Bounds.begin(), Bounds.end(), CompareMin),
+                       *std::max_element(Bounds.begin(), Bounds.end(), CompareMax), ResNaN);
+}
+
+ConstantRange
+ConstantRange::fmultiply(const ConstantRange &Other) const {
+  assert(isFloat && Other.isFloat);
+  if (isEmptySet() || Other.isEmptySet())
+    return getEmpty();
+
+  // If one of the operands can only be NaN, it propagates.
+  // Even if the other operand is full set.
+  if (isSingleElementFP() && getSingleElementFP()->isNaN())
+    return *this;
+  if (Other.isSingleElementFP() && Other.getSingleElementFP()->isNaN())
+    return Other;
+
+  // Full set includes infinities. Multiplying inf results in +/-inf so just
+  // return another full set
+  if (isFullSet() || Other.isFullSet())
+    return getFull();
+
+  // Useful constants
+  APFloat PosInf = APFloat::getInf(LowerFP.getSemantics(), false);
+  APFloat NegInf = APFloat::getInf(LowerFP.getSemantics(), true);
+  APFloat PosZero = APFloat::getZero(LowerFP.getSemantics(), false);
+  APFloat NegZero = APFloat::getZero(LowerFP.getSemantics(), true);
+
+  // Handle special cases, where multiplying boudnaries doesn't work:
+  // [-Inf, 0] * [-Inf, 0] -- produces [0, Inf] instead of [-0, Inf]
+  // [-Inf, 0] * [-0, Inf] -- produces [-Inf, -0] instead of [-Inf, 0]
+  // [-0, Inf] * [-Inf, 0] -- produces [-Inf, -0] instead of [-Inf, 0]
+  // [-0, Inf] * [-0, Inf] -- produces [0, Inf] instead of [-0, Inf]
+  auto IsNegZeroPosInf = [](const ConstantRange &CR) {
+    return CR.LowerFP.isNegZero() && CR.UpperFP.isInfinity() && !CR.UpperFP.isNegative();
+  };
+  auto IsNegInfPosZero = [](const ConstantRange &CR) {
+    return CR.UpperFP.isPosZero() && CR.LowerFP.isInfinity() && CR.LowerFP.isNegative();
+  };
+  if ((IsNegInfPosZero(*this) && IsNegZeroPosInf(Other)) ||
+      (IsNegZeroPosInf(*this) && IsNegInfPosZero(Other)))
+    return ConstantRange(std::move(NegInf), std::move(PosZero), true);
+  if ((IsNegZeroPosInf(*this) && IsNegZeroPosInf(Other)) ||
+      (IsNegInfPosZero(*this) && IsNegInfPosZero(Other)))
+    return ConstantRange(std::move(NegZero), std::move(PosInf), true);
+
+  // Multiplying any zero by any inf produces NaN
+  auto ContainsInf = [=](const ConstantRange &CR) {
+    return CR.contains(PosInf) || CR.contains(NegInf);
+  };
+  auto ContainsZero = [=](const ConstantRange &CR) {
+    return CR.contains(PosZero) || CR.contains(NegZero);
+  };
+  bool ResNaN = (ContainsZero(*this) && ContainsInf(Other)) ||
+                (ContainsZero(Other) && ContainsInf(*this)) ||
+                canBeNaN || Other.canBeNaN;
+
+  // Multiplication by +/-Zero: Inf * 0 is NaN, any other value * 0 is +/-0
+  // This conservatively includes both zeros.
+  if ((LowerFP.isZero() && UpperFP.isZero()) ||
+      (Other.LowerFP.isZero() && Other.UpperFP.isZero()))
+      return ConstantRange(std::move(NegZero), std::move(PosZero), ResNaN);
+
+  // If upperWrapped ranges have not been handled by now, give up.
+  if (isUpperWrapped() || Other.isUpperWrapped())
+    return ConstantRange(std::move(NegInf), std::move(PosInf), ResNaN);
+
+  APFloat MyBounds[] = {LowerFP, UpperFP};
+  APFloat OtherBounds[] = {Other.LowerFP, Other.UpperFP};
+  APFloat::roundingMode RoundingModes[] = {APFloat::rmTowardNegative, APFloat::rmTowardPositive};
+
+  SmallVector<APFloat, 8> Bounds;
+  for (const auto &MyBound:MyBounds)
+    for (const auto &OtherBound:OtherBounds)
+     for (auto RM:RoundingModes) {
+       APFloat Res = MyBound;
+       Res.multiply(OtherBound, RM);
+       if (!Res.isNaN())
+         Bounds.push_back(std::move(Res));
+     }
+  assert(!Bounds.empty());
+
+  auto CompareMin = [](const APFloat &A, const APFloat &B) {
+    return llvm::minimum(A, B).bitwiseIsEqual(A); };
+  auto CompareMax = [](const APFloat &A, const APFloat &B) {
+    return llvm::maximum(A, B).bitwiseIsEqual(B); };
+  return ConstantRange(*std::min_element(Bounds.begin(), Bounds.end(), CompareMin),
+                       *std::max_element(Bounds.begin(), Bounds.end(), CompareMax), ResNaN);
+}
+
+ConstantRange
 ConstantRange::multiply(const ConstantRange &Other) const {
   // TODO: If either operand is a single element and the multiply is known to
   // be non-wrapping, round the result min and max value to the appropriate
   // multiple of that element. If wrapping is possible, at least adjust the
   // range according to the greatest power-of-two factor of the single element.
 
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   // Multiplication is signedness-independent. However different ranges can be
   // obtained depending on how the input ranges are treated. These different
   // ranges are all conservatively correct, but one might be better than the
   // other. We calculate two ranges; one treating the inputs as unsigned
   // and the other signed, then return the smallest of these ranges.
ConstantRange::multiply(const ConstantRange &Other) const {
   auto Compare = [](const APInt &A, const APInt &B) { return A.slt(B); };
   ConstantRange Result_sext(std::min(L, Compare), std::max(L, Compare) + 1);
   ConstantRange SR = Result_sext.truncate(getBitWidth());
 
   return UR.isSizeStrictlySmallerThan(SR) ? UR : SR;
 }
 
 ConstantRange
+ConstantRange::fmax(const ConstantRange &Other) const {
+  assert(isFloat);
+  if (isEmptySet() || Other.isEmptySet())
+    return getEmpty();
+  // X fmax Y is: range(fmax(X_smin, Y_smin), fmax(X_smax, Y_smax))
+  if (!isUpperWrapped() && !Other.isUpperWrapped())
+    return ConstantRange(maximum(LowerFP, Other.LowerFP),
+                         maximum(UpperFP, Other.UpperFP),
+                         canBeNaN || Other.canBeNaN);
+
+  if (!isUpperWrapped() && Other.isUpperWrapped())
+    return Other.fmax(*this);
+
+  // Handle NaN explicitly
+  if (Other.LowerFP.isNaN())
+    return ConstantRange(LowerFP, UpperFP, true);
+  // If a range is upper wrapped it includes -Inf.
+  // This results in all numbers from the other range to appear in the results.
+  if (isUpperWrapped() && !Other.isUpperWrapped())
+    return ConstantRange(Other.LowerFP, APFloat::getInf(UpperFP.getSemantics()),
+                         canBeNaN || Other.canBeNaN);
+  return unionWith(Other);
+}
+
+ConstantRange
+ConstantRange::fmin(const ConstantRange &Other) const {
+  assert(isFloat && Other.isFloat);
+  if (isEmptySet() || Other.isEmptySet())
+    return getEmpty();
+  // X fmin Y is: range(fmin(X_smin, Y_smin), fmin(X_smax, Y_smax))
+  if (!isUpperWrapped() && !Other.isUpperWrapped())
+    return ConstantRange(minimum(LowerFP, Other.LowerFP),
+                         minimum(UpperFP, Other.UpperFP),
+                         canBeNaN || Other.canBeNaN);
+  if (!isUpperWrapped() && Other.isUpperWrapped())
+    return Other.fmin(*this);
+
+  // Handle NaN explicitly
+  if (Other.LowerFP.isNaN())
+    return ConstantRange(LowerFP, UpperFP, true);
+  // If a range is upper wrapped it includes Inf.
+  // This results in all numbers from the other range to appear in the results.
+  if (isUpperWrapped() && !Other.isUpperWrapped())
+    return ConstantRange(APFloat::getInf(UpperFP.getSemantics(), true),
+                         Other.UpperFP, canBeNaN || Other.canBeNaN);
+  return unionWith(Other);
+}
+
+ConstantRange
 ConstantRange::smax(const ConstantRange &Other) const {
   // X smax Y is: range(smax(X_smin, Y_smin),
   //                    smax(X_smax, Y_smax))
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   APInt NewL = APIntOps::smax(getSignedMin(), Other.getSignedMin());
   APInt NewU = APIntOps::smax(getSignedMax(), Other.getSignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange
 ConstantRange::umax(const ConstantRange &Other) const {
   // X umax Y is: range(umax(X_umin, Y_umin),
   //                    umax(X_umax, Y_umax))
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   APInt NewL = APIntOps::umax(getUnsignedMin(), Other.getUnsignedMin());
   APInt NewU = APIntOps::umax(getUnsignedMax(), Other.getUnsignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange
 ConstantRange::smin(const ConstantRange &Other) const {
   // X smin Y is: range(smin(X_smin, Y_smin),
   //                    smin(X_smax, Y_smax))
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   APInt NewL = APIntOps::smin(getSignedMin(), Other.getSignedMin());
   APInt NewU = APIntOps::smin(getSignedMax(), Other.getSignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange
 ConstantRange::umin(const ConstantRange &Other) const {
   // X umin Y is: range(umin(X_umin, Y_umin),
   //                    umin(X_umax, Y_umax))
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
   APInt NewL = APIntOps::umin(getUnsignedMin(), Other.getUnsignedMin());
   APInt NewU = APIntOps::umin(getUnsignedMax(), Other.getUnsignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange
 ConstantRange::udiv(const ConstantRange &RHS) const {
+  assert(!isFloat);
   if (isEmptySet() || RHS.isEmptySet() || RHS.getUnsignedMax().isNullValue())
     return getEmpty();
 
   APInt Lower = getUnsignedMin().udiv(RHS.getUnsignedMax());
 
   APInt RHS_umin = RHS.getUnsignedMin();
   if (RHS_umin.isNullValue()) {
     // We want the lowest value in RHS excluding zero. Usually that would be 1
     // except for a range in the form of [X, 1) in which case it would be X.
     if (RHS.getUpper() == 1)
       RHS_umin = RHS.getLower();
     else
       RHS_umin = 1;
   }
 
   APInt Upper = getUnsignedMax().udiv(RHS_umin) + 1;
   return getNonEmpty(std::move(Lower), std::move(Upper));
 }
 
 ConstantRange ConstantRange::sdiv(const ConstantRange &RHS) const {
   // We split up the LHS and RHS into positive and negative components
   // and then also compute the positive and negative components of the result
   // separately by combining division results with the appropriate signs.
+  assert(!isFloat);
   APInt Zero = APInt::getNullValue(getBitWidth());
   APInt SignedMin = APInt::getSignedMinValue(getBitWidth());
   ConstantRange PosFilter(APInt(getBitWidth(), 1), SignedMin);
   ConstantRange NegFilter(SignedMin, Zero);
   ConstantRange PosL = intersectWith(PosFilter);
   ConstantRange NegL = intersectWith(NegFilter);
   ConstantRange PosR = RHS.intersectWith(PosFilter);
   ConstantRange NegR = RHS.intersectWith(NegFilter);
ConstantRange ConstantRange::sdiv(const ConstantRange &RHS) const {
 
   // Preserve the zero that we dropped when splitting the LHS by sign.
   if (contains(Zero) && (!PosR.isEmptySet() || !NegR.isEmptySet()))
     Res = Res.unionWith(ConstantRange(Zero));
   return Res;
 }
 
 ConstantRange ConstantRange::urem(const ConstantRange &RHS) const {
+  assert(!isFloat);
   if (isEmptySet() || RHS.isEmptySet() || RHS.getUnsignedMax().isNullValue())
     return getEmpty();
 
   // L % R for L < R is L.
   if (getUnsignedMax().ult(RHS.getUnsignedMin()))
     return *this;
 
   // L % R is <= L and < R.
   APInt Upper = APIntOps::umin(getUnsignedMax(), RHS.getUnsignedMax() - 1) + 1;
   return getNonEmpty(APInt::getNullValue(getBitWidth()), std::move(Upper));
 }
 
 ConstantRange ConstantRange::srem(const ConstantRange &RHS) const {
+  assert(!isFloat);
   if (isEmptySet() || RHS.isEmptySet())
     return getEmpty();
 
   ConstantRange AbsRHS = RHS.abs();
   APInt MinAbsRHS = AbsRHS.getUnsignedMin();
   APInt MaxAbsRHS = AbsRHS.getUnsignedMax();
 
   // Modulus by zero is UB.
ConstantRange ConstantRange::srem(const ConstantRange &RHS) const {
   // LHS range crosses zero.
   APInt Lower = APIntOps::umax(MinLHS, -MaxAbsRHS + 1);
   APInt Upper = APIntOps::umin(MaxLHS, MaxAbsRHS - 1) + 1;
   return ConstantRange(std::move(Lower), std::move(Upper));
 }
 
 ConstantRange
 ConstantRange::binaryAnd(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   // Use APInt's implementation of AND for single element ranges.
   if (isSingleElement() && Other.isSingleElement())
     return {*getSingleElement() & *Other.getSingleElement()};
 
   // TODO: replace this with something less conservative
 
   APInt umin = APIntOps::umin(Other.getUnsignedMax(), getUnsignedMax());
   return getNonEmpty(APInt::getNullValue(getBitWidth()), std::move(umin) + 1);
 }
 
 ConstantRange
 ConstantRange::binaryOr(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   // Use APInt's implementation of OR for single element ranges.
   if (isSingleElement() && Other.isSingleElement())
     return {*getSingleElement() | *Other.getSingleElement()};
 
   // TODO: replace this with something less conservative
if (isSingleElement() && Other.isSingleElement())
     return {*getSingleElement() ^ *Other.getSingleElement()};
 
   // TODO: replace this with something less conservative
   return getFull();
 }
 
 ConstantRange
 ConstantRange::shl(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt max = getUnsignedMax();
   APInt Other_umax = Other.getUnsignedMax();
 
   // If we are shifting by maximum amount of
   // zero return return the original range.
ConstantRange::shl(const ConstantRange &Other) const {
   min <<= Other.getUnsignedMin();
   max <<= Other_umax;
 
   return ConstantRange(std::move(min), std::move(max) + 1);
 }
 
 ConstantRange
 ConstantRange::lshr(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt max = getUnsignedMax().lshr(Other.getUnsignedMin()) + 1;
   APInt min = getUnsignedMin().lshr(Other.getUnsignedMax());
   return getNonEmpty(std::move(min), std::move(max));
 }
 
 ConstantRange
 ConstantRange::ashr(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   // May straddle zero, so handle both positive and negative cases.
   // 'PosMax' is the upper bound of the result of the ashr
   // operation, when Upper of the LHS of ashr is a non-negative.
   // number. Since ashr of a non-negative number will result in a
   // smaller number, the Upper value of LHS is shifted right with
if (getSignedMin().isNonNegative()) {
     // Upper is non-negative and Lower is negative.
     min = NegMin;
     max = PosMax;
   }
   return getNonEmpty(std::move(min), std::move(max));
 }
 
 ConstantRange ConstantRange::uadd_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt NewL = getUnsignedMin().uadd_sat(Other.getUnsignedMin());
   APInt NewU = getUnsignedMax().uadd_sat(Other.getUnsignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::sadd_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt NewL = getSignedMin().sadd_sat(Other.getSignedMin());
   APInt NewU = getSignedMax().sadd_sat(Other.getSignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::usub_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt NewL = getUnsignedMin().usub_sat(Other.getUnsignedMax());
   APInt NewU = getUnsignedMax().usub_sat(Other.getUnsignedMin()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::ssub_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt NewL = getSignedMin().ssub_sat(Other.getSignedMax());
   APInt NewU = getSignedMax().ssub_sat(Other.getSignedMin()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::umul_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt NewL = getUnsignedMin().umul_sat(Other.getUnsignedMin());
   APInt NewU = getUnsignedMax().umul_sat(Other.getUnsignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::smul_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   // Because we could be dealing with negative numbers here, the lower bound is
   // the smallest of the cartesian product of the lower and upper ranges;
   // for example:
   //   [-1,4) * [-2,3) = min(-1*-2, -1*2, 3*-2, 3*2) = -6.
   // Similarly for the upper bound, swapping min for max.
ConstantRange ConstantRange::smul_sat(const ConstantRange &Other) const {
   // Note that we wanted to perform signed saturating multiplication,
   // so since we performed plain multiplication in twice the bitwidth,
   // we need to perform signed saturating truncation.
   return getNonEmpty(std::min(L, Compare).truncSSat(getBitWidth()),
                      std::max(L, Compare).truncSSat(getBitWidth()) + 1);
 }
 
 ConstantRange ConstantRange::ushl_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt NewL = getUnsignedMin().ushl_sat(Other.getUnsignedMin());
   APInt NewU = getUnsignedMax().ushl_sat(Other.getUnsignedMax()) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::sshl_sat(const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return getEmpty();
 
   APInt Min = getSignedMin(), Max = getSignedMax();
   APInt ShAmtMin = Other.getUnsignedMin(), ShAmtMax = Other.getUnsignedMax();
   APInt NewL = Min.sshl_sat(Min.isNonNegative() ? ShAmtMin : ShAmtMax);
   APInt NewU = Max.sshl_sat(Max.isNegative() ? ShAmtMin : ShAmtMax) + 1;
   return getNonEmpty(std::move(NewL), std::move(NewU));
 }
 
 ConstantRange ConstantRange::inverse() const {
   if (isFullSet())
     return getEmpty();
   if (isEmptySet())
     return getFull();
+
+  if (!isFloat)
     return ConstantRange(Upper, Lower);
+
+  // Handle 'almost full' range
+  if (LowerFP.isNegative() && LowerFP.isInfinity() && !UpperFP.isNegative() && UpperFP.isInfinity())
+    return APFloat::getNaN(LowerFP.getSemantics());
+
+  APFloat NewLower = UpperFP;
+  if ((NewLower.isInfinity() && !NewLower.isNegative()) || NewLower.isNaN())
+    NewLower = APFloat::getInf(LowerFP.getSemantics(), true);
+  else
+    NewLower = ZeroNext(NewLower, false);
+
+  APFloat NewUpper = LowerFP;
+  if ((NewUpper.isInfinity() && NewUpper.isNegative()) || NewUpper.isNaN())
+    NewUpper = APFloat::getInf(UpperFP.getSemantics(), false);
+  else
+    NewUpper = ZeroNext(NewUpper, true);
+
+  return ConstantRange(::std::move(NewLower), ::std::move(NewUpper), !canBeNaN);
 }
 
 ConstantRange ConstantRange::abs() const {
+  assert(!isFloat);
   if (isEmptySet())
     return getEmpty();
 
   if (isSignWrappedSet()) {
     APInt Lo;
     // Check whether the range crosses zero.
     if (Upper.isStrictlyPositive() || !Lower.isStrictlyPositive())
       Lo = APInt::getNullValue(getBitWidth());
ConstantRange ConstantRange::abs() const {
 
   // Range crosses zero.
   return ConstantRange(APInt::getNullValue(getBitWidth()),
                        APIntOps::umax(-SMin, SMax) + 1);
 }
 
 ConstantRange::OverflowResult ConstantRange::unsignedAddMayOverflow(
     const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return OverflowResult::MayOverflow;
 
   APInt Min = getUnsignedMin(), Max = getUnsignedMax();
   APInt OtherMin = Other.getUnsignedMin(), OtherMax = Other.getUnsignedMax();
 
   // a u+ b overflows high iff a u> ~b.
   if (Min.ugt(~OtherMin))
     return OverflowResult::AlwaysOverflowsHigh;
   if (Max.ugt(~OtherMax))
     return OverflowResult::MayOverflow;
   return OverflowResult::NeverOverflows;
 }
 
 ConstantRange::OverflowResult ConstantRange::signedAddMayOverflow(
     const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return OverflowResult::MayOverflow;
 
   APInt Min = getSignedMin(), Max = getSignedMax();
   APInt OtherMin = Other.getSignedMin(), OtherMax = Other.getSignedMax();
 
   APInt SignedMin = APInt::getSignedMinValue(getBitWidth());
   APInt SignedMax = APInt::getSignedMaxValue(getBitWidth());
if (Min.isNegative() && OtherMin.isNegative() &&
       Min.slt(SignedMin - OtherMin))
     return OverflowResult::MayOverflow;
 
   return OverflowResult::NeverOverflows;
 }
 
 ConstantRange::OverflowResult ConstantRange::unsignedSubMayOverflow(
     const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return OverflowResult::MayOverflow;
 
   APInt Min = getUnsignedMin(), Max = getUnsignedMax();
   APInt OtherMin = Other.getUnsignedMin(), OtherMax = Other.getUnsignedMax();
 
   // a u- b overflows low iff a u< b.
   if (Max.ult(OtherMin))
     return OverflowResult::AlwaysOverflowsLow;
   if (Min.ult(OtherMax))
     return OverflowResult::MayOverflow;
   return OverflowResult::NeverOverflows;
 }
 
 ConstantRange::OverflowResult ConstantRange::signedSubMayOverflow(
     const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return OverflowResult::MayOverflow;
 
   APInt Min = getSignedMin(), Max = getSignedMax();
   APInt OtherMin = Other.getSignedMin(), OtherMax = Other.getSignedMax();
 
   APInt SignedMin = APInt::getSignedMinValue(getBitWidth());
   APInt SignedMax = APInt::getSignedMaxValue(getBitWidth());
if (Min.isNegative() && OtherMax.isNonNegative() &&
       Min.slt(SignedMin + OtherMax))
     return OverflowResult::MayOverflow;
 
   return OverflowResult::NeverOverflows;
 }
 
 ConstantRange::OverflowResult ConstantRange::unsignedMulMayOverflow(
     const ConstantRange &Other) const {
+  assert(!isFloat);
   if (isEmptySet() || Other.isEmptySet())
     return OverflowResult::MayOverflow;
 
   APInt Min = getUnsignedMin(), Max = getUnsignedMax();
   APInt OtherMin = Other.getUnsignedMin(), OtherMax = Other.getUnsignedMax();
   bool Overflow;
 
   (void) Min.umul_ov(OtherMin, Overflow);
   if (Overflow)
     return OverflowResult::AlwaysOverflowsHigh;
 
   (void) Max.umul_ov(OtherMax, Overflow);
   if (Overflow)
     return OverflowResult::MayOverflow;
 
   return OverflowResult::NeverOverflows;
 }
 
 void ConstantRange::print(raw_ostream &OS) const {
   if (isFullSet())
-    OS << "full-set";
+    OS << (isFloat ? "full-set-fp" : "full-set");
   else if (isEmptySet())
-    OS << "empty-set";
+    OS << (isFloat ? "empty-set-fp" : "empty-set");
   else
+    if (isFloat) {
+      SmallVector<char, 16> Lo, Up;
+      LowerFP.toString(Lo);
+      UpperFP.toString(Up);
+      OS << "[" << Lo << ", " << Up << "]";
+      if (LowerFP.bitwiseIsEqual(UpperFP))
+        OS << "*";
+      if (canBeNaN)
+        OS << " or NaN";
+    } else
       OS << "[" << Lower << "," << Upper << ")";
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void ConstantRange::dump() const {
   print(dbgs());
 }
 #endif
 

llvm/unittests/IR/ConstantRangeTest.cpp

 //===- ConstantRangeTest.cpp - ConstantRange tests ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+#include <cmath>
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/KnownBits.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 class ConstantRangeTest : public ::testing::Test {
 protected:
   static ConstantRange Full;
   static ConstantRange Empty;
   static ConstantRange One;
   static ConstantRange Some;
   static ConstantRange Wrap;
+  static ConstantRange NaNFP;
+  static ConstantRange FullFP;
+  static ConstantRange EmptyFP;
+  static ConstantRange OneFP;
+  static ConstantRange SomeFP;
+  static ConstantRange ZeroFP;
+  static ConstantRange NegZeroFP;
+  static ConstantRange WrapFP;
+  static ConstantRange InfFP;
 };
 
 template<typename Fn>
 static void EnumerateConstantRanges(unsigned Bits, Fn TestFn) {
   unsigned Max = 1 << Bits;
   for (unsigned Lo = 0; Lo < Max; Lo++) {
     for (unsigned Hi = 0; Hi < Max; Hi++) {
       // Enforce ConstantRange invariant.
EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
     if (CorrectnessOnly) {
       EXPECT_TRUE(CR.contains(Exact));
     } else {
       EXPECT_EQ(Exact, CR);
     }
   });
 }
 
+static APFloat advanceFP(const APFloat &F, unsigned ExpDiff) {
+  // Check special cases first
+  if (F.isNegZero())
+    return APFloat::getZero(F.getSemantics(), false);
+  if (F.isPosZero())
+    return APFloat::getSmallest(F.getSemantics(), false);
+  if (F.isNegative() && F.isInfinity())
+    return APFloat::getLargest(F.getSemantics(), true);
+  if (!F.isNegative() && F.isInfinity())
+    return APFloat::getInf(F.getSemantics(), true);
+
+  assert(&F.getSemantics() == &APFloat::IEEEsingle());
+  APFloat Coef(std::exp2f((127 - ExpDiff)));
+  if (F.isNegative())
+    return F / Coef;
+  else
+    return F * Coef;
+}
+
+template<typename Fn>
+static void EnumerateConstantRangesFP(unsigned ExpDiff, Fn TestFn) {
+  APFloat PosInf = APFloat::getInf(APFloat::IEEEsingle(), false);
+  APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
+  for (APFloat Lo = NegInf; Lo < PosInf; Lo = advanceFP(Lo, ExpDiff)) {
+    for (APFloat Hi = NegInf; Hi < PosInf; Hi = advanceFP(Hi, ExpDiff)) {
+      // Test with NaN
+      ConstantRange CR1(Lo, Hi, true);
+      TestFn(CR1);
+      // Test without NaN
+      ConstantRange CR2(Lo, Hi, false);
+      TestFn(CR2);
+    }
+    // Test PosInf with NaN
+    ConstantRange CR1(Lo, PosInf, true);
+    TestFn(CR1);
+    // Test PosInf without NaN
+    ConstantRange CR2(Lo, PosInf, false);
+    TestFn(CR2);
+  }
+  // Lo == PosInf is not enumerated above
+  for (APFloat Hi = NegInf; Hi < PosInf; Hi = advanceFP(Hi, ExpDiff)) {
+    // Test with NaN
+    ConstantRange CR1(PosInf, Hi, true);
+    TestFn(CR1);
+    // Test without NaN
+    ConstantRange CR2(PosInf, Hi, false);
+    TestFn(CR2);
+  }
+  // Lo == PosInf, Hi == PosInf
+  // Test with NaN
+  ConstantRange CR1(PosInf, PosInf, true);
+  TestFn(CR1);
+  // Test without NaN
+  ConstantRange CR2(PosInf, PosInf, false);
+  TestFn(CR2);
+
+  // Test only NaN
+  APFloat NaN = APFloat::getNaN(APFloat::IEEEsingle());
+  ConstantRange CR3(NaN, NaN, true);
+  TestFn(CR3);
+}
+
+template<typename Fn>
+static void EnumerateTwoConstantRangesFP(unsigned ExpDiff, Fn TestFn) {
+  EnumerateConstantRangesFP(ExpDiff, [&](const ConstantRange &CR1) {
+    EnumerateConstantRangesFP(ExpDiff, [&](const ConstantRange &CR2) {
+      TestFn(CR1, CR2);
+    });
+  });
+}
+
+template<typename Fn>
+static void ForeachNumInConstantRangeFP(const ConstantRange &CR, unsigned ExpDiff, Fn TestFn) {
+  if (!CR.isEmptySet()) {
+    APFloat N = CR.getLowerFP();
+    for (;!N.bitwiseIsEqual(CR.getUpperFP()); N = advanceFP(N, ExpDiff)) {
+      TestFn(N);
+    }
+    // Test the upper bound
+    TestFn(CR.getUpperFP());
+    // Test NaN if it's allowed in the range
+    if (CR.getCanBeNaN())
+      TestFn(APFloat::getNaN(N.getSemantics()));
+  }
+}
+
 ConstantRange ConstantRangeTest::Full(16, true);
 ConstantRange ConstantRangeTest::Empty(16, false);
 ConstantRange ConstantRangeTest::One(APInt(16, 0xa));
 ConstantRange ConstantRangeTest::Some(APInt(16, 0xa), APInt(16, 0xaaa));
 ConstantRange ConstantRangeTest::Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
 
+ConstantRange ConstantRangeTest::NaNFP(APFloat::getNaN(APFloat::IEEEsingle()), APFloat::getNaN(APFloat::IEEEsingle()), true);
+ConstantRange ConstantRangeTest::EmptyFP(APFloat::getNaN(APFloat::IEEEsingle()), APFloat::getNaN(APFloat::IEEEsingle()), false);
+ConstantRange ConstantRangeTest::FullFP(APFloat::getInf(APFloat::IEEEsingle(), true), APFloat::getInf(APFloat::IEEEsingle(), false), true);
+ConstantRange ConstantRangeTest::OneFP(APFloat(10.0f));
+ConstantRange ConstantRangeTest::ZeroFP(APFloat(0.0f));
+ConstantRange ConstantRangeTest::NegZeroFP(APFloat(-0.0f));
+ConstantRange ConstantRangeTest::SomeFP(APFloat(10.0f), APFloat(100.0f), false);
+ConstantRange ConstantRangeTest::WrapFP(APFloat(100.0f), APFloat(10.0f), false);
+ConstantRange ConstantRangeTest::InfFP(APFloat::getInf(APFloat::IEEEsingle(), true), APFloat::getInf(APFloat::IEEEsingle(), false), false);
+
 TEST_F(ConstantRangeTest, Basics) {
   EXPECT_TRUE(Full.isFullSet());
   EXPECT_FALSE(Full.isEmptySet());
   EXPECT_TRUE(Full.inverse().isEmptySet());
   EXPECT_FALSE(Full.isWrappedSet());
   EXPECT_TRUE(Full.contains(APInt(16, 0x0)));
   EXPECT_TRUE(Full.contains(APInt(16, 0x9)));
   EXPECT_TRUE(Full.contains(APInt(16, 0xa)));
TEST_F(ConstantRangeTest, Basics) {
   EXPECT_TRUE(Wrap.isWrappedSet());
   EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));
   EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));
   EXPECT_FALSE(Wrap.contains(APInt(16, 0xa)));
   EXPECT_FALSE(Wrap.contains(APInt(16, 0xaa9)));
   EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));
 }
 
+TEST_F(ConstantRangeTest, BasicsFP) {
+  EXPECT_TRUE(FullFP.isFullSet());
+  EXPECT_FALSE(FullFP.isEmptySet());
+  EXPECT_TRUE(FullFP.getIsFloat());
+  EXPECT_TRUE(FullFP.getCanBeNaN());
+  EXPECT_FALSE(FullFP.isWrappedSet());
+  EXPECT_TRUE(FullFP.inverse().isEmptySet());
+  EXPECT_TRUE(FullFP.contains(APFloat(0.0f)));
+  EXPECT_TRUE(FullFP.contains(APFloat(0.9f)));
+  EXPECT_TRUE(FullFP.contains(APFloat(10.0f)));
+  EXPECT_TRUE(FullFP.contains(APFloat(1000.0f)));
+  EXPECT_TRUE(FullFP.contains(APFloat(-1000.0f)));
+  EXPECT_TRUE(FullFP.contains(APFloat::getNaN(APFloat::IEEEsingle())));
+  EXPECT_TRUE(FullFP.contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_TRUE(FullFP.contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+
+  EXPECT_FALSE(EmptyFP.isFullSet());
+  EXPECT_TRUE(EmptyFP.isEmptySet());
+  EXPECT_TRUE(EmptyFP.getIsFloat());
+  EXPECT_TRUE(EmptyFP.inverse().isFullSet());
+  EXPECT_FALSE(EmptyFP.getCanBeNaN());
+  EXPECT_FALSE(Empty.isWrappedSet());
+  EXPECT_FALSE(EmptyFP.contains(APFloat(0.0f)));
+  EXPECT_FALSE(EmptyFP.contains(APFloat(9.0f)));
+  EXPECT_FALSE(EmptyFP.contains(APFloat(10.0f)));
+  EXPECT_FALSE(EmptyFP.contains(APFloat(1000.0f)));
+  EXPECT_FALSE(EmptyFP.contains(APFloat(-1000.0f)));
+  EXPECT_FALSE(EmptyFP.contains(NaNFP));
+  EXPECT_FALSE(EmptyFP.contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_FALSE(EmptyFP.contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+
+  EXPECT_FALSE(OneFP.isFullSet());
+  EXPECT_FALSE(OneFP.isEmptySet());
+  EXPECT_TRUE(OneFP.getIsFloat());
+  EXPECT_TRUE(OneFP.isSingleElementFP());
+  EXPECT_FALSE(OneFP.getCanBeNaN());
+  EXPECT_FALSE(OneFP.isWrappedSet());
+  EXPECT_FALSE(OneFP.contains(APFloat(0.0f)));
+  EXPECT_FALSE(OneFP.contains(APFloat(0.0f)));
+  EXPECT_TRUE(OneFP.contains(APFloat(10.0f)));
+  EXPECT_FALSE(OneFP.inverse().contains(APFloat(10.0f)));
+  EXPECT_FALSE(OneFP.contains(APFloat(1000.0f)));
+  EXPECT_FALSE(OneFP.contains(APFloat(-1000.0f)));
+  EXPECT_FALSE(OneFP.contains(NaNFP));
+  EXPECT_FALSE(OneFP.contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_FALSE(OneFP.contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+
+  EXPECT_FALSE(ZeroFP.contains(APFloat(-0.0f)));
+  EXPECT_FALSE(NegZeroFP.contains(APFloat(0.0f)));
+  EXPECT_TRUE(ZeroFP.contains(APFloat(0.0f)));
+  EXPECT_TRUE(NegZeroFP.contains(APFloat(-0.0f)));
+
+  EXPECT_FALSE(SomeFP.isFullSet());
+  EXPECT_FALSE(SomeFP.isEmptySet());
+  EXPECT_TRUE(SomeFP.getIsFloat());
+  EXPECT_FALSE(SomeFP.getCanBeNaN());
+  EXPECT_FALSE(SomeFP.isWrappedSet());
+  EXPECT_FALSE(SomeFP.contains(APFloat(0.0f)));
+  EXPECT_FALSE(SomeFP.contains(APFloat(9.0f)));
+  EXPECT_TRUE(SomeFP.contains(APFloat(10.0f)));
+  EXPECT_TRUE(SomeFP.contains(APFloat(100.0f)));
+  EXPECT_FALSE(SomeFP.contains(APFloat(10000.0f)));
+  EXPECT_FALSE(SomeFP.contains(NaNFP));
+  EXPECT_FALSE(SomeFP.contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_FALSE(SomeFP.contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+
+  EXPECT_FALSE(WrapFP.isFullSet());
+  EXPECT_FALSE(WrapFP.isEmptySet());
+  EXPECT_TRUE(WrapFP.getIsFloat());
+  EXPECT_FALSE(WrapFP.getCanBeNaN());
+  EXPECT_TRUE(WrapFP.isWrappedSet());
+  EXPECT_TRUE(WrapFP.contains(APFloat(0.0f)));
+  EXPECT_TRUE(WrapFP.contains(APFloat(9.0f)));
+  EXPECT_FALSE(WrapFP.contains(APFloat(10.1f)));
+  EXPECT_FALSE(WrapFP.contains(APFloat(99.9f)));
+  EXPECT_TRUE(WrapFP.contains(APFloat(1000.0f)));
+  EXPECT_FALSE(WrapFP.contains(NaNFP));
+  EXPECT_TRUE(WrapFP.contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_TRUE(WrapFP.contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+
+  EXPECT_FALSE(NaNFP.isFullSet());
+  EXPECT_FALSE(NaNFP.isEmptySet());
+  EXPECT_TRUE(NaNFP.getCanBeNaN());
+  EXPECT_TRUE(NaNFP.getIsFloat());
+  EXPECT_TRUE(NaNFP.isSingleElementFP());
+  EXPECT_TRUE(NaNFP.getSingleElementFP()->isNaN());
+  EXPECT_FALSE(NaNFP.inverse().getCanBeNaN());
+  EXPECT_TRUE(NaNFP.inverse().contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+  EXPECT_TRUE(NaNFP.inverse().contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_TRUE(NaNFP.inverse().contains(APFloat(0.0f)));
+  EXPECT_FALSE(NaNFP.isWrappedSet());
+  EXPECT_FALSE(NaNFP.contains(APFloat(0.0f)));
+  EXPECT_FALSE(NaNFP.contains(APFloat(9.0f)));
+  EXPECT_FALSE(NaNFP.contains(APFloat(10.0f)));
+  EXPECT_FALSE(NaNFP.contains(APFloat(100.0f)));
+  EXPECT_FALSE(NaNFP.contains(APFloat(1000.0f)));
+  EXPECT_TRUE(NaNFP.contains(APFloat::getNaN(APFloat::IEEEsingle())));
+  EXPECT_FALSE(NaNFP.contains(APFloat::getInf(APFloat::IEEEsingle(), true)));
+  EXPECT_FALSE(NaNFP.contains(APFloat::getInf(APFloat::IEEEsingle(), false)));
+}
+
 TEST_F(ConstantRangeTest, Equality) {
   EXPECT_EQ(Full, Full);
   EXPECT_EQ(Empty, Empty);
   EXPECT_EQ(One, One);
   EXPECT_EQ(Some, Some);
   EXPECT_EQ(Wrap, Wrap);
   EXPECT_NE(Full, Empty);
   EXPECT_NE(Full, One);
   EXPECT_NE(Full, Some);
   EXPECT_NE(Full, Wrap);
   EXPECT_NE(Empty, One);
   EXPECT_NE(Empty, Some);
   EXPECT_NE(Empty, Wrap);
   EXPECT_NE(One, Some);
   EXPECT_NE(One, Wrap);
   EXPECT_NE(Some, Wrap);
 }
 
+TEST_F(ConstantRangeTest, EqualityFP) {
+  EXPECT_EQ(FullFP, FullFP);
+  EXPECT_EQ(EmptyFP, EmptyFP);
+  EXPECT_EQ(OneFP, OneFP);
+  EXPECT_EQ(SomeFP, SomeFP);
+  EXPECT_EQ(WrapFP, WrapFP);
+  EXPECT_EQ(NaNFP, NaNFP);
+  EXPECT_NE(FullFP, EmptyFP);
+  EXPECT_NE(FullFP, OneFP);
+  EXPECT_NE(FullFP, SomeFP);
+  EXPECT_NE(FullFP, WrapFP);
+  EXPECT_NE(FullFP, NaNFP);
+  EXPECT_NE(EmptyFP, OneFP);
+  EXPECT_NE(EmptyFP, SomeFP);
+  EXPECT_NE(EmptyFP, WrapFP);
+  EXPECT_NE(EmptyFP, NaNFP);
+  EXPECT_NE(OneFP, SomeFP);
+  EXPECT_NE(OneFP, WrapFP);
+  EXPECT_NE(OneFP, NaNFP);
+  EXPECT_NE(SomeFP, WrapFP);
+  EXPECT_NE(SomeFP, NaNFP);
+}
+
 TEST_F(ConstantRangeTest, SingleElement) {
   EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(nullptr));
   EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(nullptr));
   EXPECT_EQ(Full.getSingleMissingElement(), static_cast<APInt *>(nullptr));
   EXPECT_EQ(Empty.getSingleMissingElement(), static_cast<APInt *>(nullptr));
 
   EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
   EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(nullptr));
   EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(nullptr));
 
   EXPECT_EQ(One.getSingleMissingElement(), static_cast<APInt *>(nullptr));
   EXPECT_EQ(Some.getSingleMissingElement(), static_cast<APInt *>(nullptr));
 
   ConstantRange OneInverse = One.inverse();
   EXPECT_EQ(*OneInverse.getSingleMissingElement(), *One.getSingleElement());
 
   EXPECT_FALSE(Full.isSingleElement());
   EXPECT_FALSE(Empty.isSingleElement());
   EXPECT_TRUE(One.isSingleElement());
   EXPECT_FALSE(Some.isSingleElement());
   EXPECT_FALSE(Wrap.isSingleElement());
 }
 
+TEST_F(ConstantRangeTest, SingleElementFP) {
+  EXPECT_EQ(FullFP.getSingleElementFP(), static_cast<APFloat *>(nullptr));
+  EXPECT_EQ(EmptyFP.getSingleElementFP(), static_cast<APFloat *>(nullptr));
+
+  EXPECT_EQ(*OneFP.getSingleElementFP(), APFloat(10.0f));
+  EXPECT_EQ(SomeFP.getSingleElementFP(), static_cast<APFloat *>(nullptr));
+  EXPECT_EQ(WrapFP.getSingleElementFP(), static_cast<APFloat *>(nullptr));
+}
+
 TEST_F(ConstantRangeTest, GetMinsAndMaxes) {
   EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX));
   EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));
   EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));
   EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));
 
   EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));
   EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));
TEST_F(ConstantRangeTest, UpperWrapped) {
   EXPECT_FALSE(CR1.isWrappedSet());
   EXPECT_TRUE(CR1.isUpperWrapped());
 
   ConstantRange CR2(APInt(8, 42), APInt::getSignedMinValue(8));
   EXPECT_FALSE(CR2.isSignWrappedSet());
   EXPECT_TRUE(CR2.isUpperSignWrapped());
 }
 
+TEST_F(ConstantRangeTest, UpperWrappedFP) {
+  // The behavior here is the same as for isWrappedSet() / isSignWrappedSet().
+  EXPECT_FALSE(FullFP.isUpperWrapped());
+  EXPECT_FALSE(EmptyFP.isUpperWrapped());
+  EXPECT_FALSE(OneFP.isUpperWrapped());
+  EXPECT_FALSE(SomeFP.isUpperWrapped());
+  EXPECT_TRUE(WrapFP.isUpperWrapped());
+  EXPECT_FALSE(NaNFP.isUpperWrapped());
+}
+
 TEST_F(ConstantRangeTest, Trunc) {
   ConstantRange TFull = Full.truncate(10);
   ConstantRange TEmpty = Empty.truncate(10);
   ConstantRange TOne = One.truncate(10);
   ConstantRange TSome = Some.truncate(10);
   ConstantRange TWrap = Wrap.truncate(10);
   EXPECT_TRUE(TFull.isFullSet());
   EXPECT_TRUE(TEmpty.isEmptySet());
TEST_F(ConstantRangeTest, IntersectWith) {
   EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 2)));
 
   // [15, 0) /\ [7, 6) = [15, 0)
   LHS = ConstantRange(APInt(32, 15), APInt(32, 0));
   RHS = ConstantRange(APInt(32, 7), APInt(32, 6));
   EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 15), APInt(32, 0)));
 }
 
+TEST_F(ConstantRangeTest, IntersectWithFP) {
+  EXPECT_EQ(EmptyFP.intersectWith(FullFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.intersectWith(EmptyFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.intersectWith(OneFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.intersectWith(SomeFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.intersectWith(WrapFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.intersectWith(NaNFP), EmptyFP);
+  EXPECT_EQ(FullFP.intersectWith(FullFP), FullFP);
+  EXPECT_EQ(FullFP.intersectWith(OneFP), OneFP);
+  EXPECT_EQ(FullFP.intersectWith(SomeFP), SomeFP);
+  EXPECT_EQ(FullFP.intersectWith(NaNFP), NaNFP);
+  EXPECT_EQ(SomeFP.intersectWith(SomeFP), SomeFP);
+  EXPECT_EQ(SomeFP.intersectWith(OneFP), OneFP);
+  EXPECT_EQ(SomeFP.intersectWith(WrapFP), SomeFP);
+  EXPECT_EQ(SomeFP.intersectWith(NaNFP), EmptyFP);
+  EXPECT_EQ(OneFP.intersectWith(WrapFP), OneFP);
+  EXPECT_EQ(OneFP.intersectWith(WrapFP), WrapFP.intersectWith(OneFP));
+  EXPECT_EQ(OneFP.intersectWith(NaNFP), EmptyFP);
+  EXPECT_EQ(NaNFP.intersectWith(NaNFP), NaNFP);
+
+  // Klee generated testcase from PR4545, float version.
+  // The intersection of [4, 2] and [6, 5] is disjoint, looking like
+  // [-Inf, 2] \/ [4, 5] \/ [6, Inf].
+  ConstantRange LHS(APFloat(4.0f), APFloat(2.0f));
+  ConstantRange RHS(APFloat(6.0f), APFloat(5.0f));
+  EXPECT_TRUE(LHS.intersectWith(RHS) == LHS);
+
+  // Intersection of [-Inf, 3] and [2, Inf] should be [2, 3]
+  LHS = ConstantRange(APFloat::getInf(APFloat::IEEEsingle(), true), APFloat(3.0f));
+  RHS = ConstantRange(APFloat(2.0f), APFloat::getInf(APFloat::IEEEsingle()));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(2.0f), APFloat(3.0f)));
+
+  // Intersection of [-Inf, -0.0] and [0.0, Inf] should be empty
+  LHS = ConstantRange(APFloat::getInf(APFloat::IEEEsingle(), true), APFloat(-0.0f));
+  RHS = ConstantRange(APFloat(0.0f), APFloat::getInf(APFloat::IEEEsingle()));
+  EXPECT_EQ(LHS.intersectWith(RHS), EmptyFP);
+
+  // [2, 0] /\ [4, 3] = [2, 0]
+  LHS = ConstantRange(APFloat(2.0f), APFloat(0.0f));
+  RHS = ConstantRange(APFloat(4.0f), APFloat(3.0f));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(2.0f), APFloat(0.0f)));
+
+  // [3, 0] /\ [4, 2] = [4, 0]
+  LHS = ConstantRange(APFloat(3.0f), APFloat(0.0f));
+  RHS = ConstantRange(APFloat(4.0f), APFloat(2.0f));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(4.0f), APFloat(0.0f)));
+
+  // [4, 2] /\ [5, 1] = [5, 1]
+  LHS = ConstantRange(APFloat(4.0f), APFloat(2.0f));
+  RHS = ConstantRange(APFloat(5.0f), APFloat(1.0f));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(5.0f), APFloat(1.0f)));
+
+  // [2, 0] /\ [7, 4] = [7, 4]
+  LHS = ConstantRange(APFloat(2.0f), APFloat(0.0f));
+  RHS = ConstantRange(APFloat(7.0f), APFloat(4.0f));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(7.0f), APFloat(4.0f)));
+
+  // [4, 2] /\ [1, 0] = [1, 0]
+  LHS = ConstantRange(APFloat(4.0f), APFloat(2.0f));
+  RHS = ConstantRange(APFloat(1.0f), APFloat(0.0f));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(4.0f), APFloat(2.0f)));
+
+  // [15, 0] /\ [7, 6] = [15, 0]
+  LHS = ConstantRange(APFloat(15.0f), APFloat(0.0f));
+  RHS = ConstantRange(APFloat(7.0f), APFloat(6.0f));
+  EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APFloat(15.0f), APFloat(0.0f)));
+}
+
 template<typename Fn1, typename Fn2>
 void testBinarySetOperationExhaustive(Fn1 OpFn, Fn2 InResultFn) {
   unsigned Bits = 4;
   EnumerateTwoConstantRanges(Bits,
       [=](const ConstantRange &CR1, const ConstantRange &CR2) {
         // Collect up to three contiguous unsigned ranges. The HaveInterrupt
         // variables are used determine when we have to switch to the next
         // range because the previous one ended.
testBinarySetOperationExhaustive(
          ConstantRange::PreferredRangeType Type) {
         return CR1.intersectWith(CR2, Type);
       },
       [](const ConstantRange &CR1, const ConstantRange &CR2, const APInt &N) {
         return CR1.contains(N) && CR2.contains(N);
       });
 }
 
+TEST_F(ConstantRangeTest, IntersectWithExhaustiveFP) {
+  unsigned ExpDiff = 2;
+  ConstantRange Full(APFloat::getInf(APFloat::IEEEsingle(), true),
+                     APFloat::getInf(APFloat::IEEEsingle(), false), true);
+  EnumerateTwoConstantRangesFP(ExpDiff,
+      [=](const ConstantRange &CR1, const ConstantRange &CR2) {
+         ConstantRange Res = CR1.intersectWith(CR2);
+
+         ForeachNumInConstantRangeFP(Full, ExpDiff, [&](const APFloat &N) {
+           // UpperWrapped operands lead to disjoint ranges check that result
+           // is a super-set.
+           if (CR1.isUpperWrapped() || CR2.isUpperWrapped()) {
+             if (CR1.contains(N) && CR2.contains(N) && !Res.contains(N))
+               ADD_FAILURE() << "FAILURE AT: " << N.convertToFloat() << "\n";
+           } else {
+             if (Res.contains(N) != (CR1.contains(N) && CR2.contains(N)))
+               ADD_FAILURE() << "FAILURE AT: " << N.convertToFloat() << "\n";
+           }
+         });
+      });
+}
+
 TEST_F(ConstantRangeTest, UnionWithExhaustive) {
   testBinarySetOperationExhaustive(
       [](const ConstantRange &CR1, const ConstantRange &CR2,
          ConstantRange::PreferredRangeType Type) {
         return CR1.unionWith(CR2, Type);
       },
       [](const ConstantRange &CR1, const ConstantRange &CR2, const APInt &N) {
         return CR1.contains(N) || CR2.contains(N);
       });
 }
 
+TEST_F(ConstantRangeTest, UnionWithExhaustiveFP) {
+  unsigned ExpDiff = 2;
+  ConstantRange Full(APFloat::getInf(APFloat::IEEEsingle(), true),
+                     APFloat::getInf(APFloat::IEEEsingle(), false), true);
+  EnumerateTwoConstantRangesFP(ExpDiff,
+      [=](const ConstantRange &CR1, const ConstantRange &CR2) {
+         ConstantRange Res = CR1.unionWith(CR2);
+
+         ForeachNumInConstantRangeFP(Full, ExpDiff, [&](const APFloat &N) {
+           // Non-upperWrapped operands lead to disjoint ranges check that
+           // result is a super-set.
+           bool InSources = CR1.contains(N) || CR2.contains(N);
+           bool InResult = Res.contains(N);
+           if (!CR1.isUpperWrapped() || !CR2.isUpperWrapped()) {
+             if (InSources && !InResult)
+               ADD_FAILURE() << "FAILURE AT: " << N.convertToFloat() << "\n";
+           } else {
+             if (InResult != InSources)
+               ADD_FAILURE() << "FAILURE AT: " << N.convertToFloat() << "\n";
+           }
+         });
+      });
+}
+
 TEST_F(ConstantRangeTest, UnionWith) {
   EXPECT_EQ(Wrap.unionWith(One),
             ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));
   EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));
   EXPECT_EQ(Empty.unionWith(Empty), Empty);
   EXPECT_EQ(Full.unionWith(Full), Full);
   EXPECT_EQ(Some.unionWith(Wrap), Full);
 
   // PR4545
   EXPECT_EQ(ConstantRange(APInt(16, 14), APInt(16, 1)).unionWith(
                                     ConstantRange(APInt(16, 0), APInt(16, 8))),
             ConstantRange(APInt(16, 14), APInt(16, 8)));
   EXPECT_EQ(ConstantRange(APInt(16, 6), APInt(16, 4)).unionWith(
                                     ConstantRange(APInt(16, 4), APInt(16, 0))),
             ConstantRange::getFull(16));
   EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 0)).unionWith(
                                     ConstantRange(APInt(16, 2), APInt(16, 1))),
             ConstantRange::getFull(16));
 }
 
+TEST_F(ConstantRangeTest, UnionWithFP) {
+  EXPECT_EQ(WrapFP.unionWith(OneFP), WrapFP);
+  EXPECT_EQ(OneFP.unionWith(WrapFP), WrapFP.unionWith(OneFP));
+  EXPECT_EQ(EmptyFP.unionWith(EmptyFP), EmptyFP);
+  EXPECT_EQ(FullFP.unionWith(FullFP), FullFP);
+  EXPECT_EQ(SomeFP.unionWith(WrapFP), ConstantRange::getFull(APFloat::IEEEsingle(), false));
+  EXPECT_EQ(OneFP.unionWith(NaNFP), NaNFP.unionWith(OneFP));
+  EXPECT_EQ(SomeFP.unionWith(NaNFP), NaNFP.unionWith(SomeFP));
+  EXPECT_EQ(WrapFP.unionWith(NaNFP), NaNFP.unionWith(WrapFP));
+  EXPECT_TRUE(OneFP.unionWith(NaNFP).getCanBeNaN());
+  EXPECT_FALSE(OneFP.unionWith(NaNFP).isSingleElementFP());
+  EXPECT_TRUE(SomeFP.unionWith(NaNFP).getCanBeNaN());
+  EXPECT_TRUE(WrapFP.unionWith(NaNFP).getCanBeNaN());
+  EXPECT_TRUE(OneFP.unionWith(NaNFP).contains(APFloat::getNaN(APFloat::IEEEsingle())));
+  EXPECT_TRUE(SomeFP.unionWith(NaNFP).contains(APFloat::getNaN(APFloat::IEEEsingle())));
+  EXPECT_TRUE(WrapFP.unionWith(NaNFP).contains(APFloat::getNaN(APFloat::IEEEsingle())));
+
+  EXPECT_EQ(ConstantRange(APFloat(14.0f), APFloat(1.0f)).unionWith(
+                                    ConstantRange(APFloat(1.0f), APFloat(8.0f))),
+            ConstantRange(APFloat(14.0f), APFloat(8.0f)));
+  EXPECT_EQ(ConstantRange(APFloat(6.0f), APFloat(4.0f)).unionWith(
+                                    ConstantRange(APFloat(4.0f), APFloat(0.0f))),
+            ConstantRange::getFull(APFloat::IEEEsingle(), false));
+  EXPECT_EQ(ConstantRange(APFloat(1.0f), APFloat(0.0f)).unionWith(
+                                    ConstantRange(APFloat(2.0f), APFloat(1.0f))),
+            ConstantRange::getFull(APFloat::IEEEsingle(), false));
+}
+
+TEST_F(ConstantRangeTest, InverseExhaustiveFP) {
+  unsigned ExpDiff = 2;
+  ConstantRange Full(APFloat::getInf(APFloat::IEEEsingle(), true),
+                     APFloat::getInf(APFloat::IEEEsingle(), false), true);
+  EnumerateConstantRangesFP(ExpDiff, [&](const ConstantRange &CR) {
+         ConstantRange Res = CR.inverse();
+         ForeachNumInConstantRangeFP(Full, ExpDiff, [&](const APFloat &N) {
+           if (CR.contains(N) == Res.contains(N))
+             ADD_FAILURE() << "FAILURE AT: " << N.convertToFloat() << "\n";
+         });
+      });
+}
+
 TEST_F(ConstantRangeTest, SetDifference) {
   EXPECT_EQ(Full.difference(Empty), Full);
   EXPECT_EQ(Full.difference(Full), Empty);
   EXPECT_EQ(Empty.difference(Empty), Empty);
   EXPECT_EQ(Empty.difference(Full), Empty);
 
   ConstantRange A(APInt(16, 3), APInt(16, 7));
   ConstantRange B(APInt(16, 5), APInt(16, 9));
   ConstantRange C(APInt(16, 3), APInt(16, 5));
   ConstantRange D(APInt(16, 7), APInt(16, 9));
   ConstantRange E(APInt(16, 5), APInt(16, 4));
   ConstantRange F(APInt(16, 7), APInt(16, 3));
   EXPECT_EQ(A.difference(B), C);
   EXPECT_EQ(B.difference(A), D);
   EXPECT_EQ(E.difference(A), F);
 }
 
+TEST_F(ConstantRangeTest, SetDifferenceFP) {
+  EXPECT_EQ(FullFP.difference(EmptyFP), FullFP);
+  EXPECT_EQ(FullFP.difference(FullFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.difference(EmptyFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.difference(FullFP), EmptyFP);
+
+  auto N7U = APFloat(7.0f); N7U.next(false);
+  auto N3D = APFloat(3.0f); N3D.next(true);
+  auto N5D = APFloat(5.0f); N5D.next(true);
+  ConstantRange A(APFloat(3.0f), APFloat(7.0f));
+  ConstantRange B(APFloat(5.0f), APFloat(9.0f));
+  ConstantRange C(APFloat(3.0f), N5D);
+  ConstantRange D(N7U, APFloat(9.0f));
+  ConstantRange E(APFloat(5.0f), APFloat(4.0f));
+  ConstantRange F(N7U, N3D);
+  EXPECT_EQ(A.difference(B), C);
+  EXPECT_EQ(B.difference(A), D);
+  EXPECT_EQ(E.difference(A), F);
+}
+
 TEST_F(ConstantRangeTest, SubtractAPInt) {
   EXPECT_EQ(Full.subtract(APInt(16, 4)), Full);
   EXPECT_EQ(Empty.subtract(APInt(16, 4)), Empty);
   EXPECT_EQ(Some.subtract(APInt(16, 4)),
             ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
   EXPECT_EQ(Wrap.subtract(APInt(16, 4)),
             ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
   EXPECT_EQ(One.subtract(APInt(16, 4)),
TEST_F(ConstantRangeTest, Add) {
   EXPECT_EQ(Some.add(APInt(16, 4)),
             ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
   EXPECT_EQ(Wrap.add(APInt(16, 4)),
             ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
   EXPECT_EQ(One.add(APInt(16, 4)),
             ConstantRange(APInt(16, 0xe)));
 }
 
+TEST_F(ConstantRangeTest, AddFP) {
+  EXPECT_EQ(FullFP.fadd(APFloat(4.0f)), FullFP);
+  EXPECT_EQ(FullFP.fadd(FullFP), FullFP);
+  EXPECT_EQ(FullFP.fadd(EmptyFP), EmptyFP);
+  EXPECT_EQ(FullFP.fadd(OneFP), FullFP);
+  EXPECT_EQ(FullFP.fadd(SomeFP), FullFP);
+  EXPECT_EQ(FullFP.fadd(WrapFP), FullFP);
+  EXPECT_EQ(EmptyFP.fadd(EmptyFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.fadd(OneFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.fadd(SomeFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.fadd(WrapFP), EmptyFP);
+  EXPECT_EQ(EmptyFP.fadd(APFloat(4.0f)), EmptyFP);
+  EXPECT_EQ(SomeFP.fadd(APFloat(4.0f)),
+            ConstantRange(APFloat(14.0f), APFloat(104.0f)));
+  EXPECT_EQ(WrapFP.fadd(APFloat(4.0f)), InfFP);
+  EXPECT_EQ(OneFP.fadd(APFloat(4.0f)),
+            ConstantRange(APFloat(14.0f)));
+}
+
+template<typename Fn1, typename Fn2>
+static void TestFPBinOpExhaustive(
+    Fn1 RangeFn, Fn2 FloatFn, bool CorrectnessOnly = false) {
+  unsigned ExpDiff = 1;
+  APFloat NaN = APFloat::getNaN(APFloat::IEEEsingle());
+  APFloat PosInf = APFloat::getInf(APFloat::IEEEsingle());
+  APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
+
+  EnumerateTwoConstantRangesFP(ExpDiff, [&](const ConstantRange &CR1,
+                                            const ConstantRange &CR2) {
+    SmallVector<ConstantRange, 2> Ranges1;
+    SmallVector<ConstantRange, 2> Ranges2;
+    SmallVector<ConstantRange, 4> ExactRanges;
+
+    // Split upperWrapped ranges into pos and neg part and test separately
+    if (CR1.isUpperWrapped()) {
+      Ranges1.push_back({CR1.getLowerFP(), PosInf, CR1.getCanBeNaN()});
+      Ranges1.push_back({NegInf, CR1.getUpperFP(), CR1.getCanBeNaN()});
+    } else {
+      Ranges1.push_back(CR1);
+    }
+    if (CR2.isUpperWrapped()) {
+      Ranges2.push_back({CR2.getLowerFP(), PosInf, CR2.getCanBeNaN()});
+      Ranges2.push_back({NegInf, CR2.getUpperFP(), CR2.getCanBeNaN()});
+    } else {
+      Ranges2.push_back(CR2);
+    }
+
+
+    for (const auto &R1:Ranges1)
+      for (const auto &R2:Ranges2) {
+        APFloat Min = NaN;
+        APFloat Max = NaN;
+        bool canBeNaN = R1.getCanBeNaN() || R2.getCanBeNaN();
+        ForeachNumInConstantRangeFP(R1, ExpDiff, [&](const APFloat &N1) {
+          ForeachNumInConstantRangeFP(R2, ExpDiff, [&](const APFloat &N2) {
+            APFloat N = FloatFn(N1, N2);
+            Min = minnum(Min, N);
+            Max = maxnum(Max, N);
+            if (N.isNaN())
+              canBeNaN = true;
+          });
+        });
+        ExactRanges.push_back({Min, Max, canBeNaN});
+      }
+
+    ConstantRange CR = RangeFn(CR1, CR2);
+
+    bool ExactNaN = false;
+    for (const auto &Exact: ExactRanges) {
+      if (Exact.getCanBeNaN())
+        ExactNaN = true;
+      if (!CR.contains(Exact))
+        ADD_FAILURE() << "FAILED: \n";
+    }
+    // Check that we don't unnecesarilly include NaN
+    EXPECT_EQ(CR.getCanBeNaN(), ExactNaN);
+  });
+}
+
+
+TEST_F(ConstantRangeTest, AddFPExhaustive) {
+  TestFPBinOpExhaustive(
+      [](const ConstantRange &CR1, const ConstantRange &CR2) {
+        return CR1.fadd(CR2);
+      },
+      [](const APFloat &X, const APFloat &Y) {
+        return X + Y;
+      });
+}
+
+TEST_F(ConstantRangeTest, SubFPExhaustive) {
+  TestFPBinOpExhaustive(
+      [](const ConstantRange &CR1, const ConstantRange &CR2) {
+        return CR1.fsub(CR2);
+      },
+      [](const APFloat &X, const APFloat &Y) {
+        return X - Y;
+      });
+}
+
+TEST_F(ConstantRangeTest, MulFPExhaustive) {
+  TestFPBinOpExhaustive(
+      [](const ConstantRange &CR1, const ConstantRange &CR2) {
+        return CR1.fmultiply(CR2);
+      },
+      [](const APFloat &X, const APFloat &Y) {
+        return X * Y;
+      });
+}
+
+TEST_F(ConstantRangeTest, DivFPExhaustive) {
+  TestFPBinOpExhaustive(
+      [](const ConstantRange &CR1, const ConstantRange &CR2) {
+        return CR1.fdivide(CR2);
+      },
+      [](const APFloat &X, const APFloat &Y) {
+        return X / Y;
+      });
+}
+
+TEST_F(ConstantRangeTest, MaximumFPExhaustive) {
+  TestFPBinOpExhaustive(
+      [](const ConstantRange &CR1, const ConstantRange &CR2) {
+        return CR1.fmax(CR2);
+      },
+      [](const APFloat &X, const APFloat &Y) {
+        return maximum(X, Y);
+      });
+}
+
+TEST_F(ConstantRangeTest, MinimumFPExhaustive) {
+  TestFPBinOpExhaustive(
+      [](const ConstantRange &CR1, const ConstantRange &CR2) {
+        return CR1.fmin(CR2);
+      },
+      [](const APFloat &X, const APFloat &Y) {
+        return minimum(X, Y);
+      });
+}
+
 template <typename Fn1, typename Fn2>
 static void TestAddWithNoSignedWrapExhaustive(Fn1 RangeFn, Fn2 IntFn) {
   unsigned Bits = 4;
   EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
                                        const ConstantRange &CR2) {
     ConstantRange CR = RangeFn(CR1, CR2);
     APInt Min = APInt::getSignedMaxValue(Bits);
     APInt Max = APInt::getSignedMinValue(Bits);
EXPECT_EQ(Some.ashr(Some), ConstantRange(APInt(16, 0),
                                            APInt(16, (0xaaa >> 0xa) + 1)));
   EXPECT_EQ(Some.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
   EXPECT_EQ(Wrap.ashr(Wrap), Full);
   ConstantRange Neg(APInt(16, 0xf3f0, true), APInt(16, 0xf7f8, true));
   EXPECT_EQ(Neg.ashr(Small), ConstantRange(APInt(16, 0xfffc, true),
                                            APInt(16, 0xfffe, true)));
 }
 
+template<typename Fn1, typename Fn2, typename Fn3>
+static void TestFPCompExhaustive(Fn1 RangeFn, Fn2 FloatFn, Fn3 CombFn, bool Init) {
+  unsigned ExpDiff = 105;
+  ConstantRange FullCR = ConstantRange::getFull(APFloat::IEEEsingle());
+  EnumerateConstantRangesFP(ExpDiff, [&](const ConstantRange &CR) {
+    ConstantRange ResCR = RangeFn(CR);
+    ForeachNumInConstantRangeFP(FullCR, ExpDiff, [&](const APFloat &LHS) {
+      bool ResVal = Init;
+      // Compare against all values in the original ConstantRange
+      ForeachNumInConstantRangeFP(CR, ExpDiff, [&](const APFloat &RHS) {
+        ResVal = CombFn(ResVal, FloatFn(LHS, RHS));
+      });
+      EXPECT_EQ(ResVal, ResCR.contains(LHS));
+    });
+  });
+}
+
+template<typename Fn1, typename Fn2>
+static void TestFPCompExhaustiveAllowed(Fn1 RangeFn, Fn2 FloatFn) {
+  TestFPCompExhaustive(
+    RangeFn, FloatFn, [](bool a, bool b){ return a || b; }, false);
+}
+
+TEST(ConstantRange, MakeAllowedFCmpOrdRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_ORD, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN(); }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpUnoRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_UNO, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN(); }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpOEQRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_OEQ, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS == RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpUEQRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_UEQ, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS == RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpONERegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_ONE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS != RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpUNERegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_UNE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS != RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpOGTRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_OGT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS > RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpUGTRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_UGT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS > RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpOLTRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_OLT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS < RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpULTRegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_ULT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS < RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpOGERegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_OGE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS >= RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpUGERegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_UGE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS >= RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpOLERegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_OLE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS <= RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeAllowedFCmpULERegion) {
+  TestFPCompExhaustiveAllowed(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeAllowedFCmpRegion(CmpInst::FCMP_ULE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS <= RHS; }
+  );
+}
+
+template<typename Fn1, typename Fn2>
+static void TestFPCompExhaustiveSatisfying(Fn1 RangeFn, Fn2 FloatFn) {
+  TestFPCompExhaustive(
+    RangeFn, FloatFn, [](bool a, bool b){ return a && b; }, true);
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpOrdRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_ORD, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN(); }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpUnoRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_UNO, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN(); }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpOEQRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_OEQ, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS == RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpUEQRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_UEQ, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS == RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpONERegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_ONE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS != RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpUNERegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_UNE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS != RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpOGTRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_OGT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS > RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpUGTRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_UGT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS > RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpOLTRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_OLT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS < RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpULTRegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_ULT, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS < RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpOGERegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_OGE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS >= RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpUGERegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_UGE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS >= RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpOLERegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_OLE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return !LHS.isNaN() && !RHS.isNaN() && LHS <= RHS; }
+  );
+}
+
+TEST(ConstantRange, MakeSatisfyingFCmpULERegion) {
+  TestFPCompExhaustiveSatisfying(
+    [](const ConstantRange &CR) {
+      return ConstantRange::makeSatisfyingFCmpRegion(CmpInst::FCMP_ULE, CR); },
+    [](const APFloat &LHS, const APFloat &RHS) {
+      return LHS.isNaN() || RHS.isNaN() || LHS <= RHS; }
+  );
+}
+
 TEST(ConstantRange, MakeAllowedICmpRegion) {
   // PR8250
   ConstantRange SMax = ConstantRange(APInt::getSignedMaxValue(32));
   EXPECT_TRUE(ConstantRange::makeAllowedICmpRegion(ICmpInst::ICMP_SGT, SMax)
                   .isEmptySet());
 }
 
 TEST(ConstantRange, MakeSatisfyingICmpRegion) {
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
 
     ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
     EXPECT_EQ(Exact, AbsCR);
   });
 }
 
 TEST_F(ConstantRangeTest, castOps) {
   ConstantRange A(APInt(16, 66), APInt(16, 128));
-  ConstantRange FpToI8 = A.castOp(Instruction::FPToSI, 8);
+  ConstantRange A32(APInt(32, 66), APInt(32, 128));
+  ConstantRange AF(APFloat(66.0f), APFloat(128.0f));
+  EXPECT_EQ(32u, AF.getBitWidth());
+
+  EXPECT_TRUE(A.castOp(Instruction::BitCast, APFloat::IEEEhalf()).getIsFloat());
+  EXPECT_TRUE(A32.castOp(Instruction::BitCast, APFloat::IEEEsingle()).getIsFloat());
+  EXPECT_TRUE(A32.castOp(Instruction::BitCast, APFloat::IEEEsingle()).isFullSet());
+  EXPECT_TRUE(AF.castOp(Instruction::BitCast, APFloat::IEEEsingle()).getIsFloat());
+  EXPECT_EQ(AF.castOp(Instruction::BitCast, APFloat::IEEEsingle()), AF);
+
+  EXPECT_FALSE(A32.castOp(Instruction::BitCast, 32).getIsFloat());
+  EXPECT_FALSE(AF.castOp(Instruction::BitCast, 32).getIsFloat());
+  EXPECT_EQ(A32.castOp(Instruction::BitCast, 32), A32);
+  EXPECT_TRUE(AF.castOp(Instruction::BitCast, 32).isFullSet());
+
+  ConstantRange FpToI8 = AF.castOp(Instruction::FPToSI, 8);
   EXPECT_EQ(8u, FpToI8.getBitWidth());
   EXPECT_TRUE(FpToI8.isFullSet());
 
-  ConstantRange FpToI16 = A.castOp(Instruction::FPToSI, 16);
+  ConstantRange FpToI16 = AF.castOp(Instruction::FPToSI, 16);
   EXPECT_EQ(16u, FpToI16.getBitWidth());
-  EXPECT_EQ(A, FpToI16);
+  EXPECT_TRUE(FpToI16.isFullSet());
+
+  ConstantRange UI32ToFP32 = A.castOp(Instruction::UIToFP, APFloat::IEEEsingle());
+  EXPECT_EQ(32u, UI32ToFP32.getBitWidth());
+  EXPECT_TRUE(UI32ToFP32.isFullSet());
 
-  ConstantRange FPExtToDouble = A.castOp(Instruction::FPExt, 64);
+  ConstantRange SI32ToFP32 = A.castOp(Instruction::SIToFP, APFloat::IEEEsingle());
+  EXPECT_EQ(32u, SI32ToFP32.getBitWidth());
+  EXPECT_TRUE(SI32ToFP32.isFullSet());
+
+  ConstantRange FPExtToDouble = AF.castOp(Instruction::FPExt, APFloat::IEEEdouble());
   EXPECT_EQ(64u, FPExtToDouble.getBitWidth());
-  EXPECT_TRUE(FPExtToDouble.isFullSet());
+  EXPECT_EQ(66.0, FPExtToDouble.getLowerFP().convertToDouble());
+  EXPECT_EQ(128.0, FPExtToDouble.getUpperFP().convertToDouble());
+
+  ConstantRange FPTruncToHalf = AF.castOp(Instruction::FPTrunc, APFloat::IEEEhalf());
+  EXPECT_EQ(16u, FPTruncToHalf.getBitWidth());
+  EXPECT_TRUE(FPTruncToHalf.getLowerFP().isExactlyValue(66.0));
+  EXPECT_TRUE(FPTruncToHalf.getUpperFP().isExactlyValue(128.0));
 
   ConstantRange PtrToInt = A.castOp(Instruction::PtrToInt, 64);
   EXPECT_EQ(64u, PtrToInt.getBitWidth());
   EXPECT_TRUE(PtrToInt.isFullSet());
 
   ConstantRange IntToPtr = A.castOp(Instruction::IntToPtr, 64);
   EXPECT_EQ(64u, IntToPtr.getBitWidth());
   EXPECT_TRUE(IntToPtr.isFullSet());
+
+  ConstantRange A128(APInt(128, 66), APInt(128, 128));
+  EXPECT_TRUE(A128.castOp(Instruction::BitCast, APFloat::PPCDoubleDouble()).getIsFloat());
+  EXPECT_TRUE(A128.castOp(Instruction::BitCast, APFloat::PPCDoubleDouble()).isFullSet());
+  EXPECT_EQ(A128.castOp(Instruction::BitCast, 128), A128);
+  EXPECT_FALSE(A128.castOp(Instruction::BitCast, 128).getIsFloat());
+
+  ConstantRange AFPPC(APFloat::getZero(APFloat::PPCDoubleDouble()),
+                      APFloat::getInf(APFloat::PPCDoubleDouble()));
+  EXPECT_EQ(AFPPC.castOp(Instruction::BitCast, APFloat::PPCDoubleDouble()), AFPPC);
+  EXPECT_TRUE(AFPPC.castOp(Instruction::BitCast, APFloat::PPCDoubleDouble()).getIsFloat());
+  EXPECT_FALSE(AFPPC.castOp(Instruction::BitCast, 128).getIsFloat());
+  EXPECT_TRUE(AFPPC.castOp(Instruction::BitCast, 128).isFullSet());
 }
 
 TEST_F(ConstantRangeTest, binaryXor) {
   // Single element ranges.
   ConstantRange R16(APInt(8, 16));
   ConstantRange R20(APInt(8, 20));
   EXPECT_EQ(*R16.binaryXor(R16).getSingleElement(), APInt(8, 0));
   EXPECT_EQ(*R16.binaryXor(R20).getSingleElement(), APInt(8, 16 ^ 20));