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 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
GetContextType()146     GetContextType() const
147     {
148         return m_context_type;
149     }
150 
151     void
SetValueType(ValueType value_type)152     SetValueType (ValueType value_type)
153     {
154         m_value_type = value_type;
155     }
156 
157     void
ClearContext()158     ClearContext ()
159     {
160         m_context = NULL;
161         m_context_type = eContextTypeInvalid;
162     }
163 
164     void
SetContext(ContextType context_type,void * p)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 &
GetScalar()188     GetScalar() const
189     {
190         return m_value;
191     }
192 
193     const Vector &
GetVector()194     GetVector() const
195     {
196         return m_vector;
197     }
198 
199     Scalar &
GetScalar()200     GetScalar()
201     {
202         return m_value;
203     }
204 
205     Vector &
GetVector()206     GetVector()
207     {
208         return m_vector;
209     }
210 
211     bool
SetVectorBytes(const Vector & vector)212     SetVectorBytes(const Vector& vector)
213 	{
214         m_vector = vector;
215         return m_vector.IsValid();
216     }
217 
218     bool
SetVectorBytes(uint8_t * bytes,size_t length,lldb::ByteOrder byte_order)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
SetScalarFromVector()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:
ValueList()284     ValueList () :
285         m_values()
286     {
287     }
288 
289     ValueList (const ValueList &rhs);
290 
~ValueList()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_
315