1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
|
//===-- 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);
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);
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_
|
