1 //===-- RegisterValue.cpp ----------------------------------------*- 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 #include "lldb/Core/RegisterValue.h"
11
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/Core/DataExtractor.h"
17 #include "lldb/Core/Error.h"
18 #include "lldb/Core/Scalar.h"
19 #include "lldb/Core/Stream.h"
20 #include "lldb/Core/StreamString.h"
21 #include "lldb/Interpreter/Args.h"
22 #include "lldb/Host/StringConvert.h"
23
24 using namespace lldb;
25 using namespace lldb_private;
26
27
28 bool
Dump(Stream * s,const RegisterInfo * reg_info,bool prefix_with_name,bool prefix_with_alt_name,Format format,uint32_t reg_name_right_align_at) const29 RegisterValue::Dump (Stream *s,
30 const RegisterInfo *reg_info,
31 bool prefix_with_name,
32 bool prefix_with_alt_name,
33 Format format,
34 uint32_t reg_name_right_align_at) const
35 {
36 DataExtractor data;
37 if (GetData (data))
38 {
39 bool name_printed = false;
40 // For simplicity, alignment of the register name printing applies only
41 // in the most common case where:
42 //
43 // prefix_with_name^prefix_with_alt_name is true
44 //
45 StreamString format_string;
46 if (reg_name_right_align_at && (prefix_with_name^prefix_with_alt_name))
47 format_string.Printf("%%%us", reg_name_right_align_at);
48 else
49 format_string.Printf("%%s");
50 const char *fmt = format_string.GetData();
51 if (prefix_with_name)
52 {
53 if (reg_info->name)
54 {
55 s->Printf (fmt, reg_info->name);
56 name_printed = true;
57 }
58 else if (reg_info->alt_name)
59 {
60 s->Printf (fmt, reg_info->alt_name);
61 prefix_with_alt_name = false;
62 name_printed = true;
63 }
64 }
65 if (prefix_with_alt_name)
66 {
67 if (name_printed)
68 s->PutChar ('/');
69 if (reg_info->alt_name)
70 {
71 s->Printf (fmt, reg_info->alt_name);
72 name_printed = true;
73 }
74 else if (!name_printed)
75 {
76 // No alternate name but we were asked to display a name, so show the main name
77 s->Printf (fmt, reg_info->name);
78 name_printed = true;
79 }
80 }
81 if (name_printed)
82 s->PutCString (" = ");
83
84 if (format == eFormatDefault)
85 format = reg_info->format;
86
87 data.Dump (s,
88 0, // Offset in "data"
89 format, // Format to use when dumping
90 reg_info->byte_size, // item_byte_size
91 1, // item_count
92 UINT32_MAX, // num_per_line
93 LLDB_INVALID_ADDRESS, // base_addr
94 0, // item_bit_size
95 0); // item_bit_offset
96 return true;
97 }
98 return false;
99 }
100
101
102 bool
GetData(DataExtractor & data) const103 RegisterValue::GetData (DataExtractor &data) const
104 {
105 return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
106 }
107
108
109 uint32_t
GetAsMemoryData(const RegisterInfo * reg_info,void * dst,uint32_t dst_len,lldb::ByteOrder dst_byte_order,Error & error) const110 RegisterValue::GetAsMemoryData (const RegisterInfo *reg_info,
111 void *dst,
112 uint32_t dst_len,
113 lldb::ByteOrder dst_byte_order,
114 Error &error) const
115 {
116 if (reg_info == NULL)
117 {
118 error.SetErrorString ("invalid register info argument.");
119 return 0;
120 }
121
122 // ReadRegister should have already been called on tgus object prior to
123 // calling this.
124 if (GetType() == eTypeInvalid)
125 {
126 // No value has been read into this object...
127 error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
128 return 0;
129 }
130
131 if (dst_len > kMaxRegisterByteSize)
132 {
133 error.SetErrorString ("destination is too big");
134 return 0;
135 }
136
137 const uint32_t src_len = reg_info->byte_size;
138
139 // Extract the register data into a data extractor
140 DataExtractor reg_data;
141 if (!GetData(reg_data))
142 {
143 error.SetErrorString ("invalid register value to copy into");
144 return 0;
145 }
146
147 // Prepare a memory buffer that contains some or all of the register value
148 const uint32_t bytes_copied = reg_data.CopyByteOrderedData (0, // src offset
149 src_len, // src length
150 dst, // dst buffer
151 dst_len, // dst length
152 dst_byte_order); // dst byte order
153 if (bytes_copied == 0)
154 error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
155
156 return bytes_copied;
157 }
158
159 uint32_t
SetFromMemoryData(const RegisterInfo * reg_info,const void * src,uint32_t src_len,lldb::ByteOrder src_byte_order,Error & error)160 RegisterValue::SetFromMemoryData (const RegisterInfo *reg_info,
161 const void *src,
162 uint32_t src_len,
163 lldb::ByteOrder src_byte_order,
164 Error &error)
165 {
166 if (reg_info == NULL)
167 {
168 error.SetErrorString ("invalid register info argument.");
169 return 0;
170 }
171
172 // Moving from addr into a register
173 //
174 // Case 1: src_len == dst_len
175 //
176 // |AABBCCDD| Address contents
177 // |AABBCCDD| Register contents
178 //
179 // Case 2: src_len > dst_len
180 //
181 // Error! (The register should always be big enough to hold the data)
182 //
183 // Case 3: src_len < dst_len
184 //
185 // |AABB| Address contents
186 // |AABB0000| Register contents [on little-endian hardware]
187 // |0000AABB| Register contents [on big-endian hardware]
188 if (src_len > kMaxRegisterByteSize)
189 {
190 error.SetErrorStringWithFormat ("register buffer is too small to receive %u bytes of data.", src_len);
191 return 0;
192 }
193
194 const uint32_t dst_len = reg_info->byte_size;
195
196 if (src_len > dst_len)
197 {
198 error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len);
199 return 0;
200 }
201
202 // Use a data extractor to correctly copy and pad the bytes read into the
203 // register value
204 DataExtractor src_data (src, src_len, src_byte_order, 4);
205
206 // Given the register info, set the value type of this RegisterValue object
207 SetType (reg_info);
208 // And make sure we were able to figure out what that register value was
209 RegisterValue::Type value_type = GetType();
210 if (value_type == eTypeInvalid)
211 {
212 // No value has been read into this object...
213 error.SetErrorStringWithFormat("invalid register value type for register %s", reg_info->name);
214 return 0;
215 }
216 else if (value_type == eTypeBytes)
217 {
218 m_data.buffer.byte_order = src_byte_order;
219 // Make sure to set the buffer length of the destination buffer to avoid
220 // problems due to uninitalized variables.
221 m_data.buffer.length = src_len;
222 }
223
224 const uint32_t bytes_copied = src_data.CopyByteOrderedData (0, // src offset
225 src_len, // src length
226 GetBytes(), // dst buffer
227 GetByteSize(), // dst length
228 GetByteOrder()); // dst byte order
229 if (bytes_copied == 0)
230 error.SetErrorStringWithFormat("failed to copy data for register write of %s", reg_info->name);
231
232 return bytes_copied;
233 }
234
235 bool
GetScalarValue(Scalar & scalar) const236 RegisterValue::GetScalarValue (Scalar &scalar) const
237 {
238 switch (m_type)
239 {
240 case eTypeInvalid: break;
241 case eTypeBytes:
242 {
243 switch (m_data.buffer.length)
244 {
245 default: break;
246 case 1: scalar = m_data.uint8; return true;
247 case 2: scalar = m_data.uint16; return true;
248 case 4: scalar = m_data.uint32; return true;
249 case 8: scalar = m_data.uint64; return true;
250 }
251 }
252 case eTypeUInt8: scalar = m_data.uint8; return true;
253 case eTypeUInt16: scalar = m_data.uint16; return true;
254 case eTypeUInt32: scalar = m_data.uint32; return true;
255 case eTypeUInt64: scalar = m_data.uint64; return true;
256 #if defined (ENABLE_128_BIT_SUPPORT)
257 case eTypeUInt128: break;
258 #endif
259 case eTypeFloat: scalar = m_data.ieee_float; return true;
260 case eTypeDouble: scalar = m_data.ieee_double; return true;
261 case eTypeLongDouble: scalar = m_data.ieee_long_double; return true;
262 }
263 return false;
264 }
265
266 void
Clear()267 RegisterValue::Clear()
268 {
269 m_type = eTypeInvalid;
270 }
271
272 RegisterValue::Type
SetType(const RegisterInfo * reg_info)273 RegisterValue::SetType (const RegisterInfo *reg_info)
274 {
275 m_type = eTypeInvalid;
276 const uint32_t byte_size = reg_info->byte_size;
277 switch (reg_info->encoding)
278 {
279 case eEncodingInvalid:
280 break;
281
282 case eEncodingUint:
283 case eEncodingSint:
284 if (byte_size == 1)
285 m_type = eTypeUInt8;
286 else if (byte_size <= 2)
287 m_type = eTypeUInt16;
288 else if (byte_size <= 4)
289 m_type = eTypeUInt32;
290 else if (byte_size <= 8)
291 m_type = eTypeUInt64;
292 #if defined (ENABLE_128_BIT_SUPPORT)
293 else if (byte_size <= 16)
294 m_type = eTypeUInt128;
295 #endif
296 break;
297
298 case eEncodingIEEE754:
299 if (byte_size == sizeof(float))
300 m_type = eTypeFloat;
301 else if (byte_size == sizeof(double))
302 m_type = eTypeDouble;
303 else if (byte_size == sizeof(long double))
304 m_type = eTypeLongDouble;
305 break;
306
307 case eEncodingVector:
308 m_type = eTypeBytes;
309 break;
310 }
311 return m_type;
312 }
313
314 Error
SetValueFromData(const RegisterInfo * reg_info,DataExtractor & src,lldb::offset_t src_offset,bool partial_data_ok)315 RegisterValue::SetValueFromData (const RegisterInfo *reg_info, DataExtractor &src, lldb::offset_t src_offset, bool partial_data_ok)
316 {
317 Error error;
318
319 if (src.GetByteSize() == 0)
320 {
321 error.SetErrorString ("empty data.");
322 return error;
323 }
324
325 if (reg_info->byte_size == 0)
326 {
327 error.SetErrorString ("invalid register info.");
328 return error;
329 }
330
331 uint32_t src_len = src.GetByteSize() - src_offset;
332
333 if (!partial_data_ok && (src_len < reg_info->byte_size))
334 {
335 error.SetErrorString ("not enough data.");
336 return error;
337 }
338
339 // Cap the data length if there is more than enough bytes for this register
340 // value
341 if (src_len > reg_info->byte_size)
342 src_len = reg_info->byte_size;
343
344 // Zero out the value in case we get partial data...
345 memset (m_data.buffer.bytes, 0, sizeof (m_data.buffer.bytes));
346
347 switch (SetType (reg_info))
348 {
349 case eTypeInvalid:
350 error.SetErrorString("");
351 break;
352 case eTypeUInt8: SetUInt8 (src.GetMaxU32 (&src_offset, src_len)); break;
353 case eTypeUInt16: SetUInt16 (src.GetMaxU32 (&src_offset, src_len)); break;
354 case eTypeUInt32: SetUInt32 (src.GetMaxU32 (&src_offset, src_len)); break;
355 case eTypeUInt64: SetUInt64 (src.GetMaxU64 (&src_offset, src_len)); break;
356 #if defined (ENABLE_128_BIT_SUPPORT)
357 case eTypeUInt128:
358 {
359 __uint128_t data1 = src.GetU64 (&src_offset);
360 __uint128_t data2 = src.GetU64 (&src_offset);
361 if (src.GetByteSize() == eByteOrderBig)
362 SetUInt128 (data1 << 64 + data2);
363 else
364 SetUInt128 (data2 << 64 + data1);
365 }
366 break;
367 #endif
368 case eTypeFloat: SetFloat (src.GetFloat (&src_offset)); break;
369 case eTypeDouble: SetDouble(src.GetDouble (&src_offset)); break;
370 case eTypeLongDouble: SetFloat (src.GetLongDouble (&src_offset)); break;
371 case eTypeBytes:
372 {
373 m_data.buffer.length = reg_info->byte_size;
374 m_data.buffer.byte_order = src.GetByteOrder();
375 assert (m_data.buffer.length <= kMaxRegisterByteSize);
376 if (m_data.buffer.length > kMaxRegisterByteSize)
377 m_data.buffer.length = kMaxRegisterByteSize;
378 if (src.CopyByteOrderedData (src_offset, // offset within "src" to start extracting data
379 src_len, // src length
380 m_data.buffer.bytes, // dst buffer
381 m_data.buffer.length, // dst length
382 m_data.buffer.byte_order) == 0)// dst byte order
383 {
384 error.SetErrorString ("data copy failed data.");
385 return error;
386 }
387 }
388 }
389
390 return error;
391 }
392
393 #include "llvm/ADT/StringRef.h"
394 #include <vector>
StripSpaces(llvm::StringRef & Str)395 static inline void StripSpaces(llvm::StringRef &Str)
396 {
397 while (!Str.empty() && isspace(Str[0]))
398 Str = Str.substr(1);
399 while (!Str.empty() && isspace(Str.back()))
400 Str = Str.substr(0, Str.size()-1);
401 }
LStrip(llvm::StringRef & Str,char c)402 static inline void LStrip(llvm::StringRef &Str, char c)
403 {
404 if (!Str.empty() && Str.front() == c)
405 Str = Str.substr(1);
406 }
RStrip(llvm::StringRef & Str,char c)407 static inline void RStrip(llvm::StringRef &Str, char c)
408 {
409 if (!Str.empty() && Str.back() == c)
410 Str = Str.substr(0, Str.size()-1);
411 }
412 // Helper function for RegisterValue::SetValueFromCString()
413 static bool
ParseVectorEncoding(const RegisterInfo * reg_info,const char * vector_str,const uint32_t byte_size,RegisterValue * reg_value)414 ParseVectorEncoding(const RegisterInfo *reg_info, const char *vector_str, const uint32_t byte_size, RegisterValue *reg_value)
415 {
416 // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
417 llvm::StringRef Str(vector_str);
418 StripSpaces(Str);
419 LStrip(Str, '{');
420 RStrip(Str, '}');
421 StripSpaces(Str);
422
423 char Sep = ' ';
424
425 // The first split should give us:
426 // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f 0x2a 0x3e').
427 std::pair<llvm::StringRef, llvm::StringRef> Pair = Str.split(Sep);
428 std::vector<uint8_t> bytes;
429 unsigned byte = 0;
430
431 // Using radix auto-sensing by passing 0 as the radix.
432 // Keep on processing the vector elements as long as the parsing succeeds and the vector size is < byte_size.
433 while (!Pair.first.getAsInteger(0, byte) && bytes.size() < byte_size) {
434 bytes.push_back(byte);
435 Pair = Pair.second.split(Sep);
436 }
437
438 // Check for vector of exact byte_size elements.
439 if (bytes.size() != byte_size)
440 return false;
441
442 reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
443 return true;
444 }
445 Error
SetValueFromCString(const RegisterInfo * reg_info,const char * value_str)446 RegisterValue::SetValueFromCString (const RegisterInfo *reg_info, const char *value_str)
447 {
448 Error error;
449 if (reg_info == NULL)
450 {
451 error.SetErrorString ("Invalid register info argument.");
452 return error;
453 }
454
455 if (value_str == NULL || value_str[0] == '\0')
456 {
457 error.SetErrorString ("Invalid c-string value string.");
458 return error;
459 }
460 bool success = false;
461 const uint32_t byte_size = reg_info->byte_size;
462 switch (reg_info->encoding)
463 {
464 case eEncodingInvalid:
465 error.SetErrorString ("Invalid encoding.");
466 break;
467
468 case eEncodingUint:
469 if (byte_size <= sizeof (uint64_t))
470 {
471 uint64_t uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
472 if (!success)
473 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
474 else if (!Args::UInt64ValueIsValidForByteSize (uval64, byte_size))
475 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte unsigned integer value", uval64, byte_size);
476 else
477 {
478 if (!SetUInt (uval64, reg_info->byte_size))
479 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
480 }
481 }
482 else
483 {
484 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
485 return error;
486 }
487 break;
488
489 case eEncodingSint:
490 if (byte_size <= sizeof (long long))
491 {
492 uint64_t sval64 = StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
493 if (!success)
494 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
495 else if (!Args::SInt64ValueIsValidForByteSize (sval64, byte_size))
496 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %u byte signed integer value", sval64, byte_size);
497 else
498 {
499 if (!SetUInt (sval64, reg_info->byte_size))
500 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
501 }
502 }
503 else
504 {
505 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
506 return error;
507 }
508 break;
509
510 case eEncodingIEEE754:
511 if (byte_size == sizeof (float))
512 {
513 if (::sscanf (value_str, "%f", &m_data.ieee_float) == 1)
514 m_type = eTypeFloat;
515 else
516 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
517 }
518 else if (byte_size == sizeof (double))
519 {
520 if (::sscanf (value_str, "%lf", &m_data.ieee_double) == 1)
521 m_type = eTypeDouble;
522 else
523 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
524 }
525 else if (byte_size == sizeof (long double))
526 {
527 if (::sscanf (value_str, "%Lf", &m_data.ieee_long_double) == 1)
528 m_type = eTypeLongDouble;
529 else
530 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
531 }
532 else
533 {
534 error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size);
535 return error;
536 }
537 break;
538
539 case eEncodingVector:
540 if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
541 error.SetErrorString ("unrecognized vector encoding string value.");
542 break;
543 }
544 if (error.Fail())
545 m_type = eTypeInvalid;
546
547 return error;
548 }
549
550
551 bool
SignExtend(uint32_t sign_bitpos)552 RegisterValue::SignExtend (uint32_t sign_bitpos)
553 {
554 switch (m_type)
555 {
556 case eTypeInvalid:
557 break;
558
559 case eTypeUInt8:
560 if (sign_bitpos == (8-1))
561 return true;
562 else if (sign_bitpos < (8-1))
563 {
564 uint8_t sign_bit = 1u << sign_bitpos;
565 if (m_data.uint8 & sign_bit)
566 {
567 const uint8_t mask = ~(sign_bit) + 1u;
568 m_data.uint8 |= mask;
569 }
570 return true;
571 }
572 break;
573
574 case eTypeUInt16:
575 if (sign_bitpos == (16-1))
576 return true;
577 else if (sign_bitpos < (16-1))
578 {
579 uint16_t sign_bit = 1u << sign_bitpos;
580 if (m_data.uint16 & sign_bit)
581 {
582 const uint16_t mask = ~(sign_bit) + 1u;
583 m_data.uint16 |= mask;
584 }
585 return true;
586 }
587 break;
588
589 case eTypeUInt32:
590 if (sign_bitpos == (32-1))
591 return true;
592 else if (sign_bitpos < (32-1))
593 {
594 uint32_t sign_bit = 1u << sign_bitpos;
595 if (m_data.uint32 & sign_bit)
596 {
597 const uint32_t mask = ~(sign_bit) + 1u;
598 m_data.uint32 |= mask;
599 }
600 return true;
601 }
602 break;
603
604 case eTypeUInt64:
605 if (sign_bitpos == (64-1))
606 return true;
607 else if (sign_bitpos < (64-1))
608 {
609 uint64_t sign_bit = 1ull << sign_bitpos;
610 if (m_data.uint64 & sign_bit)
611 {
612 const uint64_t mask = ~(sign_bit) + 1ull;
613 m_data.uint64 |= mask;
614 }
615 return true;
616 }
617 break;
618
619 #if defined (ENABLE_128_BIT_SUPPORT)
620 case eTypeUInt128:
621 if (sign_bitpos == (128-1))
622 return true;
623 else if (sign_bitpos < (128-1))
624 {
625 __uint128_t sign_bit = (__uint128_t)1u << sign_bitpos;
626 if (m_data.uint128 & sign_bit)
627 {
628 const uint128_t mask = ~(sign_bit) + 1u;
629 m_data.uint128 |= mask;
630 }
631 return true;
632 }
633 break;
634 #endif
635 case eTypeFloat:
636 case eTypeDouble:
637 case eTypeLongDouble:
638 case eTypeBytes:
639 break;
640 }
641 return false;
642 }
643
644 bool
CopyValue(const RegisterValue & rhs)645 RegisterValue::CopyValue (const RegisterValue &rhs)
646 {
647 m_type = rhs.m_type;
648 switch (m_type)
649 {
650 case eTypeInvalid:
651 return false;
652 case eTypeUInt8: m_data.uint8 = rhs.m_data.uint8; break;
653 case eTypeUInt16: m_data.uint16 = rhs.m_data.uint16; break;
654 case eTypeUInt32: m_data.uint32 = rhs.m_data.uint32; break;
655 case eTypeUInt64: m_data.uint64 = rhs.m_data.uint64; break;
656 #if defined (ENABLE_128_BIT_SUPPORT)
657 case eTypeUInt128: m_data.uint128 = rhs.m_data.uint128; break;
658 #endif
659 case eTypeFloat: m_data.ieee_float = rhs.m_data.ieee_float; break;
660 case eTypeDouble: m_data.ieee_double = rhs.m_data.ieee_double; break;
661 case eTypeLongDouble: m_data.ieee_long_double = rhs.m_data.ieee_long_double; break;
662 case eTypeBytes:
663 assert (rhs.m_data.buffer.length <= kMaxRegisterByteSize);
664 ::memcpy (m_data.buffer.bytes, rhs.m_data.buffer.bytes, kMaxRegisterByteSize);
665 m_data.buffer.length = rhs.m_data.buffer.length;
666 m_data.buffer.byte_order = rhs.m_data.buffer.byte_order;
667 break;
668 }
669 return true;
670 }
671
672 uint16_t
GetAsUInt16(uint16_t fail_value,bool * success_ptr) const673 RegisterValue::GetAsUInt16 (uint16_t fail_value, bool *success_ptr) const
674 {
675 if (success_ptr)
676 *success_ptr = true;
677
678 switch (m_type)
679 {
680 default: break;
681 case eTypeUInt8: return m_data.uint8;
682 case eTypeUInt16: return m_data.uint16;
683 case eTypeBytes:
684 {
685 switch (m_data.buffer.length)
686 {
687 default: break;
688 case 1: return m_data.uint8;
689 case 2: return m_data.uint16;
690 }
691 }
692 break;
693 }
694 if (success_ptr)
695 *success_ptr = false;
696 return fail_value;
697 }
698
699 uint32_t
GetAsUInt32(uint32_t fail_value,bool * success_ptr) const700 RegisterValue::GetAsUInt32 (uint32_t fail_value, bool *success_ptr) const
701 {
702 if (success_ptr)
703 *success_ptr = true;
704 switch (m_type)
705 {
706 default: break;
707 case eTypeUInt8: return m_data.uint8;
708 case eTypeUInt16: return m_data.uint16;
709 case eTypeUInt32: return m_data.uint32;
710 case eTypeFloat:
711 if (sizeof(float) == sizeof(uint32_t))
712 return m_data.uint32;
713 break;
714 case eTypeDouble:
715 if (sizeof(double) == sizeof(uint32_t))
716 return m_data.uint32;
717 break;
718 case eTypeLongDouble:
719 if (sizeof(long double) == sizeof(uint32_t))
720 return m_data.uint32;
721 break;
722 case eTypeBytes:
723 {
724 switch (m_data.buffer.length)
725 {
726 default: break;
727 case 1: return m_data.uint8;
728 case 2: return m_data.uint16;
729 case 4: return m_data.uint32;
730 }
731 }
732 break;
733 }
734 if (success_ptr)
735 *success_ptr = false;
736 return fail_value;
737 }
738
739 uint64_t
GetAsUInt64(uint64_t fail_value,bool * success_ptr) const740 RegisterValue::GetAsUInt64 (uint64_t fail_value, bool *success_ptr) const
741 {
742 if (success_ptr)
743 *success_ptr = true;
744 switch (m_type)
745 {
746 default: break;
747 case eTypeUInt8: return m_data.uint8;
748 case eTypeUInt16: return m_data.uint16;
749 case eTypeUInt32: return m_data.uint32;
750 case eTypeUInt64: return m_data.uint64;
751 case eTypeFloat:
752 if (sizeof(float) == sizeof(uint64_t))
753 return m_data.uint64;
754 break;
755 case eTypeDouble:
756 if (sizeof(double) == sizeof(uint64_t))
757 return m_data.uint64;
758 break;
759 case eTypeLongDouble:
760 if (sizeof(long double) == sizeof(uint64_t))
761 return m_data.uint64;
762 break;
763 case eTypeBytes:
764 {
765 switch (m_data.buffer.length)
766 {
767 default: break;
768 case 1: return m_data.uint8;
769 case 2: return m_data.uint16;
770 case 4: return m_data.uint32;
771 case 8: return m_data.uint64;
772 }
773 }
774 break;
775 }
776 if (success_ptr)
777 *success_ptr = false;
778 return fail_value;
779 }
780
781 #if defined (ENABLE_128_BIT_SUPPORT)
782 __uint128_t
GetAsUInt128(__uint128_t fail_value,bool * success_ptr) const783 RegisterValue::GetAsUInt128 (__uint128_t fail_value, bool *success_ptr) const
784 {
785 if (success_ptr)
786 *success_ptr = true;
787 switch (m_type)
788 {
789 default: break;
790 case eTypeUInt8: return m_data.uint8;
791 case eTypeUInt16: return m_data.uint16;
792 case eTypeUInt32: return m_data.uint32;
793 case eTypeUInt64: return m_data.uint64;
794 case eTypeUInt128: return m_data.uint128;
795 case eTypeFloat:
796 if (sizeof(float) == sizeof(__uint128_t))
797 return m_data.uint128;
798 break;
799 case eTypeDouble:
800 if (sizeof(double) == sizeof(__uint128_t))
801 return m_data.uint128;
802 break;
803 case eTypeLongDouble:
804 if (sizeof(long double) == sizeof(__uint128_t))
805 return m_data.uint128;
806 break;
807 case eTypeBytes:
808 {
809 switch (m_data.buffer.length)
810 {
811 default:
812 break;
813 case 1: return m_data.uint8;
814 case 2: return m_data.uint16;
815 case 4: return m_data.uint32;
816 case 8: return m_data.uint64;
817 case 16: return m_data.uint128;
818 }
819 }
820 break;
821 }
822 if (success_ptr)
823 *success_ptr = false;
824 return fail_value;
825 }
826 #endif
827 float
GetAsFloat(float fail_value,bool * success_ptr) const828 RegisterValue::GetAsFloat (float fail_value, bool *success_ptr) const
829 {
830 if (success_ptr)
831 *success_ptr = true;
832 switch (m_type)
833 {
834 default: break;
835 case eTypeUInt32:
836 if (sizeof(float) == sizeof(m_data.uint32))
837 return m_data.ieee_float;
838 break;
839 case eTypeUInt64:
840 if (sizeof(float) == sizeof(m_data.uint64))
841 return m_data.ieee_float;
842 break;
843 #if defined (ENABLE_128_BIT_SUPPORT)
844 case eTypeUInt128:
845 if (sizeof(float) == sizeof(m_data.uint128))
846 return m_data.ieee_float;
847 break;
848 #endif
849 case eTypeFloat: return m_data.ieee_float;
850 case eTypeDouble:
851 if (sizeof(float) == sizeof(double))
852 return m_data.ieee_float;
853 break;
854 case eTypeLongDouble:
855 if (sizeof(float) == sizeof(long double))
856 return m_data.ieee_float;
857 break;
858 }
859 if (success_ptr)
860 *success_ptr = false;
861 return fail_value;
862 }
863
864 double
GetAsDouble(double fail_value,bool * success_ptr) const865 RegisterValue::GetAsDouble (double fail_value, bool *success_ptr) const
866 {
867 if (success_ptr)
868 *success_ptr = true;
869 switch (m_type)
870 {
871 default:
872 break;
873
874 case eTypeUInt32:
875 if (sizeof(double) == sizeof(m_data.uint32))
876 return m_data.ieee_double;
877 break;
878
879 case eTypeUInt64:
880 if (sizeof(double) == sizeof(m_data.uint64))
881 return m_data.ieee_double;
882 break;
883
884 #if defined (ENABLE_128_BIT_SUPPORT)
885 case eTypeUInt128:
886 if (sizeof(double) == sizeof(m_data.uint128))
887 return m_data.ieee_double;
888 #endif
889 case eTypeFloat: return m_data.ieee_float;
890 case eTypeDouble: return m_data.ieee_double;
891
892 case eTypeLongDouble:
893 if (sizeof(double) == sizeof(long double))
894 return m_data.ieee_double;
895 break;
896 }
897 if (success_ptr)
898 *success_ptr = false;
899 return fail_value;
900 }
901
902 long double
GetAsLongDouble(long double fail_value,bool * success_ptr) const903 RegisterValue::GetAsLongDouble (long double fail_value, bool *success_ptr) const
904 {
905 if (success_ptr)
906 *success_ptr = true;
907 switch (m_type)
908 {
909 default:
910 break;
911
912 case eTypeUInt32:
913 if (sizeof(long double) == sizeof(m_data.uint32))
914 return m_data.ieee_long_double;
915 break;
916
917 case eTypeUInt64:
918 if (sizeof(long double) == sizeof(m_data.uint64))
919 return m_data.ieee_long_double;
920 break;
921
922 #if defined (ENABLE_128_BIT_SUPPORT)
923 case eTypeUInt128:
924 if (sizeof(long double) == sizeof(m_data.uint128))
925 return m_data.ieee_long_double;
926 #endif
927 case eTypeFloat: return m_data.ieee_float;
928 case eTypeDouble: return m_data.ieee_double;
929 case eTypeLongDouble: return m_data.ieee_long_double;
930 break;
931 }
932 if (success_ptr)
933 *success_ptr = false;
934 return fail_value;
935 }
936
937 const void *
GetBytes() const938 RegisterValue::GetBytes () const
939 {
940 switch (m_type)
941 {
942 case eTypeInvalid: break;
943 case eTypeUInt8: return &m_data.uint8;
944 case eTypeUInt16: return &m_data.uint16;
945 case eTypeUInt32: return &m_data.uint32;
946 case eTypeUInt64: return &m_data.uint64;
947 #if defined (ENABLE_128_BIT_SUPPORT)
948 case eTypeUInt128: return &m_data.uint128;
949 #endif
950 case eTypeFloat: return &m_data.ieee_float;
951 case eTypeDouble: return &m_data.ieee_double;
952 case eTypeLongDouble: return &m_data.ieee_long_double;
953 case eTypeBytes: return m_data.buffer.bytes;
954 }
955 return NULL;
956 }
957
958 void *
GetBytes()959 RegisterValue::GetBytes ()
960 {
961 switch (m_type)
962 {
963 case eTypeInvalid: break;
964 case eTypeUInt8: return &m_data.uint8;
965 case eTypeUInt16: return &m_data.uint16;
966 case eTypeUInt32: return &m_data.uint32;
967 case eTypeUInt64: return &m_data.uint64;
968 #if defined (ENABLE_128_BIT_SUPPORT)
969 case eTypeUInt128: return &m_data.uint128;
970 #endif
971 case eTypeFloat: return &m_data.ieee_float;
972 case eTypeDouble: return &m_data.ieee_double;
973 case eTypeLongDouble: return &m_data.ieee_long_double;
974 case eTypeBytes: return m_data.buffer.bytes;
975 }
976 return NULL;
977 }
978
979 uint32_t
GetByteSize() const980 RegisterValue::GetByteSize () const
981 {
982 switch (m_type)
983 {
984 case eTypeInvalid: break;
985 case eTypeUInt8: return sizeof(m_data.uint8);
986 case eTypeUInt16: return sizeof(m_data.uint16);
987 case eTypeUInt32: return sizeof(m_data.uint32);
988 case eTypeUInt64: return sizeof(m_data.uint64);
989 #if defined (ENABLE_128_BIT_SUPPORT)
990 case eTypeUInt128: return sizeof(m_data.uint128);
991 #endif
992 case eTypeFloat: return sizeof(m_data.ieee_float);
993 case eTypeDouble: return sizeof(m_data.ieee_double);
994 case eTypeLongDouble: return sizeof(m_data.ieee_long_double);
995 case eTypeBytes: return m_data.buffer.length;
996 }
997 return 0;
998 }
999
1000
1001 bool
SetUInt(uint64_t uint,uint32_t byte_size)1002 RegisterValue::SetUInt (uint64_t uint, uint32_t byte_size)
1003 {
1004 if (byte_size == 0)
1005 {
1006 SetUInt64 (uint);
1007 }
1008 else if (byte_size == 1)
1009 {
1010 SetUInt8 (uint);
1011 }
1012 else if (byte_size <= 2)
1013 {
1014 SetUInt16 (uint);
1015 }
1016 else if (byte_size <= 4)
1017 {
1018 SetUInt32 (uint);
1019 }
1020 else if (byte_size <= 8)
1021 {
1022 SetUInt64 (uint);
1023 }
1024 #if defined (ENABLE_128_BIT_SUPPORT)
1025 else if (byte_size <= 16)
1026 {
1027 SetUInt128 (uint);
1028 }
1029 #endif
1030 else
1031 return false;
1032 return true;
1033 }
1034
1035 void
SetBytes(const void * bytes,size_t length,lldb::ByteOrder byte_order)1036 RegisterValue::SetBytes (const void *bytes, size_t length, lldb::ByteOrder byte_order)
1037 {
1038 // If this assertion fires off we need to increase the size of
1039 // m_data.buffer.bytes, or make it something that is allocated on
1040 // the heap. Since the data buffer is in a union, we can't make it
1041 // a collection class like SmallVector...
1042 if (bytes && length > 0)
1043 {
1044 assert (length <= sizeof (m_data.buffer.bytes) && "Storing too many bytes in a RegisterValue.");
1045 m_type = eTypeBytes;
1046 m_data.buffer.length = length;
1047 memcpy (m_data.buffer.bytes, bytes, length);
1048 m_data.buffer.byte_order = byte_order;
1049 }
1050 else
1051 {
1052 m_type = eTypeInvalid;
1053 m_data.buffer.length = 0;
1054 }
1055 }
1056
1057
1058 bool
operator ==(const RegisterValue & rhs) const1059 RegisterValue::operator == (const RegisterValue &rhs) const
1060 {
1061 if (m_type == rhs.m_type)
1062 {
1063 switch (m_type)
1064 {
1065 case eTypeInvalid: return true;
1066 case eTypeUInt8: return m_data.uint8 == rhs.m_data.uint8;
1067 case eTypeUInt16: return m_data.uint16 == rhs.m_data.uint16;
1068 case eTypeUInt32: return m_data.uint32 == rhs.m_data.uint32;
1069 case eTypeUInt64: return m_data.uint64 == rhs.m_data.uint64;
1070 #if defined (ENABLE_128_BIT_SUPPORT)
1071 case eTypeUInt128: return m_data.uint128 == rhs.m_data.uint128;
1072 #endif
1073 case eTypeFloat: return m_data.ieee_float == rhs.m_data.ieee_float;
1074 case eTypeDouble: return m_data.ieee_double == rhs.m_data.ieee_double;
1075 case eTypeLongDouble: return m_data.ieee_long_double == rhs.m_data.ieee_long_double;
1076 case eTypeBytes:
1077 if (m_data.buffer.length != rhs.m_data.buffer.length)
1078 return false;
1079 else
1080 {
1081 uint8_t length = m_data.buffer.length;
1082 if (length > kMaxRegisterByteSize)
1083 length = kMaxRegisterByteSize;
1084 return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) == 0;
1085 }
1086 break;
1087 }
1088 }
1089 return false;
1090 }
1091
1092 bool
operator !=(const RegisterValue & rhs) const1093 RegisterValue::operator != (const RegisterValue &rhs) const
1094 {
1095 if (m_type != rhs.m_type)
1096 return true;
1097 switch (m_type)
1098 {
1099 case eTypeInvalid: return false;
1100 case eTypeUInt8: return m_data.uint8 != rhs.m_data.uint8;
1101 case eTypeUInt16: return m_data.uint16 != rhs.m_data.uint16;
1102 case eTypeUInt32: return m_data.uint32 != rhs.m_data.uint32;
1103 case eTypeUInt64: return m_data.uint64 != rhs.m_data.uint64;
1104 #if defined (ENABLE_128_BIT_SUPPORT)
1105 case eTypeUInt128: return m_data.uint128 != rhs.m_data.uint128;
1106 #endif
1107 case eTypeFloat: return m_data.ieee_float != rhs.m_data.ieee_float;
1108 case eTypeDouble: return m_data.ieee_double != rhs.m_data.ieee_double;
1109 case eTypeLongDouble: return m_data.ieee_long_double != rhs.m_data.ieee_long_double;
1110 case eTypeBytes:
1111 if (m_data.buffer.length != rhs.m_data.buffer.length)
1112 {
1113 return true;
1114 }
1115 else
1116 {
1117 uint8_t length = m_data.buffer.length;
1118 if (length > kMaxRegisterByteSize)
1119 length = kMaxRegisterByteSize;
1120 return memcmp (m_data.buffer.bytes, rhs.m_data.buffer.bytes, length) != 0;
1121 }
1122 break;
1123 }
1124 return true;
1125 }
1126
1127 bool
ClearBit(uint32_t bit)1128 RegisterValue::ClearBit (uint32_t bit)
1129 {
1130 switch (m_type)
1131 {
1132 case eTypeInvalid:
1133 break;
1134
1135 case eTypeUInt8:
1136 if (bit < 8)
1137 {
1138 m_data.uint8 &= ~(1u << bit);
1139 return true;
1140 }
1141 break;
1142
1143 case eTypeUInt16:
1144 if (bit < 16)
1145 {
1146 m_data.uint16 &= ~(1u << bit);
1147 return true;
1148 }
1149 break;
1150
1151 case eTypeUInt32:
1152 if (bit < 32)
1153 {
1154 m_data.uint32 &= ~(1u << bit);
1155 return true;
1156 }
1157 break;
1158
1159 case eTypeUInt64:
1160 if (bit < 64)
1161 {
1162 m_data.uint64 &= ~(1ull << (uint64_t)bit);
1163 return true;
1164 }
1165 break;
1166 #if defined (ENABLE_128_BIT_SUPPORT)
1167 case eTypeUInt128:
1168 if (bit < 64)
1169 {
1170 m_data.uint128 &= ~((__uint128_t)1ull << (__uint128_t)bit);
1171 return true;
1172 }
1173 #endif
1174 case eTypeFloat:
1175 case eTypeDouble:
1176 case eTypeLongDouble:
1177 break;
1178
1179 case eTypeBytes:
1180 if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
1181 {
1182 uint32_t byte_idx;
1183 if (m_data.buffer.byte_order == eByteOrderBig)
1184 byte_idx = m_data.buffer.length - (bit / 8) - 1;
1185 else
1186 byte_idx = bit / 8;
1187
1188 const uint32_t byte_bit = bit % 8;
1189 if (byte_idx < m_data.buffer.length)
1190 {
1191 m_data.buffer.bytes[byte_idx] &= ~(1u << byte_bit);
1192 return true;
1193 }
1194 }
1195 break;
1196 }
1197 return false;
1198 }
1199
1200
1201 bool
SetBit(uint32_t bit)1202 RegisterValue::SetBit (uint32_t bit)
1203 {
1204 switch (m_type)
1205 {
1206 case eTypeInvalid:
1207 break;
1208
1209 case eTypeUInt8:
1210 if (bit < 8)
1211 {
1212 m_data.uint8 |= (1u << bit);
1213 return true;
1214 }
1215 break;
1216
1217 case eTypeUInt16:
1218 if (bit < 16)
1219 {
1220 m_data.uint16 |= (1u << bit);
1221 return true;
1222 }
1223 break;
1224
1225 case eTypeUInt32:
1226 if (bit < 32)
1227 {
1228 m_data.uint32 |= (1u << bit);
1229 return true;
1230 }
1231 break;
1232
1233 case eTypeUInt64:
1234 if (bit < 64)
1235 {
1236 m_data.uint64 |= (1ull << (uint64_t)bit);
1237 return true;
1238 }
1239 break;
1240 #if defined (ENABLE_128_BIT_SUPPORT)
1241 case eTypeUInt128:
1242 if (bit < 64)
1243 {
1244 m_data.uint128 |= ((__uint128_t)1ull << (__uint128_t)bit);
1245 return true;
1246 }
1247 #endif
1248 case eTypeFloat:
1249 case eTypeDouble:
1250 case eTypeLongDouble:
1251 break;
1252
1253 case eTypeBytes:
1254 if (m_data.buffer.byte_order == eByteOrderBig || m_data.buffer.byte_order == eByteOrderLittle)
1255 {
1256 uint32_t byte_idx;
1257 if (m_data.buffer.byte_order == eByteOrderBig)
1258 byte_idx = m_data.buffer.length - (bit / 8) - 1;
1259 else
1260 byte_idx = bit / 8;
1261
1262 const uint32_t byte_bit = bit % 8;
1263 if (byte_idx < m_data.buffer.length)
1264 {
1265 m_data.buffer.bytes[byte_idx] |= (1u << byte_bit);
1266 return true;
1267 }
1268 }
1269 break;
1270 }
1271 return false;
1272 }
1273
1274