Clang Project

clang_source_code/include/clang/Basic/FixedPoint.h
1//===- FixedPoint.h - Fixed point constant handling -------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the fixed point number interface.
11/// This is a class for abstracting various operations performed on fixed point
12/// types described in ISO/IEC JTC1 SC22 WG14 N1169 starting at clause 4.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_CLANG_BASIC_FIXEDPOINT_H
17#define LLVM_CLANG_BASIC_FIXEDPOINT_H
18
19#include "llvm/ADT/APSInt.h"
20#include "llvm/ADT/SmallString.h"
21#include "llvm/Support/raw_ostream.h"
22
23namespace clang {
24
25class ASTContext;
26class QualType;
27
28/// The fixed point semantics work similarly to llvm::fltSemantics. The width
29/// specifies the whole bit width of the underlying scaled integer (with padding
30/// if any). The scale represents the number of fractional bits in this type.
31/// When HasUnsignedPadding is true and this type is signed, the first bit
32/// in the value this represents is treaded as padding.
33class FixedPointSemantics {
34public:
35  FixedPointSemantics(unsigned Width, unsigned Scale, bool IsSigned,
36                      bool IsSaturated, bool HasUnsignedPadding)
37      : Width(Width), Scale(Scale), IsSigned(IsSigned),
38        IsSaturated(IsSaturated), HasUnsignedPadding(HasUnsignedPadding) {
39     (0) . __assert_fail ("Width >= Scale && \"Not enough room for the scale\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Basic/FixedPoint.h", 39, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Width >= Scale && "Not enough room for the scale");
40     (0) . __assert_fail ("!(IsSigned && HasUnsignedPadding) && \"Cannot have unsigned padding on a signed type.\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Basic/FixedPoint.h", 41, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(!(IsSigned && HasUnsignedPadding) &&
41 (0) . __assert_fail ("!(IsSigned && HasUnsignedPadding) && \"Cannot have unsigned padding on a signed type.\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Basic/FixedPoint.h", 41, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">           "Cannot have unsigned padding on a signed type.");
42  }
43
44  unsigned getWidth() const { return Width; }
45  unsigned getScale() const { return Scale; }
46  bool isSigned() const { return IsSigned; }
47  bool isSaturated() const { return IsSaturated; }
48  bool hasUnsignedPadding() const { return HasUnsignedPadding; }
49
50  void setSaturated(bool Saturated) { IsSaturated = Saturated; }
51
52  /// Return the number of integral bits represented by these semantics. These
53  /// are separate from the fractional bits and do not include the sign or
54  /// padding bit.
55  unsigned getIntegralBits() const {
56    if (IsSigned || (!IsSigned && HasUnsignedPadding))
57      return Width - Scale - 1;
58    else
59      return Width - Scale;
60  }
61
62  /// Return the FixedPointSemantics that allows for calculating the full
63  /// precision semantic that can precisely represent the precision and ranges
64  /// of both input values. This does not compute the resulting semantics for a
65  /// given binary operation.
66  FixedPointSemantics
67  getCommonSemantics(const FixedPointSemantics &Other) const;
68
69  /// Return the FixedPointSemantics for an integer type.
70  static FixedPointSemantics GetIntegerSemantics(unsigned Width,
71                                                 bool IsSigned) {
72    return FixedPointSemantics(Width, /*Scale=*/0, IsSigned,
73                               /*IsSaturated=*/false,
74                               /*HasUnsignedPadding=*/false);
75  }
76
77private:
78  unsigned Width;
79  unsigned Scale;
80  bool IsSigned;
81  bool IsSaturated;
82  bool HasUnsignedPadding;
83};
84
85/// The APFixedPoint class works similarly to APInt/APSInt in that it is a
86/// functional replacement for a scaled integer. It is meant to replicate the
87/// fixed point types proposed in ISO/IEC JTC1 SC22 WG14 N1169. The class carries
88/// info about the fixed point type's width, sign, scale, and saturation, and
89/// provides different operations that would normally be performed on fixed point
90/// types.
91///
92/// Semantically this does not represent any existing C type other than fixed
93/// point types and should eventually be moved to LLVM if fixed point types gain
94/// native IR support.
95class APFixedPoint {
96 public:
97   APFixedPoint(const llvm::APInt &Val, const FixedPointSemantics &Sema)
98       : Val(Val, !Sema.isSigned()), Sema(Sema) {
99      (0) . __assert_fail ("Val.getBitWidth() == Sema.getWidth() && \"The value should have a bit width that matches the Sema width\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Basic/FixedPoint.h", 100, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Val.getBitWidth() == Sema.getWidth() &&
100 (0) . __assert_fail ("Val.getBitWidth() == Sema.getWidth() && \"The value should have a bit width that matches the Sema width\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Basic/FixedPoint.h", 100, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">            "The value should have a bit width that matches the Sema width");
101   }
102
103   APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema)
104       : APFixedPoint(llvm::APInt(Sema.getWidth(), Val, Sema.isSigned()),
105                      Sema) {}
106
107   // Zero initialization.
108   APFixedPoint(const FixedPointSemantics &Sema) : APFixedPoint(0, Sema) {}
109
110   llvm::APSInt getValue() const { return llvm::APSInt(Val, !Sema.isSigned()); }
111   inline unsigned getWidth() const { return Sema.getWidth(); }
112   inline unsigned getScale() const { return Sema.getScale(); }
113   inline bool isSaturated() const { return Sema.isSaturated(); }
114   inline bool isSigned() const { return Sema.isSigned(); }
115   inline bool hasPadding() const { return Sema.hasUnsignedPadding(); }
116   FixedPointSemantics getSemantics() const { return Sema; }
117
118   bool getBoolValue() const { return Val.getBoolValue(); }
119
120   // Convert this number to match the semantics provided. If the overflow
121   // parameter is provided, set this value to true or false to indicate if this
122   // operation results in an overflow.
123   APFixedPoint convert(const FixedPointSemantics &DstSema,
124                        bool *Overflow = nullptr) const;
125
126   // Perform binary operations on a fixed point type. The resulting fixed point
127   // value will be in the common, full precision semantics that can represent
128   // the precision and ranges os both input values. See convert() for an
129   // explanation of the Overflow parameter.
130   APFixedPoint add(const APFixedPoint &Other, bool *Overflow = nullptr) const;
131
132   /// Perform a unary negation (-X) on this fixed point type, taking into
133   /// account saturation if applicable.
134   APFixedPoint negate(bool *Overflow = nullptr) const;
135
136   APFixedPoint shr(unsigned Amt) const {
137     return APFixedPoint(Val >> Amt, Sema);
138   }
139
140  APFixedPoint shl(unsigned Amt) const {
141    return APFixedPoint(Val << Amt, Sema);
142  }
143
144  /// Return the integral part of this fixed point number, rounded towards
145  /// zero. (-2.5k -> -2)
146  llvm::APSInt getIntPart() const {
147    if (Val < 0 && Val != -Val) // Cover the case when we have the min val
148      return -(-Val >> getScale());
149    else
150      return Val >> getScale();
151  }
152
153  /// Return the integral part of this fixed point number, rounded towards
154  /// zero. The value is stored into an APSInt with the provided width and sign.
155  /// If the overflow parameter is provided, and the integral value is not able
156  /// to be fully stored in the provided width and sign, the overflow parameter
157  /// is set to true.
158  ///
159  /// If the overflow parameter is provided, set this value to true or false to
160  /// indicate if this operation results in an overflow.
161  llvm::APSInt convertToInt(unsigned DstWidth, bool DstSign,
162                            bool *Overflow = nullptr) const;
163
164  void toString(llvm::SmallVectorImpl<char> &Str) const;
165  std::string toString() const {
166    llvm::SmallString<40> S;
167    toString(S);
168    return S.str();
169  }
170
171  // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1.
172  int compare(const APFixedPoint &Other) const;
173  bool operator==(const APFixedPoint &Other) const {
174    return compare(Other) == 0;
175  }
176  bool operator!=(const APFixedPoint &Other) const {
177    return compare(Other) != 0;
178  }
179  bool operator>(const APFixedPoint &Other) const { return compare(Other) > 0; }
180  bool operator<(const APFixedPoint &Other) const { return compare(Other) < 0; }
181  bool operator>=(const APFixedPoint &Other) const {
182    return compare(Other) >= 0;
183  }
184  bool operator<=(const APFixedPoint &Other) const {
185    return compare(Other) <= 0;
186  }
187
188  static APFixedPoint getMax(const FixedPointSemantics &Sema);
189  static APFixedPoint getMin(const FixedPointSemantics &Sema);
190
191  /// Create an APFixedPoint with a value equal to that of the provided integer,
192  /// and in the same semantics as the provided target semantics. If the value
193  /// is not able to fit in the specified fixed point semantics, and the
194  /// overflow parameter is provided, it is set to true.
195  static APFixedPoint getFromIntValue(const llvm::APSInt &Value,
196                                      const FixedPointSemantics &DstFXSema,
197                                      bool *Overflow = nullptr);
198
199private:
200  llvm::APSInt Val;
201  FixedPointSemantics Sema;
202};
203
204inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
205                                     const APFixedPoint &FX) {
206  OS << FX.toString();
207  return OS;
208}
209
210}  // namespace clang
211
212#endif
213
clang::FixedPointSemantics::getWidth
clang::FixedPointSemantics::getScale
clang::FixedPointSemantics::isSigned
clang::FixedPointSemantics::isSaturated
clang::FixedPointSemantics::hasUnsignedPadding
clang::FixedPointSemantics::setSaturated
clang::FixedPointSemantics::getIntegralBits
clang::FixedPointSemantics::getCommonSemantics
clang::FixedPointSemantics::GetIntegerSemantics
clang::FixedPointSemantics::Width
clang::FixedPointSemantics::Scale
clang::FixedPointSemantics::IsSigned
clang::FixedPointSemantics::IsSaturated
clang::FixedPointSemantics::HasUnsignedPadding
clang::APFixedPoint::getValue
clang::APFixedPoint::getWidth
clang::APFixedPoint::getScale
clang::APFixedPoint::isSaturated
clang::APFixedPoint::isSigned
clang::APFixedPoint::hasPadding
clang::APFixedPoint::getSemantics
clang::APFixedPoint::getBoolValue
clang::APFixedPoint::convert
clang::APFixedPoint::add
clang::APFixedPoint::negate
clang::APFixedPoint::shr
clang::APFixedPoint::shl
clang::APFixedPoint::getIntPart
clang::APFixedPoint::convertToInt
clang::APFixedPoint::toString
clang::APFixedPoint::toString
clang::APFixedPoint::compare
clang::APFixedPoint::getMax
clang::APFixedPoint::getMin
clang::APFixedPoint::getFromIntValue
clang::APFixedPoint::Val
clang::APFixedPoint::Sema
clang::APFixedPoint::toString
clang::APFixedPoint::toString
clang::APFixedPoint::getFromIntValue
CodeThinker, Enjoy your reading code