1//===--- Integral.h - Wrapper for numeric types for the VM ------*- 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// Defines the VM types and helpers operating on types.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_INTERP_INTEGRAL_H
14#define LLVM_CLANG_AST_INTERP_INTEGRAL_H
15
16#include "clang/AST/ComparisonCategories.h"
17#include "clang/AST/APValue.h"
18#include "llvm/ADT/APSInt.h"
19#include "llvm/Support/MathExtras.h"
20#include "llvm/Support/raw_ostream.h"
21#include <cstddef>
22#include <cstdint>
23
24namespace clang {
25namespace interp {
26
27using APInt = llvm::APInt;
28using APSInt = llvm::APSInt;
29
30/// Helper to compare two comparable types.
31template <typename T>
32ComparisonCategoryResult Compare(const T &X, const T &Y) {
33  if (X < Y)
34    return ComparisonCategoryResult::Less;
35  if (X > Y)
36    return ComparisonCategoryResult::Greater;
37  return ComparisonCategoryResult::Equal;
38}
39
40// Helper structure to select the representation.
41template <unsigned Bits, bool Signed> struct Repr;
42template <> struct Repr<8, false> { using Type = uint8_t; };
43template <> struct Repr<16, false> { using Type = uint16_t; };
44template <> struct Repr<32, false> { using Type = uint32_t; };
45template <> struct Repr<64, false> { using Type = uint64_t; };
46template <> struct Repr<8, true> { using Type = int8_t; };
47template <> struct Repr<16, true> { using Type = int16_t; };
48template <> struct Repr<32, true> { using Type = int32_t; };
49template <> struct Repr<64, true> { using Type = int64_t; };
50
51/// Wrapper around numeric types.
52///
53/// These wrappers are required to shared an interface between APSint and
54/// builtin primitive numeral types, while optimising for storage and
55/// allowing methods operating on primitive type to compile to fast code.
56template <unsigned Bits, bool Signed> class Integral {
57private:
58  template <unsigned OtherBits, bool OtherSigned> friend class Integral;
59
60  // The primitive representing the integral.
61  using T = typename Repr<Bits, Signed>::Type;
62  T V;
63
64  /// Primitive representing limits.
65  static const auto Min = std::numeric_limits<T>::min();
66  static const auto Max = std::numeric_limits<T>::max();
67
68  /// Construct an integral from anything that is convertible to storage.
69  template <typename T> explicit Integral(T V) : V(V) {}
70
71public:
72  /// Zero-initializes an integral.
73  Integral() : V(0) {}
74
75  /// Constructs an integral from another integral.
76  template <unsigned SrcBits, bool SrcSign>
77  explicit Integral(Integral<SrcBits, SrcSign> V) : V(V.V) {}
78
79  /// Construct an integral from a value based on signedness.
80  explicit Integral(const APSInt &V)
81      : V(V.isSigned() ? V.getSExtValue() : V.getZExtValue()) {}
82
83  bool operator<(Integral RHS) const { return V < RHS.V; }
84  bool operator>(Integral RHS) const { return V > RHS.V; }
85  bool operator<=(Integral RHS) const { return V <= RHS.V; }
86  bool operator>=(Integral RHS) const { return V >= RHS.V; }
87  bool operator==(Integral RHS) const { return V == RHS.V; }
88  bool operator!=(Integral RHS) const { return V != RHS.V; }
89
90  bool operator>(unsigned RHS) const {
91    return V >= 0 && static_cast<unsigned>(V) > RHS;
92  }
93
94  Integral operator-() const { return Integral(-V); }
95  Integral operator~() const { return Integral(~V); }
96
97  template <unsigned DstBits, bool DstSign>
98  explicit operator Integral<DstBits, DstSign>() const {
99    return Integral<DstBits, DstSign>(V);
100  }
101
102  explicit operator unsigned() const { return V; }
103  explicit operator int64_t() const { return V; }
104  explicit operator uint64_t() const { return V; }
105
106  APSInt toAPSInt() const {
107    return APSInt(APInt(Bits, static_cast<uint64_t>(V), Signed), !Signed);
108  }
109  APSInt toAPSInt(unsigned NumBits) const {
110    if (Signed)
111      return APSInt(toAPSInt().sextOrTrunc(NumBits), !Signed);
112    else
113      return APSInt(toAPSInt().zextOrTrunc(NumBits), !Signed);
114  }
115  APValue toAPValue() const { return APValue(toAPSInt()); }
116
117  Integral<Bits, false> toUnsigned() const {
118    return Integral<Bits, false>(*this);
119  }
120
121  constexpr static unsigned bitWidth() { return Bits; }
122
123  bool isZero() const { return !V; }
124
125  bool isMin() const { return *this == min(bitWidth()); }
126
127  bool isMinusOne() const { return Signed && V == T(-1); }
128
129  constexpr static bool isSigned() { return Signed; }
130
131  bool isNegative() const { return V < T(0); }
132  bool isPositive() const { return !isNegative(); }
133
134  ComparisonCategoryResult compare(const Integral &RHS) const {
135    return Compare(V, RHS.V);
136  }
137
138  unsigned countLeadingZeros() const { return llvm::countLeadingZeros<T>(V); }
139
140  Integral truncate(unsigned TruncBits) const {
141    if (TruncBits >= Bits)
142      return *this;
143    const T BitMask = (T(1) << T(TruncBits)) - 1;
144    const T SignBit = T(1) << (TruncBits - 1);
145    const T ExtMask = ~BitMask;
146    return Integral((V & BitMask) | (Signed && (V & SignBit) ? ExtMask : 0));
147  }
148
149  void print(llvm::raw_ostream &OS) const { OS << V; }
150
151  static Integral min(unsigned NumBits) {
152    return Integral(Min);
153  }
154  static Integral max(unsigned NumBits) {
155    return Integral(Max);
156  }
157
158  template <typename T>
159  static typename std::enable_if<std::is_integral<T>::value, Integral>::type
160  from(T Value) {
161    return Integral(Value);
162  }
163
164  template <unsigned SrcBits, bool SrcSign>
165  static typename std::enable_if<SrcBits != 0, Integral>::type
166  from(Integral<SrcBits, SrcSign> Value) {
167    return Integral(Value.V);
168  }
169
170  template <bool SrcSign> static Integral from(Integral<0, SrcSign> Value) {
171    if (SrcSign)
172      return Integral(Value.V.getSExtValue());
173    else
174      return Integral(Value.V.getZExtValue());
175  }
176
177  static Integral zero() { return from(0); }
178
179  template <typename T> static Integral from(T Value, unsigned NumBits) {
180    return Integral(Value);
181  }
182
183  static bool inRange(int64_t Value, unsigned NumBits) {
184    return CheckRange<T, Min, Max>(Value);
185  }
186
187  static bool increment(Integral A, Integral *R) {
188    return add(A, Integral(T(1)), A.bitWidth(), R);
189  }
190
191  static bool decrement(Integral A, Integral *R) {
192    return sub(A, Integral(T(1)), A.bitWidth(), R);
193  }
194
195  static bool add(Integral A, Integral B, unsigned OpBits, Integral *R) {
196    return CheckAddUB(A.V, B.V, R->V);
197  }
198
199  static bool sub(Integral A, Integral B, unsigned OpBits, Integral *R) {
200    return CheckSubUB(A.V, B.V, R->V);
201  }
202
203  static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
204    return CheckMulUB(A.V, B.V, R->V);
205  }
206
207private:
208  template <typename T>
209  static typename std::enable_if<std::is_signed<T>::value, bool>::type
210  CheckAddUB(T A, T B, T &R) {
211    return llvm::AddOverflow<T>(A, B, R);
212  }
213
214  template <typename T>
215  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
216  CheckAddUB(T A, T B, T &R) {
217    R = A + B;
218    return false;
219  }
220
221  template <typename T>
222  static typename std::enable_if<std::is_signed<T>::value, bool>::type
223  CheckSubUB(T A, T B, T &R) {
224    return llvm::SubOverflow<T>(A, B, R);
225  }
226
227  template <typename T>
228  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
229  CheckSubUB(T A, T B, T &R) {
230    R = A - B;
231    return false;
232  }
233
234  template <typename T>
235  static typename std::enable_if<std::is_signed<T>::value, bool>::type
236  CheckMulUB(T A, T B, T &R) {
237    return llvm::MulOverflow<T>(A, B, R);
238  }
239
240  template <typename T>
241  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
242  CheckMulUB(T A, T B, T &R) {
243    R = A * B;
244    return false;
245  }
246
247  template <typename T, T Min, T Max>
248  static typename std::enable_if<std::is_signed<T>::value, bool>::type
249  CheckRange(int64_t V) {
250    return Min <= V && V <= Max;
251  }
252
253  template <typename T, T Min, T Max>
254  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
255  CheckRange(int64_t V) {
256    return V >= 0 && static_cast<uint64_t>(V) <= Max;
257  }
258};
259
260template <unsigned Bits, bool Signed>
261llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Integral<Bits, Signed> I) {
262  I.print(OS);
263  return OS;
264}
265
266} // namespace interp
267} // namespace clang
268
269#endif
270