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