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