[#llvm-KnownFPClass]
= xref:llvm.adoc[llvm]::KnownFPClass
:relfileprefix: ../
:mrdocs:

Tracks which floating‐point classes a value may belong to.

== Synopsis

Declared in `<llvm/Support/KnownFPClass.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
struct KnownFPClass;
----

== Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/KnownFPClass/MinMaxKind.adoc[`MinMaxKind`] 
| Kind of IEEE min/max intrinsic without depending on IR.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/KnownFPClass/2constructor-014.adoc[`KnownFPClass`]         [.small]#[constructor]#
| Constructors
| xref:llvm/KnownFPClass/cannotBeOrderedGreaterEqZero.adoc[`cannotBeOrderedGreaterEqZero`] 
| Return true if it's know this can never be a negative value or a logical 0.
| xref:llvm/KnownFPClass/cannotBeOrderedGreaterThanZero.adoc[`cannotBeOrderedGreaterThanZero`] 
| Return true if the value is NaN or never ordered greater than ‐0.0.
| xref:llvm/KnownFPClass/cannotBeOrderedLessEqZero.adoc[`cannotBeOrderedLessEqZero`] 
| Return true if it's known this can never be a positive value or a logical 0.
| xref:llvm/KnownFPClass/cannotBeOrderedLessThanZero.adoc[`cannotBeOrderedLessThanZero`] 
| Return true if we can prove that the analyzed floating‐point value is either NaN or never less than ‐0.0.
| xref:llvm/KnownFPClass/copysign-05.adoc[`copysign`] 
| Copy the sign of `Sign` onto this magnitude in place.
| xref:llvm/KnownFPClass/fabs-0b.adoc[`fabs`] 
| Replace this with the absolute value, forcing a non‐negative sign.
| xref:llvm/KnownFPClass/fneg-07.adoc[`fneg`] 
| Negate this value in place, flipping known classes and the sign bit.
| xref:llvm/KnownFPClass/intersectWith.adoc[`intersectWith`] 
| Return the intersection of this and `RHS` known‐class information.
| xref:llvm/KnownFPClass/isKnownAlways.adoc[`isKnownAlways`] 
| Return true if every possible class is covered by `Mask.`
| xref:llvm/KnownFPClass/isKnownAlwaysNaN.adoc[`isKnownAlwaysNaN`] 
| Return true if it's known this must always be a nan.
| xref:llvm/KnownFPClass/isKnownNever.adoc[`isKnownNever`] 
| Return true if it's known this can never be one of the mask entries.
| xref:llvm/KnownFPClass/isKnownNeverInfOrNaN.adoc[`isKnownNeverInfOrNaN`] 
| Return true if it's known this can never be an infinity or nan
| xref:llvm/KnownFPClass/isKnownNeverInfinity.adoc[`isKnownNeverInfinity`] 
| Return true if it's known this can never be an infinity.
| xref:llvm/KnownFPClass/isKnownNeverLogicalNegZero.adoc[`isKnownNeverLogicalNegZero`] 
| Return true if it's known this can never be interpreted as a negative zero.
| xref:llvm/KnownFPClass/isKnownNeverLogicalPosZero.adoc[`isKnownNeverLogicalPosZero`] 
| Return true if it's known this can never be interpreted as a positive zero.
| xref:llvm/KnownFPClass/isKnownNeverLogicalZero.adoc[`isKnownNeverLogicalZero`] 
| Return true if it's known this can never be interpreted as a zero.
| xref:llvm/KnownFPClass/isKnownNeverNaN.adoc[`isKnownNeverNaN`] 
| Return true if it's known this can never be a nan.
| xref:llvm/KnownFPClass/isKnownNeverNegInfinity.adoc[`isKnownNeverNegInfinity`] 
| Return true if it's known this can never be ‐infinity.
| xref:llvm/KnownFPClass/isKnownNeverNegSubnormal.adoc[`isKnownNeverNegSubnormal`] 
| Return true if it's known this can never be a negative subnormal
| xref:llvm/KnownFPClass/isKnownNeverNegZero.adoc[`isKnownNeverNegZero`] 
| Return true if it's known this can never be a negative zero. This means a literal ‐0 and does not include denormal inputs implicitly treated as ‐0.
| xref:llvm/KnownFPClass/isKnownNeverPosInfinity.adoc[`isKnownNeverPosInfinity`] 
| Return true if it's known this can never be +infinity.
| xref:llvm/KnownFPClass/isKnownNeverPosSubnormal.adoc[`isKnownNeverPosSubnormal`] 
| Return true if it's known this can never be a positive subnormal
| xref:llvm/KnownFPClass/isKnownNeverPosZero.adoc[`isKnownNeverPosZero`] 
| Return true if it's known this can never be a literal positive zero.
| xref:llvm/KnownFPClass/isKnownNeverSubnormal.adoc[`isKnownNeverSubnormal`] 
| Return true if it's known this can never be a subnormal
| xref:llvm/KnownFPClass/isKnownNeverZero.adoc[`isKnownNeverZero`] 
| Return true if it's known this can never be a zero. This means a literal [+‐]0, and does not include denormal inputs implicitly treated as [+‐]0.
| xref:llvm/KnownFPClass/isUnknown.adoc[`isUnknown`] 
| Return true if nothing is known about the class or sign bit.
| xref:llvm/KnownFPClass/knownNot.adoc[`knownNot`] 
| Rule out the floating‐point classes in `RuleOut.`
| xref:llvm/KnownFPClass/operator_or_eq.adoc[`operator|=`] 
| Merge `RHS` into this by taking the union of possible classes.
| xref:llvm/KnownFPClass/propagateCanonicalizingSrc.adoc[`propagateCanonicalizingSrc`] 
| Report known classes for a potentially canonicalizing operation on `Src.`
| xref:llvm/KnownFPClass/propagateDenormal.adoc[`propagateDenormal`] 
| Propagate knowledge from a source that could be a denormal or zero.
| xref:llvm/KnownFPClass/propagateNonNaN-06.adoc[`propagateNonNaN`] 
| `propagateNonNaN` overloads
| xref:llvm/KnownFPClass/propagateNonSNaN-0c.adoc[`propagateNonSNaN`] 
| `propagateNonSNaN` overloads
| xref:llvm/KnownFPClass/propagateXorSign.adoc[`propagateXorSign`] 
| Propagate sign knowledge for operations whose result sign is the xor of the operand signs.
| xref:llvm/KnownFPClass/resetAll.adoc[`resetAll`] 
| Reset all known‐class and sign information to unknown.
| xref:llvm/KnownFPClass/signBitIsZeroOrNaN.adoc[`signBitIsZeroOrNaN`] 
| Return true if the sign bit must be 0, ignoring the sign of nans.
| xref:llvm/KnownFPClass/signBitMustBeOne.adoc[`signBitMustBeOne`] 
| Assume the sign bit is one.
| xref:llvm/KnownFPClass/signBitMustBeZero.adoc[`signBitMustBeZero`] 
| Assume the sign bit is zero.
| xref:llvm/KnownFPClass/toKnownBits.adoc[`toKnownBits`] 
| Report known bits for a float with provided semantics.
| xref:llvm/KnownFPClass/unionWith.adoc[`unionWith`] 
| Return the union of this and `RHS` known‐class information.
| xref:llvm/KnownFPClass/operator_eq.adoc[`operator==`] 
| Return true if this and `Other` have the same known classes and sign.
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/KnownFPClass/acos.adoc[`acos`] 
| Report known values for acos.
| xref:llvm/KnownFPClass/asin.adoc[`asin`] 
| Report known values for asin.
| xref:llvm/KnownFPClass/atan.adoc[`atan`] 
| Report known values for atan.
| xref:llvm/KnownFPClass/atan2.adoc[`atan2`] 
| Report known values for atan2.
| xref:llvm/KnownFPClass/bitcast.adoc[`bitcast`] 
| Report known values for a bitcast into a float with provided semantics.
| xref:llvm/KnownFPClass/canonicalize.adoc[`canonicalize`] 
| Apply the canonicalize intrinsic to this value.
| xref:llvm/KnownFPClass/copysign-09.adoc[`copysign`] 
| Return `KnownMag` with the sign taken from `KnownSign.`
| xref:llvm/KnownFPClass/cos.adoc[`cos`] 
| Report known values for cos.
| xref:llvm/KnownFPClass/cosh.adoc[`cosh`] 
| Report known values for cosh.
| xref:llvm/KnownFPClass/exp.adoc[`exp`] 
| Report known values for exp, exp2 and exp10.
| xref:llvm/KnownFPClass/fabs-0e.adoc[`fabs`] 
| Return the absolute value of `Src.`
| xref:llvm/KnownFPClass/fadd.adoc[`fadd`] 
| Report known values for fadd.
| xref:llvm/KnownFPClass/fadd_self.adoc[`fadd_self`] 
| Report known values for fadd x, x.
| xref:llvm/KnownFPClass/fdiv.adoc[`fdiv`] 
| Report known values for fdiv.
| xref:llvm/KnownFPClass/fdiv_self.adoc[`fdiv_self`] 
| Report known values for fdiv x, x.
| xref:llvm/KnownFPClass/fma.adoc[`fma`] 
| Report known values for fma.
| xref:llvm/KnownFPClass/fma_square.adoc[`fma_square`] 
| Report known values for fma of a squared value plus an addend.
| xref:llvm/KnownFPClass/fmul-06.adoc[`fmul`] 
| `fmul` overloads
| xref:llvm/KnownFPClass/fneg-03.adoc[`fneg`] 
| Return the floating‐point negation of `Src.`
| xref:llvm/KnownFPClass/fpext.adoc[`fpext`] 
| Propagate known class for fpext.
| xref:llvm/KnownFPClass/fptrunc.adoc[`fptrunc`] 
| Propagate known class for fptrunc.
| xref:llvm/KnownFPClass/frem.adoc[`frem`] 
| Report known values for frem.
| xref:llvm/KnownFPClass/frem_self.adoc[`frem_self`] 
| Report known values for frem x, x.
| xref:llvm/KnownFPClass/frexp_mant.adoc[`frexp_mant`] 
| Propagate known class for mantissa component of frexp.
| xref:llvm/KnownFPClass/fsub.adoc[`fsub`] 
| Report known values for fsub.
| xref:llvm/KnownFPClass/ldexp-02.adoc[`ldexp`] 
| `ldexp` overloads
| xref:llvm/KnownFPClass/log.adoc[`log`] 
| Propagate known class for log/log2/log10.
| xref:llvm/KnownFPClass/minMaxLike.adoc[`minMaxLike`] 
| Report known classes for a min/max‐like operation on `LHS` and `RHS.`
| xref:llvm/KnownFPClass/pow.adoc[`pow`] 
| Propagate known class for pow.
| xref:llvm/KnownFPClass/powi.adoc[`powi`] 
| Propagate known class for powi.
| xref:llvm/KnownFPClass/roundToIntegral.adoc[`roundToIntegral`] 
| Propagate known class for rounding intrinsics.
| xref:llvm/KnownFPClass/sin.adoc[`sin`] 
| Report known values for sin.
| xref:llvm/KnownFPClass/sinh.adoc[`sinh`] 
| Report known values for sinh.
| xref:llvm/KnownFPClass/sqrt.adoc[`sqrt`] 
| Propagate known class for sqrt.
| xref:llvm/KnownFPClass/square.adoc[`square`] 
| Report known values for squaring a floating‐point value.
| xref:llvm/KnownFPClass/tan.adoc[`tan`] 
| Report known values for tan.
| xref:llvm/KnownFPClass/tanh.adoc[`tanh`] 
| Report known values for tanh.
|===


== Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/KnownFPClass/KnownFPClasses.adoc[`KnownFPClasses`] 
| Floating‐point classes the value could be one of.
| xref:llvm/KnownFPClass/SignBit.adoc[`SignBit`] 
| std::nullopt if the sign bit is unknown, true if the sign bit is definitely set or false if the sign bit is definitely unset.
|===


== Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/KnownFPClass/OrderedGreaterThanZeroMask.adoc[`OrderedGreaterThanZeroMask`] 
| Mask of classes that are ordered greater than zero.
| xref:llvm/KnownFPClass/OrderedLessThanZeroMask.adoc[`OrderedLessThanZeroMask`] 
| Mask of classes that are ordered less than zero.
|===


== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/adjustKnownFPClassForSelectArm.adoc[`adjustKnownFPClassForSelectArm`]
| Adjust `Known` for the given select `Arm` to include information from the select `Cond.`
| xref:llvm/computeKnownFPClass-00.adoc[`computeKnownFPClass`]
| Wrapper to account for known fast math flags at the use instruction.
| xref:llvm/computeKnownFPClass-01.adoc[`computeKnownFPClass`]
| Determine known floating‐point classes for `V.`
| xref:llvm/computeKnownFPClass-07.adoc[`computeKnownFPClass`]
| Wrapper to account for known fast math flags at the use instruction.
| xref:llvm/computeKnownFPClass-0a.adoc[`computeKnownFPClass`]
| Determine which floating‐point classes are valid for `V,` and return them in KnownFPClass bit sets.
| xref:llvm/computeKnownFPClass-0c.adoc[`computeKnownFPClass`]
| Determine known floating‐point classes for `V` using explicit analysis context.
| xref:llvm/operator_bitor-0ab.adoc[`operator|`]
| Return the union of known‐class information from `LHS` and `RHS.`
| xref:llvm/operator_bitor-0e2.adoc[`operator|`]
| Return the union of known‐class information from `LHS` and `RHS.`
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#