//===-- 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" #include "llvm/ADT/APInt.h" #include "llvm/ADT/APFloat.h" #define NUM_OF_WORDS_INT128 2 #define BITWIDTH_INT128 128 #define NUM_OF_WORDS_INT256 4 #define BITWIDTH_INT256 256 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, e_uint128, e_sint128, e_uint256, e_sint256 }; //------------------------------------------------------------------ // Constructors and Destructors //------------------------------------------------------------------ Scalar(); Scalar(int v) : m_type(e_sint), m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v, true);} Scalar(unsigned int v) : m_type(e_uint), m_float((float)0) { m_integer = llvm::APInt(sizeof(int) * 8, v);} Scalar(long v) : m_type(e_slong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v, true);} Scalar(unsigned long v) : m_type(e_ulong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long) * 8, v);} Scalar(long long v) : m_type(e_slonglong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v, true);} Scalar(unsigned long long v): m_type(e_ulonglong), m_float((float)0) { m_integer = llvm::APInt(sizeof(long long) * 8, v);} Scalar(float v) : m_type(e_float), m_float(v) { m_float = llvm::APFloat(v); } Scalar(double v) : m_type(e_double), m_float(v) { m_float = llvm::APFloat(v); } Scalar(long double v, bool ieee_quad) : m_type(e_long_double), m_float((float)0), m_ieee_quad(ieee_quad) { if(ieee_quad) m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x)); else m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x)); } Scalar(llvm::APInt v) : m_type(), m_float((float)0) { m_integer = llvm::APInt(v); switch(m_integer.getBitWidth()) { case 8: case 16: case 32: if(m_integer.isSignedIntN(sizeof(sint_t) * 8)) m_type = e_sint; else m_type = e_uint; break; case 64: if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8)) m_type = e_slonglong; else m_type = e_ulonglong; break; case 128: if(m_integer.isSignedIntN(BITWIDTH_INT128)) m_type = e_sint128; else m_type = e_uint128; break; case 256: if(m_integer.isSignedIntN(BITWIDTH_INT256)) m_type = e_sint256; else m_type = e_uint256; break; } } 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); bool SetBit(uint32_t bit); bool ClearBit(uint32_t bit); const void * GetBytes() const; size_t GetByteSize() const; 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_integer.clearAllBits(); } 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 (); bool MakeUnsigned (); 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= (llvm::APInt 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; unsigned char UChar(unsigned char fail_value = 0) const; signed char SChar(char fail_value = 0) const; unsigned short UShort(unsigned short fail_value = 0) const; short SShort(short fail_value = 0) 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; llvm::APInt SInt128(llvm::APInt& fail_value) const; llvm::APInt UInt128(const llvm::APInt& fail_value) const; llvm::APInt SInt256(llvm::APInt& fail_value) const; llvm::APInt UInt256(const llvm::APInt& fail_value) 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; 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 char schar_t; typedef unsigned char uchar_t; typedef short sshort_t; typedef unsigned short ushort_t; 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; //------------------------------------------------------------------ // Classes that inherit from Scalar can see and modify these //------------------------------------------------------------------ Scalar::Type m_type; llvm::APInt m_integer; llvm::APFloat m_float; bool m_ieee_quad = false; 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_