Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- APFixedPoint.h - Fixed point constant handling -----------*- 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

//

//===----------------------------------------------------------------------===//

///

/// \file

/// Defines the fixed point number interface.

/// This is a class for abstracting various operations performed on fixed point

/// types.

///

//===----------------------------------------------------------------------===//

#ifndef LLVM_ADT_APFIXEDPOINT_H

#define LLVM_ADT_APFIXEDPOINT_H

#include "llvm/ADT/APSInt.h"

#include "llvm/ADT/DenseMapInfo.h"

#include "llvm/ADT/Hashing.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/Support/raw_ostream.h"

namespace llvm {

class APFloat;

struct fltSemantics;

/// The fixed point semantics work similarly to fltSemantics. The width

/// specifies the whole bit width of the underlying scaled integer (with padding

/// if any). The scale represents the number of fractional bits in this type.

/// When HasUnsignedPadding is true and this type is unsigned, the first bit

/// in the value this represents is treated as padding.

class FixedPointSemantics {

public:

  static constexpr unsigned WidthBitWidth = 16;

  static constexpr unsigned LsbWeightBitWidth = 13;

  /// Used to differentiate between constructors with Width and Lsb from the

  /// default Width and scale

  struct Lsb {

    int LsbWeight;

  };

  FixedPointSemantics(unsigned Width, unsigned Scale, bool IsSigned,

                      bool IsSaturated, bool HasUnsignedPadding)

      : FixedPointSemantics(Width, Lsb{-static_cast<int>(Scale)}, IsSigned,

                            IsSaturated, HasUnsignedPadding) {}

  FixedPointSemantics(unsigned Width, Lsb Weight, bool IsSigned,

                      bool IsSaturated, bool HasUnsignedPadding)

      : Width(Width), LsbWeight(Weight.LsbWeight), IsSigned(IsSigned),

        IsSaturated(IsSaturated), HasUnsignedPadding(HasUnsignedPadding) {

    assert(isUInt<WidthBitWidth>(Width) && isInt<LsbWeightBitWidth>(Weight.LsbWeight));

    assert(!(IsSigned && HasUnsignedPadding) &&

           "Cannot have unsigned padding on a signed type.");

  }

  /// Check if the Semantic follow the requirements of an older more limited

  /// version of this class

  bool isValidLegacySema() const {

    return LsbWeight <= 0 && static_cast<int>(Width) >= -LsbWeight;

  }

  unsigned getWidth() const { return Width; }

  unsigned getScale() const { assert(isValidLegacySema()); return -LsbWeight; }

  int getLsbWeight() const { return LsbWeight; }

  int getMsbWeight() const {

    return LsbWeight + Width - 1 /*Both lsb and msb are both part of width*/;

  }

  bool isSigned() const { return IsSigned; }

  bool isSaturated() const { return IsSaturated; }

  bool hasUnsignedPadding() const { return HasUnsignedPadding; }

  void setSaturated(bool Saturated) { IsSaturated = Saturated; }

  /// return true if the first bit doesn't have a strictly positive weight

  bool hasSignOrPaddingBit() const { return IsSigned || HasUnsignedPadding; }

  /// Return the number of integral bits represented by these semantics. These

  /// are separate from the fractional bits and do not include the sign or

  /// padding bit.

  unsigned getIntegralBits() const {

    return std::max(getMsbWeight() + 1 - hasSignOrPaddingBit(), 0);

  }

  /// Return the FixedPointSemantics that allows for calculating the full

  /// precision semantic that can precisely represent the precision and ranges

  /// of both input values. This does not compute the resulting semantics for a

  /// given binary operation.

  FixedPointSemantics

  getCommonSemantics(const FixedPointSemantics &Other) const;

  /// Print semantics for debug purposes

  void print(llvm::raw_ostream& OS) const;

  /// Returns true if this fixed-point semantic with its value bits interpreted

  /// as an integer can fit in the given floating point semantic without

  /// overflowing to infinity.

  /// For example, a signed 8-bit fixed-point semantic has a maximum and

  /// minimum integer representation of 127 and -128, respectively. If both of

  /// these values can be represented (possibly inexactly) in the floating

  /// point semantic without overflowing, this returns true.

  bool fitsInFloatSemantics(const fltSemantics &FloatSema) const;

  /// Return the FixedPointSemantics for an integer type.

  static FixedPointSemantics GetIntegerSemantics(unsigned Width,

                                                 bool IsSigned) {

    return FixedPointSemantics(Width, /*Scale=*/0, IsSigned,

                               /*IsSaturated=*/false,

                               /*HasUnsignedPadding=*/false);

  }

  bool operator==(FixedPointSemantics Other) const {

    return Width == Other.Width && LsbWeight == Other.LsbWeight &&

           IsSigned == Other.IsSigned && IsSaturated == Other.IsSaturated &&

           HasUnsignedPadding == Other.HasUnsignedPadding;

  }

  bool operator!=(FixedPointSemantics Other) const { return !(*this == Other); }

private:

  unsigned Width          : WidthBitWidth;

  signed int LsbWeight    : LsbWeightBitWidth;

  unsigned IsSigned       : 1;

  unsigned IsSaturated    : 1;

  unsigned HasUnsignedPadding : 1;

};

static_assert(sizeof(FixedPointSemantics) == 4, "");

inline hash_code hash_value(const FixedPointSemantics &Val) {

  return hash_value(bit_cast<uint32_t>(Val));

}

template <> struct DenseMapInfo<FixedPointSemantics> {

  static inline FixedPointSemantics getEmptyKey() {

    return FixedPointSemantics(0, 0, false, false, false);

  }

  static inline FixedPointSemantics getTombstoneKey() {

    return FixedPointSemantics(0, 1, false, false, false);

  }

  static unsigned getHashValue(const FixedPointSemantics &Val) {

    return hash_value(Val);

  }

  static bool isEqual(const char &LHS, const char &RHS) { return LHS == RHS; }

};

/// The APFixedPoint class works similarly to APInt/APSInt in that it is a

/// functional replacement for a scaled integer. It supports a wide range of

/// semantics including the one used by fixed point types proposed in ISO/IEC

/// JTC1 SC22 WG14 N1169. The class carries the value and semantics of

/// a fixed point, and provides different operations that would normally be

/// performed on fixed point types.

class APFixedPoint {

public:

  APFixedPoint(const APInt &Val, const FixedPointSemantics &Sema)

      : Val(Val, !Sema.isSigned()), Sema(Sema) {

    assert(Val.getBitWidth() == Sema.getWidth() &&

           "The value should have a bit width that matches the Sema width");

  }

  APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema)

      : APFixedPoint(APInt(Sema.getWidth(), Val, Sema.isSigned()), Sema) {}

  // Zero initialization.

  APFixedPoint(const FixedPointSemantics &Sema) : APFixedPoint(0, Sema) {}

  APSInt getValue() const { return APSInt(Val, !Sema.isSigned()); }

  inline unsigned getWidth() const { return Sema.getWidth(); }

  inline unsigned getScale() const { return Sema.getScale(); }

  int getLsbWeight() const { return Sema.getLsbWeight(); }

  int getMsbWeight() const { return Sema.getMsbWeight(); }

  inline bool isSaturated() const { return Sema.isSaturated(); }

  inline bool isSigned() const { return Sema.isSigned(); }

  inline bool hasPadding() const { return Sema.hasUnsignedPadding(); }

  FixedPointSemantics getSemantics() const { return Sema; }

  bool getBoolValue() const { return Val.getBoolValue(); }

  // Convert this number to match the semantics provided. If the overflow

  // parameter is provided, set this value to true or false to indicate if this

  // operation results in an overflow.

  APFixedPoint convert(const FixedPointSemantics &DstSema,

                       bool *Overflow = nullptr) const;

  // Perform binary operations on a fixed point type. The resulting fixed point

  // value will be in the common, full precision semantics that can represent

  // the precision and ranges of both input values. See convert() for an

  // explanation of the Overflow parameter.

  APFixedPoint add(const APFixedPoint &Other, bool *Overflow = nullptr) const;

  APFixedPoint sub(const APFixedPoint &Other, bool *Overflow = nullptr) const;

  APFixedPoint mul(const APFixedPoint &Other, bool *Overflow = nullptr) const;

  APFixedPoint div(const APFixedPoint &Other, bool *Overflow = nullptr) const;

  // Perform shift operations on a fixed point type. Unlike the other binary

  // operations, the resulting fixed point value will be in the original

  // semantic.

  APFixedPoint shl(unsigned Amt, bool *Overflow = nullptr) const;

  APFixedPoint shr(unsigned Amt, bool *Overflow = nullptr) const {

    // Right shift cannot overflow.

    if (Overflow)

      *Overflow = false;

    return APFixedPoint(Val >> Amt, Sema);

  }

  /// Perform a unary negation (-X) on this fixed point type, taking into

  /// account saturation if applicable.

  APFixedPoint negate(bool *Overflow = nullptr) const;

  /// Return the integral part of this fixed point number, rounded towards

  /// zero. (-2.5k -> -2)

  APSInt getIntPart() const {

    if (getMsbWeight() < 0)

      return APSInt(APInt::getZero(getWidth()), Val.isUnsigned());

    APSInt ExtVal =

        (getLsbWeight() > 0) ? Val.extend(getWidth() + getLsbWeight()) : Val;

    if (Val < 0 && Val != -Val) // Cover the case when we have the min val

      return -((-ExtVal).relativeShl(getLsbWeight()));

    return ExtVal.relativeShl(getLsbWeight());

  }

  /// Return the integral part of this fixed point number, rounded towards

  /// zero. The value is stored into an APSInt with the provided width and sign.

  /// If the overflow parameter is provided, and the integral value is not able

  /// to be fully stored in the provided width and sign, the overflow parameter

  /// is set to true.

  APSInt convertToInt(unsigned DstWidth, bool DstSign,

                      bool *Overflow = nullptr) const;

  /// Convert this fixed point number to a floating point value with the

  /// provided semantics.

  APFloat convertToFloat(const fltSemantics &FloatSema) const;

  void toString(SmallVectorImpl<char> &Str) const;

  std::string toString() const {

    SmallString<40> S;

    toString(S);

    return std::string(S.str());

  }

  void print(raw_ostream &) const;

  void dump() const;

  // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1.

  int compare(const APFixedPoint &Other) const;

  bool operator==(const APFixedPoint &Other) const {

    return compare(Other) == 0;

  }

  bool operator!=(const APFixedPoint &Other) const {

    return compare(Other) != 0;

  }

  bool operator>(const APFixedPoint &Other) const { return compare(Other) > 0; }

  bool operator<(const APFixedPoint &Other) const { return compare(Other) < 0; }

  bool operator>=(const APFixedPoint &Other) const {

    return compare(Other) >= 0;

  }

  bool operator<=(const APFixedPoint &Other) const {

    return compare(Other) <= 0;

  }

  static APFixedPoint getMax(const FixedPointSemantics &Sema);

  static APFixedPoint getMin(const FixedPointSemantics &Sema);

  /// Given a floating point semantic, return the next floating point semantic

  /// with a larger exponent and larger or equal mantissa.

  static const fltSemantics *promoteFloatSemantics(const fltSemantics *S);

  /// Create an APFixedPoint with a value equal to that of the provided integer,

  /// and in the same semantics as the provided target semantics. If the value

  /// is not able to fit in the specified fixed point semantics, and the

  /// overflow parameter is provided, it is set to true.

  static APFixedPoint getFromIntValue(const APSInt &Value,

                                      const FixedPointSemantics &DstFXSema,

                                      bool *Overflow = nullptr);

  /// Create an APFixedPoint with a value equal to that of the provided

  /// floating point value, in the provided target semantics. If the value is

  /// not able to fit in the specified fixed point semantics and the overflow

  /// parameter is specified, it is set to true.

  /// For NaN, the Overflow flag is always set. For +inf and -inf, if the

  /// semantic is saturating, the value saturates. Otherwise, the Overflow flag

  /// is set.

  static APFixedPoint getFromFloatValue(const APFloat &Value,

                                        const FixedPointSemantics &DstFXSema,

                                        bool *Overflow = nullptr);

private:

  APSInt Val;

  FixedPointSemantics Sema;

};

inline raw_ostream &operator<<(raw_ostream &OS, const APFixedPoint &FX) {

  OS << FX.toString();

  return OS;

}

inline hash_code hash_value(const APFixedPoint &Val) {

  return hash_combine(Val.getSemantics(), Val.getValue());

}

template <> struct DenseMapInfo<APFixedPoint> {

  static inline APFixedPoint getEmptyKey() {

    return APFixedPoint(DenseMapInfo<FixedPointSemantics>::getEmptyKey());

  }

  static inline APFixedPoint getTombstoneKey() {

    return APFixedPoint(DenseMapInfo<FixedPointSemantics>::getTombstoneKey());

  }

  static unsigned getHashValue(const APFixedPoint &Val) {

    return hash_value(Val);

  }

  static bool isEqual(const APFixedPoint &LHS, const APFixedPoint &RHS) {

    return LHS.getSemantics() == RHS.getSemantics() &&

           LHS.getValue() == RHS.getValue();

  }

};

} // namespace llvm

#endif