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 VectorVector64 Vector() : 65 length(0), 66 byte_order(lldb::eByteOrderInvalid) 67 { 68 } 69 VectorVector70 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 ClearVector81 Clear () 82 { 83 length = 0; 84 } 85 86 bool SetBytesVector87 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 IsValidVector97 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 GetAsScalarVector105 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 void *bytes, int len); 128 Value(const Value &rhs); 129 130 void 131 SetBytes (const void *bytes, int len); 132 133 void 134 AppendBytes (const void *bytes, int len); 135 136 Value & 137 operator=(const Value &rhs); 138 139 const ClangASTType & 140 GetClangType(); 141 142 void 143 SetClangType (const ClangASTType &clang_type); 144 145 ValueType 146 GetValueType() const; 147 148 AddressType 149 GetValueAddressType () const; 150 151 ContextType GetContextType()152 GetContextType() const 153 { 154 return m_context_type; 155 } 156 157 void SetValueType(ValueType value_type)158 SetValueType (ValueType value_type) 159 { 160 m_value_type = value_type; 161 } 162 163 void ClearContext()164 ClearContext () 165 { 166 m_context = NULL; 167 m_context_type = eContextTypeInvalid; 168 } 169 170 void SetContext(ContextType context_type,void * p)171 SetContext (ContextType context_type, void *p) 172 { 173 m_context_type = context_type; 174 m_context = p; 175 if (m_context_type == eContextTypeRegisterInfo) { 176 RegisterInfo *reg_info = GetRegisterInfo(); 177 if (reg_info->encoding == lldb::eEncodingVector) 178 SetValueType(eValueTypeVector); 179 else 180 SetValueType(eValueTypeScalar); 181 } 182 } 183 184 RegisterInfo * 185 GetRegisterInfo() const; 186 187 Type * 188 GetType(); 189 190 Scalar & 191 ResolveValue (ExecutionContext *exe_ctx); 192 193 const Scalar & GetScalar()194 GetScalar() const 195 { 196 return m_value; 197 } 198 199 const Vector & GetVector()200 GetVector() const 201 { 202 return m_vector; 203 } 204 205 Scalar & GetScalar()206 GetScalar() 207 { 208 return m_value; 209 } 210 211 Vector & GetVector()212 GetVector() 213 { 214 return m_vector; 215 } 216 217 bool SetVectorBytes(const Vector & vector)218 SetVectorBytes(const Vector& vector) 219 { 220 m_vector = vector; 221 return m_vector.IsValid(); 222 } 223 224 bool SetVectorBytes(uint8_t * bytes,size_t length,lldb::ByteOrder byte_order)225 SetVectorBytes(uint8_t *bytes, size_t length, lldb::ByteOrder byte_order) 226 { 227 return m_vector.SetBytes(bytes, length, byte_order); 228 } 229 230 bool SetScalarFromVector()231 SetScalarFromVector() 232 { 233 if (m_vector.IsValid()) 234 { 235 m_value = m_vector.GetAsScalar(); 236 return true; 237 } 238 return false; 239 } 240 241 size_t 242 ResizeData(size_t len); 243 244 size_t 245 AppendDataToHostBuffer (const Value &rhs); 246 247 DataBufferHeap & GetBuffer()248 GetBuffer () 249 { 250 return m_data_buffer; 251 } 252 253 const DataBufferHeap & GetBuffer()254 GetBuffer () const 255 { 256 return m_data_buffer; 257 } 258 259 bool 260 ValueOf(ExecutionContext *exe_ctx); 261 262 Variable * 263 GetVariable(); 264 265 void 266 Dump (Stream* strm); 267 268 lldb::Format 269 GetValueDefaultFormat (); 270 271 uint64_t 272 GetValueByteSize (Error *error_ptr); 273 274 Error 275 GetValueAsData (ExecutionContext *exe_ctx, 276 DataExtractor &data, 277 uint32_t data_offset, 278 Module *module); // Can be NULL 279 280 static const char * 281 GetValueTypeAsCString (ValueType context_type); 282 283 static const char * 284 GetContextTypeAsCString (ContextType context_type); 285 286 bool 287 GetData (DataExtractor &data); 288 289 void 290 Clear(); 291 292 protected: 293 Scalar m_value; 294 Vector m_vector; 295 ClangASTType m_clang_type; 296 void * m_context; 297 ValueType m_value_type; 298 ContextType m_context_type; 299 DataBufferHeap m_data_buffer; 300 }; 301 302 class ValueList 303 { 304 public: ValueList()305 ValueList () : 306 m_values() 307 { 308 } 309 310 ValueList (const ValueList &rhs); 311 ~ValueList()312 ~ValueList () 313 { 314 } 315 316 const ValueList & operator= (const ValueList &rhs); 317 318 // void InsertValue (Value *value, size_t idx); 319 void PushValue (const Value &value); 320 321 size_t GetSize (); 322 Value *GetValueAtIndex(size_t idx); 323 void Clear(); 324 325 protected: 326 327 private: 328 typedef std::vector<Value> collection; 329 330 collection m_values; 331 }; 332 333 } // namespace lldb_private 334 335 #endif // liblldb_Value_h_ 336