contrib/llvm/tools/lldb/include/lldb/Utility/Scalar.h

   1 //===-- Scalar.h ------------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLDB_UTILITY_SCALAR_H
  11 #define LLDB_UTILITY_SCALAR_H
  12
  13 #include "lldb/Utility/Status.h"
  14 #include "lldb/lldb-enumerations.h"
  15 #include "lldb/lldb-private-types.h"
  16 #include "llvm/ADT/APFloat.h"
  17 #include "llvm/ADT/APInt.h"
  18 #include <cstddef>
  19 #include <cstdint>
  20
  21 namespace lldb_private {
  22 class DataExtractor;
  23 class Stream;
  24 } // namespace lldb_private
  25
  26 #define NUM_OF_WORDS_INT128 2
  27 #define BITWIDTH_INT128 128
  28 #define NUM_OF_WORDS_INT256 4
  29 #define BITWIDTH_INT256 256
  30
  31 namespace lldb_private {
  32
  33 //----------------------------------------------------------------------
  34 // A class designed to hold onto values and their corresponding types.
  35 // Operators are defined and Scalar objects will correctly promote their types
  36 // and values before performing these operations. Type promotion currently
  37 // follows the ANSI C type promotion rules.
  38 //----------------------------------------------------------------------
  39 class Scalar {
  40 public:
  41   enum Type {
  42     e_void = 0,
  43     e_sint,
  44     e_uint,
  45     e_slong,
  46     e_ulong,
  47     e_slonglong,
  48     e_ulonglong,
  49     e_sint128,
  50     e_uint128,
  51     e_sint256,
  52     e_uint256,
  53     e_float,
  54     e_double,
  55     e_long_double
  56   };
  57
  58   //------------------------------------------------------------------
  59   // Constructors and Destructors
  60   //------------------------------------------------------------------
  61   Scalar();
  62   Scalar(int v) : m_type(e_sint), m_float((float)0) {
  63     m_integer = llvm::APInt(sizeof(int) * 8, v, true);
  64   }
  65   Scalar(unsigned int v) : m_type(e_uint), m_float((float)0) {
  66     m_integer = llvm::APInt(sizeof(int) * 8, v);
  67   }
  68   Scalar(long v) : m_type(e_slong), m_float((float)0) {
  69     m_integer = llvm::APInt(sizeof(long) * 8, v, true);
  70   }
  71   Scalar(unsigned long v) : m_type(e_ulong), m_float((float)0) {
  72     m_integer = llvm::APInt(sizeof(long) * 8, v);
  73   }
  74   Scalar(long long v) : m_type(e_slonglong), m_float((float)0) {
  75     m_integer = llvm::APInt(sizeof(long long) * 8, v, true);
  76   }
  77   Scalar(unsigned long long v) : m_type(e_ulonglong), m_float((float)0) {
  78     m_integer = llvm::APInt(sizeof(long long) * 8, v);
  79   }
  80   Scalar(float v) : m_type(e_float), m_float(v) { m_float = llvm::APFloat(v); }
  81   Scalar(double v) : m_type(e_double), m_float(v) {
  82     m_float = llvm::APFloat(v);
  83   }
  84   Scalar(long double v, bool ieee_quad)
  85       : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad) {
  86     if (ieee_quad)
  87       m_float = llvm::APFloat(llvm::APFloat::IEEEquad(),
  88                               llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
  89                                           ((type128 *)&v)->x));
  90     else
  91       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
  92                               llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
  93                                           ((type128 *)&v)->x));
  94   }
  95   Scalar(llvm::APInt v) : m_type(), m_float((float)0) {
  96     m_integer = llvm::APInt(v);
  97     switch (m_integer.getBitWidth()) {
  98     case 8:
  99     case 16:
 100     case 32:
 101       if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
 102         m_type = e_sint;
 103       else
 104         m_type = e_uint;
 105       break;
 106     case 64:
 107       if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
 108         m_type = e_slonglong;
 109       else
 110         m_type = e_ulonglong;
 111       break;
 112     case 128:
 113       if (m_integer.isSignedIntN(BITWIDTH_INT128))
 114         m_type = e_sint128;
 115       else
 116         m_type = e_uint128;
 117       break;
 118     case 256:
 119       if (m_integer.isSignedIntN(BITWIDTH_INT256))
 120         m_type = e_sint256;
 121       else
 122         m_type = e_uint256;
 123       break;
 124     }
 125   }
 126   Scalar(const Scalar &rhs);
 127   // Scalar(const RegisterValue& reg_value);
 128   virtual ~Scalar();
 129
 130   bool SignExtend(uint32_t bit_pos);
 131
 132   bool ExtractBitfield(uint32_t bit_size, uint32_t bit_offset);
 133
 134   bool SetBit(uint32_t bit);
 135
 136   bool ClearBit(uint32_t bit);
 137
 138   const void *GetBytes() const;
 139
 140   size_t GetByteSize() const;
 141
 142   bool GetData(DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const;
 143
 144   size_t GetAsMemoryData(void *dst, size_t dst_len,
 145                          lldb::ByteOrder dst_byte_order, Status &error) const;
 146
 147   bool IsZero() const;
 148
 149   void Clear() {
 150     m_type = e_void;
 151     m_integer.clearAllBits();
 152   }
 153
 154   const char *GetTypeAsCString() const;
 155
 156   void GetValue(Stream *s, bool show_type) const;
 157
 158   bool IsValid() const {
 159     return (m_type >= e_sint) && (m_type <= e_long_double);
 160   }
 161
 162   bool Promote(Scalar::Type type);
 163
 164   bool MakeSigned();
 165
 166   bool MakeUnsigned();
 167
 168   static const char *GetValueTypeAsCString(Scalar::Type value_type);
 169
 170   static Scalar::Type
 171   GetValueTypeForSignedIntegerWithByteSize(size_t byte_size);
 172
 173   static Scalar::Type
 174   GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size);
 175
 176   static Scalar::Type GetValueTypeForFloatWithByteSize(size_t byte_size);
 177
 178   //----------------------------------------------------------------------
 179   // All operators can benefits from the implicit conversions that will happen
 180   // automagically by the compiler, so no temporary objects will need to be
 181   // created. As a result, we currently don't need a variety of overloaded set
 182   // value accessors.
 183   //----------------------------------------------------------------------
 184   Scalar &operator=(const int i);
 185   Scalar &operator=(unsigned int v);
 186   Scalar &operator=(long v);
 187   Scalar &operator=(unsigned long v);
 188   Scalar &operator=(long long v);
 189   Scalar &operator=(unsigned long long v);
 190   Scalar &operator=(float v);
 191   Scalar &operator=(double v);
 192   Scalar &operator=(long double v);
 193   Scalar &operator=(llvm::APInt v);
 194   Scalar &operator=(const Scalar &rhs); // Assignment operator
 195   Scalar &operator+=(const Scalar &rhs);
 196   Scalar &operator<<=(const Scalar &rhs); // Shift left
 197   Scalar &operator>>=(const Scalar &rhs); // Shift right (arithmetic)
 198   Scalar &operator&=(const Scalar &rhs);
 199
 200   //----------------------------------------------------------------------
 201   // Shifts the current value to the right without maintaining the current sign
 202   // of the value (if it is signed).
 203   //----------------------------------------------------------------------
 204   bool ShiftRightLogical(const Scalar &rhs); // Returns true on success
 205
 206   //----------------------------------------------------------------------
 207   // Takes the absolute value of the current value if it is signed, else the
 208   // value remains unchanged. Returns false if the contained value has a void
 209   // type.
 210   //----------------------------------------------------------------------
 211   bool AbsoluteValue(); // Returns true on success
 212   //----------------------------------------------------------------------
 213   // Negates the current value (even for unsigned values). Returns false if the
 214   // contained value has a void type.
 215   //----------------------------------------------------------------------
 216   bool UnaryNegate(); // Returns true on success
 217   //----------------------------------------------------------------------
 218   // Inverts all bits in the current value as long as it isn't void or a
 219   // float/double/long double type. Returns false if the contained value has a
 220   // void/float/double/long double type, else the value is inverted and true is
 221   // returned.
 222   //----------------------------------------------------------------------
 223   bool OnesComplement(); // Returns true on success
 224
 225   //----------------------------------------------------------------------
 226   // Access the type of the current value.
 227   //----------------------------------------------------------------------
 228   Scalar::Type GetType() const { return m_type; }
 229
 230   //----------------------------------------------------------------------
 231   // Returns a casted value of the current contained data without modifying the
 232   // current value. FAIL_VALUE will be returned if the type of the value is
 233   // void or invalid.
 234   //----------------------------------------------------------------------
 235   int SInt(int fail_value = 0) const;
 236
 237   unsigned char UChar(unsigned char fail_value = 0) const;
 238
 239   signed char SChar(char fail_value = 0) const;
 240
 241   unsigned short UShort(unsigned short fail_value = 0) const;
 242
 243   short SShort(short fail_value = 0) const;
 244
 245   unsigned int UInt(unsigned int fail_value = 0) const;
 246
 247   long SLong(long fail_value = 0) const;
 248
 249   unsigned long ULong(unsigned long fail_value = 0) const;
 250
 251   long long SLongLong(long long fail_value = 0) const;
 252
 253   unsigned long long ULongLong(unsigned long long fail_value = 0) const;
 254
 255   llvm::APInt SInt128(llvm::APInt &fail_value) const;
 256
 257   llvm::APInt UInt128(const llvm::APInt &fail_value) const;
 258
 259   llvm::APInt SInt256(llvm::APInt &fail_value) const;
 260
 261   llvm::APInt UInt256(const llvm::APInt &fail_value) const;
 262
 263   float Float(float fail_value = 0.0f) const;
 264
 265   double Double(double fail_value = 0.0) const;
 266
 267   long double LongDouble(long double fail_value = 0.0) const;
 268
 269   Status SetValueFromCString(const char *s, lldb::Encoding encoding,
 270                              size_t byte_size);
 271
 272   Status SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
 273                           size_t byte_size);
 274
 275   static bool UIntValueIsValidForSize(uint64_t uval64, size_t total_byte_size) {
 276     if (total_byte_size > 8)
 277       return false;
 278
 279     if (total_byte_size == 8)
 280       return true;
 281
 282     const uint64_t max = ((uint64_t)1 << (uint64_t)(total_byte_size * 8)) - 1;
 283     return uval64 <= max;
 284   }
 285
 286   static bool SIntValueIsValidForSize(int64_t sval64, size_t total_byte_size) {
 287     if (total_byte_size > 8)
 288       return false;
 289
 290     if (total_byte_size == 8)
 291       return true;
 292
 293     const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
 294     const int64_t min = ~(max);
 295     return min <= sval64 && sval64 <= max;
 296   }
 297
 298 protected:
 299   typedef char schar_t;
 300   typedef unsigned char uchar_t;
 301   typedef short sshort_t;
 302   typedef unsigned short ushort_t;
 303   typedef int sint_t;
 304   typedef unsigned int uint_t;
 305   typedef long slong_t;
 306   typedef unsigned long ulong_t;
 307   typedef long long slonglong_t;
 308   typedef unsigned long long ulonglong_t;
 309   typedef float float_t;
 310   typedef double double_t;
 311   typedef long double long_double_t;
 312
 313   //------------------------------------------------------------------
 314   // Classes that inherit from Scalar can see and modify these
 315   //------------------------------------------------------------------
 316   Scalar::Type m_type;
 317   llvm::APInt m_integer;
 318   llvm::APFloat m_float;
 319   bool m_ieee_quad = false;
 320
 321 private:
 322   friend const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
 323   friend const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
 324   friend const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
 325   friend const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
 326   friend const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
 327   friend const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
 328   friend const Scalar operator%(const Scalar &lhs, const Scalar &rhs);
 329   friend const Scalar operator^(const Scalar &lhs, const Scalar &rhs);
 330   friend const Scalar operator<<(const Scalar &lhs, const Scalar &rhs);
 331   friend const Scalar operator>>(const Scalar &lhs, const Scalar &rhs);
 332   friend bool operator==(const Scalar &lhs, const Scalar &rhs);
 333   friend bool operator!=(const Scalar &lhs, const Scalar &rhs);
 334   friend bool operator<(const Scalar &lhs, const Scalar &rhs);
 335   friend bool operator<=(const Scalar &lhs, const Scalar &rhs);
 336   friend bool operator>(const Scalar &lhs, const Scalar &rhs);
 337   friend bool operator>=(const Scalar &lhs, const Scalar &rhs);
 338 };
 339
 340 //----------------------------------------------------------------------
 341 // Split out the operators into a format where the compiler will be able to
 342 // implicitly convert numbers into Scalar objects.
 343 //
 344 // This allows code like:
 345 //      Scalar two(2);
 346 //      Scalar four = two * 2;
 347 //      Scalar eight = 2 * four;    // This would cause an error if the
 348 //                                  // operator* was implemented as a
 349 //                                  // member function.
 350 // SEE:
 351 //  Item 19 of "Effective C++ Second Edition" by Scott Meyers
 352 //  Differentiate among members functions, non-member functions, and
 353 //  friend functions
 354 //----------------------------------------------------------------------
 355 const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
 356 const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
 357 const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
 358 const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
 359 const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
 360 const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
 361 const Scalar operator%(const Scalar &lhs, const Scalar &rhs);
 362 const Scalar operator^(const Scalar &lhs, const Scalar &rhs);
 363 const Scalar operator<<(const Scalar &lhs, const Scalar &rhs);
 364 const Scalar operator>>(const Scalar &lhs, const Scalar &rhs);
 365 bool operator==(const Scalar &lhs, const Scalar &rhs);
 366 bool operator!=(const Scalar &lhs, const Scalar &rhs);
 367 bool operator<(const Scalar &lhs, const Scalar &rhs);
 368 bool operator<=(const Scalar &lhs, const Scalar &rhs);
 369 bool operator>(const Scalar &lhs, const Scalar &rhs);
 370 bool operator>=(const Scalar &lhs, const Scalar &rhs);
 371
 372 } // namespace lldb_private
 373
 374 #endif // LLDB_UTILITY_SCALAR_H