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 24 namespace clang { 25 namespace interp { 26 27 using APInt = llvm::APInt; 28 using APSInt = llvm::APSInt; 29 30 /// Helper to compare two comparable types. 31 template <typename T> 32 ComparisonCategoryResult 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. 41 template <unsigned Bits, bool Signed> struct Repr; 42 template <> struct Repr<8, false> { using Type = uint8_t; }; 43 template <> struct Repr<16, false> { using Type = uint16_t; }; 44 template <> struct Repr<32, false> { using Type = uint32_t; }; 45 template <> struct Repr<64, false> { using Type = uint64_t; }; 46 template <> struct Repr<8, true> { using Type = int8_t; }; 47 template <> struct Repr<16, true> { using Type = int16_t; }; 48 template <> struct Repr<32, true> { using Type = int32_t; }; 49 template <> 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. 56 template <unsigned Bits, bool Signed> class Integral { 57 private: 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 71 public: 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 207 private: 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 260 template <unsigned Bits, bool Signed> 261 llvm::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