| //===-- Scalar.h ------------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef liblldb_Scalar_h_ |
| #define liblldb_Scalar_h_ |
| |
| #include "lldb/lldb-private.h" |
| |
| namespace lldb_private { |
| |
| //---------------------------------------------------------------------- |
| // A class designed to hold onto values and their corresponding types. |
| // Operators are defined and Scalar objects will correctly promote |
| // their types and values before performing these operations. Type |
| // promotion currently follows the ANSI C type promotion rules. |
| //---------------------------------------------------------------------- |
| class Scalar |
| { |
| public: |
| enum Type |
| { |
| e_void = 0, |
| e_sint, |
| e_uint, |
| e_slong, |
| e_ulong, |
| e_slonglong, |
| e_ulonglong, |
| e_float, |
| e_double, |
| e_long_double |
| }; |
| |
| //------------------------------------------------------------------ |
| // Constructors and Destructors |
| //------------------------------------------------------------------ |
| Scalar(); |
| Scalar(int v) : m_type(e_sint), m_data() { m_data.sint = v; } |
| Scalar(unsigned int v) : m_type(e_uint), m_data() { m_data.uint = v; } |
| Scalar(long v) : m_type(e_slong), m_data() { m_data.slong = v; } |
| Scalar(unsigned long v) : m_type(e_ulong), m_data() { m_data.ulong = v; } |
| Scalar(long long v) : m_type(e_slonglong), m_data() { m_data.slonglong = v; } |
| Scalar(unsigned long long v): m_type(e_ulonglong), m_data() { m_data.ulonglong = v; } |
| Scalar(float v) : m_type(e_float), m_data() { m_data.flt = v; } |
| Scalar(double v) : m_type(e_double), m_data() { m_data.dbl = v; } |
| Scalar(long double v) : m_type(e_long_double), m_data() { m_data.ldbl = v; } |
| Scalar(const Scalar& rhs); |
| //Scalar(const RegisterValue& reg_value); |
| virtual ~Scalar(); |
| |
| bool |
| SignExtend (uint32_t bit_pos); |
| |
| bool |
| ExtractBitfield (uint32_t bit_size, |
| uint32_t bit_offset); |
| |
| size_t |
| GetByteSize() const; |
| |
| static size_t |
| GetMaxByteSize() |
| { |
| return sizeof(ValueData); |
| } |
| |
| bool |
| GetData (DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const; |
| |
| size_t |
| GetAsMemoryData (void *dst, |
| size_t dst_len, |
| lldb::ByteOrder dst_byte_order, |
| Error &error) const; |
| |
| bool |
| IsZero() const; |
| |
| void |
| Clear() { m_type = e_void; m_data.ulonglong = 0; } |
| |
| const char * |
| GetTypeAsCString() const; |
| |
| void |
| GetValue (Stream *s, bool show_type) const; |
| |
| bool |
| IsValid() const |
| { |
| return (m_type >= e_sint) && (m_type <= e_long_double); |
| } |
| |
| bool |
| Promote(Scalar::Type type); |
| |
| bool |
| Cast (Scalar::Type type); |
| |
| bool |
| MakeSigned (); |
| |
| static const char * |
| GetValueTypeAsCString (Scalar::Type value_type); |
| |
| static Scalar::Type |
| GetValueTypeForSignedIntegerWithByteSize (size_t byte_size); |
| |
| static Scalar::Type |
| GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size); |
| |
| static Scalar::Type |
| GetValueTypeForFloatWithByteSize (size_t byte_size); |
| |
| //---------------------------------------------------------------------- |
| // All operators can benefits from the implicit conversions that will |
| // happen automagically by the compiler, so no temporary objects will |
| // need to be created. As a result, we currently don't need a variety of |
| // overloaded set value accessors. |
| //---------------------------------------------------------------------- |
| Scalar& operator= (const int i); |
| Scalar& operator= (unsigned int v); |
| Scalar& operator= (long v); |
| Scalar& operator= (unsigned long v); |
| Scalar& operator= (long long v); |
| Scalar& operator= (unsigned long long v); |
| Scalar& operator= (float v); |
| Scalar& operator= (double v); |
| Scalar& operator= (long double v); |
| Scalar& operator= (const Scalar& rhs); // Assignment operator |
| Scalar& operator+= (const Scalar& rhs); |
| Scalar& operator<<= (const Scalar& rhs); // Shift left |
| Scalar& operator>>= (const Scalar& rhs); // Shift right (arithmetic) |
| Scalar& operator&= (const Scalar& rhs); |
| |
| //---------------------------------------------------------------------- |
| // Shifts the current value to the right without maintaining the current |
| // sign of the value (if it is signed). |
| //---------------------------------------------------------------------- |
| bool |
| ShiftRightLogical(const Scalar& rhs); // Returns true on success |
| |
| //---------------------------------------------------------------------- |
| // Takes the absolute value of the current value if it is signed, else |
| // the value remains unchanged. |
| // Returns false if the contained value has a void type. |
| //---------------------------------------------------------------------- |
| bool |
| AbsoluteValue(); // Returns true on success |
| //---------------------------------------------------------------------- |
| // Negates the current value (even for unsigned values). |
| // Returns false if the contained value has a void type. |
| //---------------------------------------------------------------------- |
| bool |
| UnaryNegate(); // Returns true on success |
| //---------------------------------------------------------------------- |
| // Inverts all bits in the current value as long as it isn't void or |
| // a float/double/long double type. |
| // Returns false if the contained value has a void/float/double/long |
| // double type, else the value is inverted and true is returned. |
| //---------------------------------------------------------------------- |
| bool |
| OnesComplement(); // Returns true on success |
| |
| //---------------------------------------------------------------------- |
| // Access the type of the current value. |
| //---------------------------------------------------------------------- |
| Scalar::Type |
| GetType() const { return m_type; } |
| |
| //---------------------------------------------------------------------- |
| // Returns a casted value of the current contained data without |
| // modifying the current value. FAIL_VALUE will be returned if the type |
| // of the value is void or invalid. |
| //---------------------------------------------------------------------- |
| int |
| SInt(int fail_value = 0) const; |
| |
| // Return the raw unsigned integer without any casting or conversion |
| unsigned int |
| RawUInt () const; |
| |
| // Return the raw unsigned long without any casting or conversion |
| unsigned long |
| RawULong () const; |
| |
| // Return the raw unsigned long long without any casting or conversion |
| unsigned long long |
| RawULongLong () const; |
| |
| unsigned int |
| UInt(unsigned int fail_value = 0) const; |
| |
| long |
| SLong(long fail_value = 0) const; |
| |
| unsigned long |
| ULong(unsigned long fail_value = 0) const; |
| |
| long long |
| SLongLong(long long fail_value = 0) const; |
| |
| unsigned long long |
| ULongLong(unsigned long long fail_value = 0) const; |
| |
| float |
| Float(float fail_value = 0.0f) const; |
| |
| double |
| Double(double fail_value = 0.0) const; |
| |
| long double |
| LongDouble(long double fail_value = 0.0) const; |
| |
| uint64_t |
| GetRawBits64 (uint64_t fail_value) const; |
| |
| Error |
| SetValueFromCString (const char *s, lldb::Encoding encoding, size_t byte_size); |
| |
| Error |
| SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size); |
| |
| static bool |
| UIntValueIsValidForSize (uint64_t uval64, size_t total_byte_size) |
| { |
| if (total_byte_size > 8) |
| return false; |
| |
| if (total_byte_size == 8) |
| return true; |
| |
| const uint64_t max = ((uint64_t)1 << (uint64_t)(total_byte_size * 8)) - 1; |
| return uval64 <= max; |
| } |
| |
| static bool |
| SIntValueIsValidForSize (int64_t sval64, size_t total_byte_size) |
| { |
| if (total_byte_size > 8) |
| return false; |
| |
| if (total_byte_size == 8) |
| return true; |
| |
| const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1; |
| const int64_t min = ~(max); |
| return min <= sval64 && sval64 <= max; |
| } |
| |
| protected: |
| typedef int sint_t; |
| typedef unsigned int uint_t; |
| typedef long slong_t; |
| typedef unsigned long ulong_t; |
| typedef long long slonglong_t; |
| typedef unsigned long long ulonglong_t; |
| typedef float float_t; |
| typedef double double_t; |
| typedef long double long_double_t; |
| |
| union ValueData |
| { |
| int sint; |
| unsigned int uint; |
| long slong; |
| unsigned long ulong; |
| long long slonglong; |
| unsigned long long ulonglong; |
| float flt; |
| double dbl; |
| long double ldbl; |
| }; |
| |
| //------------------------------------------------------------------ |
| // Classes that inherit from Scalar can see and modify these |
| //------------------------------------------------------------------ |
| Scalar::Type m_type; |
| ValueData m_data; |
| |
| private: |
| friend const Scalar operator+ (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator- (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator/ (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator* (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator& (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator| (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator% (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator^ (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator<< (const Scalar& lhs, const Scalar& rhs); |
| friend const Scalar operator>> (const Scalar& lhs, const Scalar& rhs); |
| friend bool operator== (const Scalar& lhs, const Scalar& rhs); |
| friend bool operator!= (const Scalar& lhs, const Scalar& rhs); |
| friend bool operator< (const Scalar& lhs, const Scalar& rhs); |
| friend bool operator<= (const Scalar& lhs, const Scalar& rhs); |
| friend bool operator> (const Scalar& lhs, const Scalar& rhs); |
| friend bool operator>= (const Scalar& lhs, const Scalar& rhs); |
| |
| }; |
| |
| //---------------------------------------------------------------------- |
| // Split out the operators into a format where the compiler will be able |
| // to implicitly convert numbers into Scalar objects. |
| // |
| // This allows code like: |
| // Scalar two(2); |
| // Scalar four = two * 2; |
| // Scalar eight = 2 * four; // This would cause an error if the |
| // // operator* was implemented as a |
| // // member function. |
| // SEE: |
| // Item 19 of "Effective C++ Second Edition" by Scott Meyers |
| // Differentiate among members functions, non-member functions, and |
| // friend functions |
| //---------------------------------------------------------------------- |
| const Scalar operator+ (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator- (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator/ (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator* (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator& (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator| (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator% (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator^ (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator<< (const Scalar& lhs, const Scalar& rhs); |
| const Scalar operator>> (const Scalar& lhs, const Scalar& rhs); |
| bool operator== (const Scalar& lhs, const Scalar& rhs); |
| bool operator!= (const Scalar& lhs, const Scalar& rhs); |
| bool operator< (const Scalar& lhs, const Scalar& rhs); |
| bool operator<= (const Scalar& lhs, const Scalar& rhs); |
| bool operator> (const Scalar& lhs, const Scalar& rhs); |
| bool operator>= (const Scalar& lhs, const Scalar& rhs); |
| |
| } // namespace lldb_private |
| |
| #endif // liblldb_Scalar_h_ |
