KnownFPClass.h

Go to the documentation of this file.

//===- llvm/Support/KnownFPClass.h - Stores known fpclass -------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file contains a class for representing known fpclasses used by
// computeKnownFPClass.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_SUPPORT_KNOWNFPCLASS_H
#define LLVM_SUPPORT_KNOWNFPCLASS_H
 
#include "llvm/ADT/FloatingPointMode.h"
#include "llvm/Support/Compiler.h"
#include <optional>
 
namespace llvm {
class APFloat;
class APInt;
struct fltSemantics;
struct KnownBits;
 
struct KnownFPClass {
  FPClassTest KnownFPClassesValue = fcAllFlags;
  std::optional<bool> SignBitValue;
 
  /// Floating-point classes the value could be one of.
  FPClassTest getKnownFPClasses() const { return KnownFPClassesValue; }
 
  void setKnownFPClasses(FPClassTest Classes) { KnownFPClassesValue = Classes; }
 
  /// 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.
  std::optional<bool> getSignBit() const { return SignBitValue; }
 
  void setSignBit(std::optional<bool> Sign) { SignBitValue = Sign; }
 
  KnownFPClass(FPClassTest Known = fcAllFlags, std::optional<bool> Sign = {})
      : KnownFPClassesValue(Known), SignBitValue(Sign) {}
  LLVM_ABI KnownFPClass(const APFloat &C);
 
  bool operator==(KnownFPClass Other) const {
    return getKnownFPClasses() == Other.getKnownFPClasses() &&
           getSignBit() == Other.getSignBit();
  }
 
  /// Return true if it's known this can never be one of the mask entries.
  bool isKnownNever(FPClassTest Mask) const {
    return (getKnownFPClasses() & Mask) == fcNone;
  }
 
  bool isKnownAlways(FPClassTest Mask) const { return isKnownNever(~Mask); }
 
  bool isUnknown() const {
    return getKnownFPClasses() == fcAllFlags && !getSignBit();
  }
 
  /// Return true if it's known this can never be a nan.
  bool isKnownNeverNaN() const { return isKnownNever(fcNan); }
 
  /// Return true if it's known this must always be a nan.
  bool isKnownAlwaysNaN() const { return isKnownAlways(fcNan); }
 
  /// Return true if it's known this can never be an infinity.
  bool isKnownNeverInfinity() const { return isKnownNever(fcInf); }
 
  /// Return true if it's known this can never be an infinity or nan
  bool isKnownNeverInfOrNaN() const { return isKnownNever(fcInf | fcNan); }
 
  /// Return true if it's known this can never be +infinity.
  bool isKnownNeverPosInfinity() const { return isKnownNever(fcPosInf); }
 
  /// Return true if it's known this can never be -infinity.
  bool isKnownNeverNegInfinity() const { return isKnownNever(fcNegInf); }
 
  /// Return true if it's known this can never be a subnormal
  bool isKnownNeverSubnormal() const { return isKnownNever(fcSubnormal); }
 
  /// Return true if it's known this can never be a positive subnormal
  bool isKnownNeverPosSubnormal() const { return isKnownNever(fcPosSubnormal); }
 
  /// Return true if it's known this can never be a negative subnormal
  bool isKnownNeverNegSubnormal() const { return isKnownNever(fcNegSubnormal); }
 
  /// 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.
  bool isKnownNeverZero() const { return isKnownNever(fcZero); }
 
  /// Return true if it's known this can never be a literal positive zero.
  bool isKnownNeverPosZero() const { return isKnownNever(fcPosZero); }
 
  /// 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.
  bool isKnownNeverNegZero() const { return isKnownNever(fcNegZero); }
 
  /// Return true if it's known this can never be interpreted as a zero. This
  /// extends isKnownNeverZero to cover the case where the assumed
  /// floating-point mode for the function interprets denormals as zero.
  LLVM_ABI bool isKnownNeverLogicalZero(DenormalMode Mode) const;
 
  /// Return true if it's known this can never be interpreted as a negative
  /// zero.
  LLVM_ABI bool isKnownNeverLogicalNegZero(DenormalMode Mode) const;
 
  /// Return true if it's known this can never be interpreted as a positive
  /// zero.
  LLVM_ABI bool isKnownNeverLogicalPosZero(DenormalMode Mode) const;
 
  static constexpr FPClassTest OrderedLessThanZeroMask =
      fcNegSubnormal | fcNegNormal | fcNegInf;
  static constexpr FPClassTest OrderedGreaterThanZeroMask =
      fcPosSubnormal | fcPosNormal | fcPosInf;
 
  /// Return true if we can prove that the analyzed floating-point value is
  /// either NaN or never less than -0.0.
  ///
  ///      NaN --> true
  ///       +0 --> true
  ///       -0 --> true
  ///   x > +0 --> true
  ///   x < -0 --> false
  bool cannotBeOrderedLessThanZero() const {
    return isKnownNever(OrderedLessThanZeroMask);
  }
 
  /// Return true if we can prove that the analyzed floating-point value is
  /// either NaN or never greater than -0.0.
  ///      NaN --> true
  ///       +0 --> true
  ///       -0 --> true
  ///   x > +0 --> false
  ///   x < -0 --> true
  bool cannotBeOrderedGreaterThanZero() const {
    return isKnownNever(OrderedGreaterThanZeroMask);
  }
 
  /// Return true if it's known this can never be a positive value or a logical
  /// 0.
  ///
  ///      NaN --> true
  ///  x <= +0 --> false
  ///     psub --> true if mode is ieee, false otherwise.
  ///   x > +0 --> true
  bool cannotBeOrderedLessEqZero(DenormalMode Mode) const {
    return isKnownNever(fcNegative) && isKnownNeverLogicalPosZero(Mode);
  }
 
  /// Return true if it's know this can never be a negative value or a logical
  /// 0.
  ///
  ///      NaN --> true
  ///  x >= -0 --> false
  ///     nsub --> true if mode is ieee, false otherwise.
  ///   x < -0 --> true
  bool cannotBeOrderedGreaterEqZero(DenormalMode Mode) const {
    return isKnownNever(fcPositive) && isKnownNeverLogicalNegZero(Mode);
  }
 
  /// Return the known classes of \p Src after passing through an input that
  /// may flush subnormals to zero according to \p Mode.
  LLVM_ABI static KnownFPClass applyInputDenormalMode(const KnownFPClass &Src,
                                                      DenormalMode Mode);
 
  /// Return the known classes of \p Src after producing an output that may
  /// flush subnormals to zero according to \p Mode.
  LLVM_ABI static KnownFPClass applyOutputDenormalMode(const KnownFPClass &Src,
                                                       DenormalMode Mode);
 
  KnownFPClass intersectWith(const KnownFPClass &RHS) const {
    return KnownFPClass(getKnownFPClasses() | RHS.getKnownFPClasses(),
                        getSignBit() == RHS.getSignBit() ? getSignBit()
                                                         : std::nullopt);
  }
 
  KnownFPClass unionWith(const KnownFPClass &RHS) const {
    std::optional<bool> MergedSignBit;
    if (getSignBit() && !RHS.getSignBit())
      MergedSignBit = getSignBit();
    else if (!getSignBit() && RHS.getSignBit())
      MergedSignBit = RHS.getSignBit();
 
    return KnownFPClass(getKnownFPClasses() & RHS.getKnownFPClasses(),
                        MergedSignBit);
  }
 
  KnownFPClass &operator|=(const KnownFPClass &RHS) {
    setKnownFPClasses(getKnownFPClasses() | RHS.getKnownFPClasses());
 
    if (getSignBit() != RHS.getSignBit())
      setSignBit(std::nullopt);
    return *this;
  }
 
  void knownNot(FPClassTest RuleOut) {
    setKnownFPClasses(getKnownFPClasses() & ~RuleOut);
    if (isKnownNever(fcNan) && !getSignBit()) {
      if (isKnownNever(fcNegative))
        setSignBit(false);
      else if (isKnownNever(fcPositive))
        setSignBit(true);
    }
  }
 
  void fneg() {
    setKnownFPClasses(llvm::fneg(getKnownFPClasses()));
    if (std::optional<bool> Sign = getSignBit())
      setSignBit(!*Sign);
  }
 
  static KnownFPClass fneg(const KnownFPClass &Src) {
    KnownFPClass Known = Src;
    Known.fneg();
    return Known;
  }
 
  void fabs() {
    if (getKnownFPClasses() & fcNegZero)
      setKnownFPClasses(getKnownFPClasses() | fcPosZero);
 
    if (getKnownFPClasses() & fcNegInf)
      setKnownFPClasses(getKnownFPClasses() | fcPosInf);
 
    if (getKnownFPClasses() & fcNegSubnormal)
      setKnownFPClasses(getKnownFPClasses() | fcPosSubnormal);
 
    if (getKnownFPClasses() & fcNegNormal)
      setKnownFPClasses(getKnownFPClasses() | fcPosNormal);
 
    signBitMustBeZero();
  }
 
  static KnownFPClass fabs(const KnownFPClass &Src) {
    KnownFPClass Known = Src;
    Known.fabs();
    return Known;
  }
 
  // Enum of min/max intrinsics to avoid dependency on IR.
  enum class MinMaxKind {
    minimum,
    maximum,
    minimumnum,
    maximumnum,
    minnum,
    maxnum
  };
 
  LLVM_ABI static KnownFPClass
  minMaxLike(const KnownFPClass &LHS, const KnownFPClass &RHS, MinMaxKind Kind,
             DenormalMode DenormMode = DenormalMode::getDynamic());
 
  /// Apply the canonicalize intrinsic to this value. This is essentially a
  /// stronger form of propagateCanonicalizingSrc.
  LLVM_ABI static KnownFPClass
  canonicalize(const KnownFPClass &Src,
               DenormalMode DenormMode = DenormalMode::getDynamic());
 
  /// Report known values for a bitcast into a float with provided semantics.
  LLVM_ABI static KnownFPClass bitcast(const fltSemantics &FltSemantics,
                                       const KnownBits &Bits);
 
  /// Report known bits for a float with provided semantics.
  LLVM_ABI KnownBits toKnownBits(const fltSemantics &FltSemantics) const;
 
  /// Report known values for fadd
  LLVM_ABI static KnownFPClass
  fadd(const KnownFPClass &LHS, const KnownFPClass &RHS,
       DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fadd x, x
  LLVM_ABI static KnownFPClass
  fadd_self(const KnownFPClass &Src,
            DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fsub
  LLVM_ABI static KnownFPClass
  fsub(const KnownFPClass &LHS, const KnownFPClass &RHS,
       DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fmul
  LLVM_ABI static KnownFPClass
  fmul(const KnownFPClass &LHS, const KnownFPClass &RHS,
       DenormalMode Mode = DenormalMode::getDynamic());
 
  // Special case of fmul x, x.
  static KnownFPClass square(const KnownFPClass &Src,
                             DenormalMode Mode = DenormalMode::getDynamic()) {
    KnownFPClass Known = fmul(Src, Src, Mode);
 
    // X * X is always non-negative or a NaN.
    Known.knownNot(fcNegative);
    Known.propagateNonNaN(Src);
    return Known;
  }
 
  LLVM_ABI static KnownFPClass
  fmul(const KnownFPClass &LHS, const APFloat &RHS,
       DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fdiv
  LLVM_ABI static KnownFPClass
  fdiv(const KnownFPClass &LHS, const KnownFPClass &RHS,
       DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fdiv x, x
  LLVM_ABI static KnownFPClass
  fdiv_self(const KnownFPClass &Src,
            DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for frem
  LLVM_ABI static KnownFPClass
  frem(const KnownFPClass &LHS, const KnownFPClass &RHS,
       DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for frem x, x
  LLVM_ABI static KnownFPClass
  frem_self(const KnownFPClass &Src,
            DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fma
  LLVM_ABI static KnownFPClass
  fma(const KnownFPClass &LHS, const KnownFPClass &RHS,
      const KnownFPClass &Addend,
      DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Report known values for fma squared, squared, addend
  LLVM_ABI static KnownFPClass
  fma_square(const KnownFPClass &Squared, const KnownFPClass &Addend,
             DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Propagate known class for sqrt
  LLVM_ABI static KnownFPClass
  sqrt(const KnownFPClass &Src, DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Propagate known class for log/log2/log10
  ///
  /// \p IsMultiUnitFPType if this is for a multi-unit floating-point type.
  LLVM_ABI static KnownFPClass log(const KnownFPClass &Src, DenormalMode Mode,
                                   bool IsMultiUnitFPType);
 
  /// Report known values for exp, exp2 and exp10.
  /// This function assumes that exp10(-1.0) = +0.1 and exp10(+1.0) = +10.0 are
  /// both finite normal values, which holds for formats with a corresponding
  /// LLVM IR type (e.g. does not hold for Float4E2M1FN).
  LLVM_ABI static KnownFPClass exp(const KnownFPClass &Src);
 
  /// Report known values for sin
  LLVM_ABI static KnownFPClass sin(const KnownFPClass &Src);
 
  /// Report known values for cos
  LLVM_ABI static KnownFPClass cos(const KnownFPClass &Src);
 
  /// Report known values for tan
  LLVM_ABI static KnownFPClass tan(const KnownFPClass &Src);
 
  /// Report known values for sinh
  LLVM_ABI static KnownFPClass sinh(const KnownFPClass &Src);
 
  /// Report known values for cosh
  LLVM_ABI static KnownFPClass cosh(const KnownFPClass &Src);
 
  /// Report known values for tanh
  LLVM_ABI static KnownFPClass tanh(const KnownFPClass &Src);
 
  /// Report known values for asin
  LLVM_ABI static KnownFPClass asin(const KnownFPClass &Src);
 
  /// Report known values for acos
  LLVM_ABI static KnownFPClass acos(const KnownFPClass &Src);
 
  /// Report known values for atan
  LLVM_ABI static KnownFPClass atan(const KnownFPClass &Src);
 
  /// Report known values for atan2
  LLVM_ABI static KnownFPClass
  atan2(const KnownFPClass &LHS, const KnownFPClass &RHS,
        DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Return true if the sign bit must be 0, ignoring the sign of nans.
  bool signBitIsZeroOrNaN() const { return isKnownNever(fcNegative); }
 
  /// Assume the sign bit is zero.
  void signBitMustBeZero() {
    setKnownFPClasses(getKnownFPClasses() & (fcPositive | fcNan));
    setSignBit(false);
  }
 
  /// Assume the sign bit is one.
  void signBitMustBeOne() {
    setKnownFPClasses(getKnownFPClasses() & (fcNegative | fcNan));
    setSignBit(true);
  }
 
  void copysign(const KnownFPClass &Sign) {
    // Don't know anything about the sign of the source. Expand the possible set
    // to its opposite sign pair.
    if (getKnownFPClasses() & fcZero)
      setKnownFPClasses(getKnownFPClasses() | fcZero);
    if (getKnownFPClasses() & fcSubnormal)
      setKnownFPClasses(getKnownFPClasses() | fcSubnormal);
    if (getKnownFPClasses() & fcNormal)
      setKnownFPClasses(getKnownFPClasses() | fcNormal);
    if (getKnownFPClasses() & fcInf)
      setKnownFPClasses(getKnownFPClasses() | fcInf);
 
    // Sign bit is exactly preserved even for nans.
    setSignBit(Sign.getSignBit());
 
    // Clear sign bits based on the input sign mask.
    if (Sign.isKnownNever(fcPositive | fcNan) ||
        (getSignBit() && *getSignBit()))
      setKnownFPClasses(getKnownFPClasses() & (fcNegative | fcNan));
    if (Sign.isKnownNever(fcNegative | fcNan) ||
        (getSignBit() && !*getSignBit()))
      setKnownFPClasses(getKnownFPClasses() & (fcPositive | fcNan));
  }
 
  static KnownFPClass copysign(const KnownFPClass &KnownMag,
                               const KnownFPClass &KnownSign) {
    KnownFPClass Known = KnownMag;
    Known.copysign(KnownSign);
    return Known;
  }
 
  // Propagate knowledge that an operation cannot introduce a signaling NaN.
  void propagateNonSNaN(const KnownFPClass &Src) {
    if (Src.isKnownNever(fcSNan))
      knownNot(fcSNan);
  }
 
  // Propagate knowledge that an operation cannot introduce a signaling NaN.
  void propagateNonSNaN(const KnownFPClass &LHS, const KnownFPClass &RHS) {
    if (LHS.isKnownNever(fcSNan) && RHS.isKnownNever(fcSNan))
      knownNot(fcSNan);
  }
 
  // Propagate knowledge that a non-NaN source implies the result can also not
  // be a NaN. For unconstrained operations, signaling nans are not guaranteed
  // to be quieted but cannot be introduced.
  void propagateNonNaN(const KnownFPClass &Src) {
    propagateNonSNaN(Src);
    if (Src.isKnownNever(fcNan))
      knownNot(fcNan);
  }
 
  void propagateNonNaN(const KnownFPClass &LHS, const KnownFPClass &RHS) {
    propagateNonSNaN(LHS, RHS);
    if (LHS.isKnownNeverNaN() && RHS.isKnownNeverNaN())
      knownNot(fcNan);
  }
 
  /// Propagate knowledge from a source value that could be a denormal or
  /// zero. We have to be conservative since output flushing is not guaranteed,
  /// so known-never-zero may not hold.
  ///
  /// This assumes a copy-like operation and will replace any currently known
  /// information.
  LLVM_ABI void propagateDenormal(const KnownFPClass &Src, DenormalMode Mode);
 
  /// Report known classes if \p Src is evaluated through a potentially
  /// canonicalizing operation. We can assume signaling nans will not be
  /// introduced, but cannot assume a denormal will be flushed under FTZ/DAZ.
  ///
  /// This assumes a copy-like operation and will replace any currently known
  /// information.
  LLVM_ABI void propagateCanonicalizingSrc(const KnownFPClass &Src,
                                           DenormalMode Mode);
 
  /// Propagate known class for fpext.
  LLVM_ABI static KnownFPClass fpext(const KnownFPClass &KnownSrc,
                                     const fltSemantics &DstTy,
                                     const fltSemantics &SrcTy);
 
  /// Propagate known class for fptrunc.
  LLVM_ABI static KnownFPClass fptrunc(const KnownFPClass &KnownSrc);
 
  /// Propagate known class for rounding intrinsics (trunc, floor, ceil, rint,
  /// nearbyint, round, roundeven). This is trunc if \p IsTrunc. \p
  /// IsMultiUnitFPType if this is for a multi-unit floating-point type.
  LLVM_ABI static KnownFPClass
  roundToIntegral(const KnownFPClass &Src, bool IsTrunc, bool IsMultiUnitFPType,
                  DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Propagate known class for mantissa component of frexp
  LLVM_ABI static KnownFPClass
  frexp_mant(const KnownFPClass &Src,
             DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Propagate known class for ldexp, assuming the exponent is known to be
  /// within [\p ConstantRangeMin, \p ConstantRangeMax]
  ///
  // TODO: This really ought to use ConstantRange, but it's in IR not Support.
  LLVM_ABI static KnownFPClass
  ldexp(const KnownFPClass &Src, const APInt &ConstantRangeMin,
        const APInt &ConstantRangeMax, const fltSemantics &Flt,
        DenormalMode Mode = DenormalMode::getDynamic());
  LLVM_ABI static KnownFPClass
  ldexp(const KnownFPClass &Src, const KnownBits &ExpBits,
        const fltSemantics &Flt,
        DenormalMode Mode = DenormalMode::getDynamic());
 
  /// Propagate known class for pow
  LLVM_ABI static KnownFPClass pow(const KnownFPClass &LHS,
                                   const KnownFPClass &RHS);
 
  /// Propagate known class for powi
  LLVM_ABI static KnownFPClass powi(const KnownFPClass &Src,
                                    const KnownBits &N);
 
  void resetAll() { *this = KnownFPClass(); }
};
 
inline KnownFPClass operator|(KnownFPClass LHS, const KnownFPClass &RHS) {
  LHS |= RHS;
  return LHS;
}
 
inline KnownFPClass operator|(const KnownFPClass &LHS, KnownFPClass &&RHS) {
  RHS |= LHS;
  return std::move(RHS);
}
 
} // namespace llvm
 
#endif