contrib/llvm/tools/lldb/include/lldb/Core/Value.h

   1 //===-- Value.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_Value_h_
  11 #define liblldb_Value_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <string>
  16 #include <vector>
  17 // Other libraries and framework includes
  18 // Project includes
  19 #include "lldb/lldb-private.h"
  20 #include "lldb/Core/ClangForward.h"
  21 #include "lldb/Core/DataBufferHeap.h"
  22 #include "lldb/Core/Error.h"
  23 #include "lldb/Core/Scalar.h"
  24 #include "lldb/Symbol/ClangASTType.h"
  25
  26 namespace lldb_private {
  27
  28 class Value
  29 {
  30 public:
  31
  32     // Values Less than zero are an error, greater than or equal to zero
  33     // returns what the Scalar result is.
  34     enum ValueType
  35     {
  36                                         // m_value contains...
  37                                         // ============================
  38         eValueTypeScalar,               // raw scalar value
  39         eValueTypeVector,               // byte array of m_vector.length with endianness of m_vector.byte_order
  40         eValueTypeFileAddress,          // file address value
  41         eValueTypeLoadAddress,          // load address value
  42         eValueTypeHostAddress           // host address value (for memory in the process that is using liblldb)
  43     };
  44
  45     enum ContextType                    // Type that describes Value::m_context
  46     {
  47                                         // m_context contains...
  48                                         // ====================
  49         eContextTypeInvalid,            // undefined
  50         eContextTypeRegisterInfo,       // RegisterInfo * (can be a scalar or a vector register)
  51         eContextTypeLLDBType,           // lldb_private::Type *
  52         eContextTypeVariable            // lldb_private::Variable *
  53     };
  54
  55     const static size_t kMaxByteSize = 32u;
  56
  57     struct Vector
  58     {
  59         // The byte array must be big enough to hold vector registers for any supported target.
  60         uint8_t bytes[kMaxByteSize];
  61         size_t length;
  62         lldb::ByteOrder byte_order;
  63
  64         Vector() :
  65                         length(0),
  66                         byte_order(lldb::eByteOrderInvalid)
  67         {
  68                 }
  69
  70         Vector(const Vector& vector)
  71                 { *this = vector;
  72         }
  73         const Vector&
  74                 operator=(const Vector& vector)
  75                 {
  76             SetBytes(vector.bytes, vector.length, vector.byte_order);
  77             return *this;
  78         }
  79
  80         void
  81         Clear ()
  82         {
  83                         length = 0;
  84         }
  85
  86         bool
  87                 SetBytes(const void *bytes, size_t length, lldb::ByteOrder byte_order)
  88                 {
  89             this->length = length;
  90             this->byte_order = byte_order;
  91             if (length)
  92                 ::memcpy(this->bytes, bytes, length < kMaxByteSize ? length : kMaxByteSize);
  93             return IsValid();
  94         }
  95
  96         bool
  97                 IsValid() const
  98                 {
  99             return (length > 0 && length < kMaxByteSize && byte_order != lldb::eByteOrderInvalid);
 100         }
 101         // Casts a vector, if valid, to an unsigned int of matching or largest supported size.
 102         // Truncates to the beginning of the vector if required.
 103         // Returns a default constructed Scalar if the Vector data is internally inconsistent.
 104         Scalar
 105                 GetAsScalar() const
 106                 {
 107             Scalar scalar;
 108             if (IsValid())
 109             {
 110                 if (length == 1) scalar = *(const uint8_t *)bytes;
 111                 else if (length == 2) scalar = *(const uint16_t *)bytes;
 112                 else if (length == 4) scalar = *(const uint32_t *)bytes;
 113                 else if (length == 8) scalar = *(const uint64_t *)bytes;
 114 #if defined (ENABLE_128_BIT_SUPPORT)
 115                 else if (length >= 16) scalar = *(const __uint128_t *)bytes;
 116 #else
 117                 else if (length >= 16) scalar = *(const __uint64_t *)bytes;
 118 #endif
 119             }
 120             return scalar;
 121         }
 122     };
 123
 124     Value();
 125     Value(const Scalar& scalar);
 126     Value(const Vector& vector);
 127     Value(const uint8_t *bytes, int len);
 128     Value(const Value &rhs);
 129
 130     Value &
 131     operator=(const Value &rhs);
 132
 133     const ClangASTType &
 134     GetClangType();
 135
 136     void
 137     SetClangType (const ClangASTType &clang_type);
 138
 139     ValueType
 140     GetValueType() const;
 141
 142     AddressType
 143     GetValueAddressType () const;
 144
 145     ContextType
 146     GetContextType() const
 147     {
 148         return m_context_type;
 149     }
 150
 151     void
 152     SetValueType (ValueType value_type)
 153     {
 154         m_value_type = value_type;
 155     }
 156
 157     void
 158     ClearContext ()
 159     {
 160         m_context = NULL;
 161         m_context_type = eContextTypeInvalid;
 162     }
 163
 164     void
 165     SetContext (ContextType context_type, void *p)
 166     {
 167         m_context_type = context_type;
 168         m_context = p;
 169         if (m_context_type == eContextTypeRegisterInfo) {
 170             RegisterInfo *reg_info = GetRegisterInfo();
 171             if (reg_info->encoding == lldb::eEncodingVector)
 172                 SetValueType(eValueTypeVector);
 173             else
 174                 SetValueType(eValueTypeScalar);
 175         }
 176     }
 177
 178     RegisterInfo *
 179     GetRegisterInfo() const;
 180
 181     Type *
 182     GetType();
 183
 184     Scalar &
 185     ResolveValue (ExecutionContext *exe_ctx);
 186
 187     const Scalar &
 188     GetScalar() const
 189     {
 190         return m_value;
 191     }
 192
 193     const Vector &
 194     GetVector() const
 195     {
 196         return m_vector;
 197     }
 198
 199     Scalar &
 200     GetScalar()
 201     {
 202         return m_value;
 203     }
 204
 205     Vector &
 206     GetVector()
 207     {
 208         return m_vector;
 209     }
 210
 211     bool
 212     SetVectorBytes(const Vector& vector)
 213         {
 214         m_vector = vector;
 215         return m_vector.IsValid();
 216     }
 217
 218     bool
 219     SetVectorBytes(uint8_t *bytes, size_t length, lldb::ByteOrder byte_order)
 220         {
 221         return m_vector.SetBytes(bytes, length, byte_order);
 222     }
 223
 224     bool
 225     SetScalarFromVector()
 226         {
 227         if (m_vector.IsValid())
 228                 {
 229             m_value = m_vector.GetAsScalar();
 230             return true;
 231         }
 232         return false;
 233     }
 234
 235     void
 236     ResizeData(size_t len);
 237
 238     bool
 239     ValueOf(ExecutionContext *exe_ctx);
 240
 241     Variable *
 242     GetVariable();
 243
 244     void
 245     Dump (Stream* strm);
 246
 247     lldb::Format
 248     GetValueDefaultFormat ();
 249
 250     uint64_t
 251     GetValueByteSize (Error *error_ptr);
 252
 253     Error
 254     GetValueAsData (ExecutionContext *exe_ctx,
 255                     DataExtractor &data,
 256                     uint32_t data_offset,
 257                     Module *module);     // Can be NULL
 258
 259     static const char *
 260     GetValueTypeAsCString (ValueType context_type);
 261
 262     static const char *
 263     GetContextTypeAsCString (ContextType context_type);
 264
 265     bool
 266     GetData (DataExtractor &data);
 267
 268     void
 269     Clear();
 270
 271 protected:
 272     Scalar          m_value;
 273     Vector          m_vector;
 274     ClangASTType    m_clang_type;
 275     void *          m_context;
 276     ValueType       m_value_type;
 277     ContextType     m_context_type;
 278     DataBufferHeap  m_data_buffer;
 279 };
 280
 281 class ValueList
 282 {
 283 public:
 284     ValueList () :
 285         m_values()
 286     {
 287     }
 288
 289     ValueList (const ValueList &rhs);
 290
 291     ~ValueList ()
 292     {
 293     }
 294
 295     const ValueList & operator= (const ValueList &rhs);
 296
 297     // void InsertValue (Value *value, size_t idx);
 298     void PushValue (const Value &value);
 299
 300     size_t GetSize ();
 301     Value *GetValueAtIndex(size_t idx);
 302     void Clear();
 303
 304 protected:
 305
 306 private:
 307     typedef std::vector<Value> collection;
 308
 309     collection m_values;
 310 };
 311
 312 } // namespace lldb_private
 313
 314 #endif  // liblldb_Value_h_