source/Core/RegisterValue.cpp

   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 #include <vector>
  15
  16 // Other libraries and framework includes
  17 #include "llvm/ADT/ArrayRef.h"
  18 #include "llvm/ADT/StringRef.h"
  19
  20 // Project includes
  21 #include "lldb/Core/DataExtractor.h"
  22 #include "lldb/Core/Error.h"
  23 #include "lldb/Core/Scalar.h"
  24 #include "lldb/Core/Stream.h"
  25 #include "lldb/Core/StreamString.h"
  26 #include "lldb/Host/StringConvert.h"
  27 #include "lldb/Interpreter/Args.h"
  28
  29 using namespace lldb;
  30 using namespace lldb_private;
  31
  32 bool RegisterValue::Dump(Stream *s, const RegisterInfo *reg_info,
  33                          bool prefix_with_name, bool prefix_with_alt_name,
  34                          Format format,
  35                          uint32_t reg_name_right_align_at) const {
  36   DataExtractor data;
  37   if (GetData(data)) {
  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     std::string fmt = format_string.GetString();
  50     if (prefix_with_name) {
  51       if (reg_info->name) {
  52         s->Printf(fmt.c_str(), reg_info->name);
  53         name_printed = true;
  54       } else if (reg_info->alt_name) {
  55         s->Printf(fmt.c_str(), reg_info->alt_name);
  56         prefix_with_alt_name = false;
  57         name_printed = true;
  58       }
  59     }
  60     if (prefix_with_alt_name) {
  61       if (name_printed)
  62         s->PutChar('/');
  63       if (reg_info->alt_name) {
  64         s->Printf(fmt.c_str(), reg_info->alt_name);
  65         name_printed = true;
  66       } else if (!name_printed) {
  67         // No alternate name but we were asked to display a name, so show the
  68         // main name
  69         s->Printf(fmt.c_str(), reg_info->name);
  70         name_printed = true;
  71       }
  72     }
  73     if (name_printed)
  74       s->PutCString(" = ");
  75
  76     if (format == eFormatDefault)
  77       format = reg_info->format;
  78
  79     data.Dump(s,
  80               0,                    // Offset in "data"
  81               format,               // Format to use when dumping
  82               reg_info->byte_size,  // item_byte_size
  83               1,                    // item_count
  84               UINT32_MAX,           // num_per_line
  85               LLDB_INVALID_ADDRESS, // base_addr
  86               0,                    // item_bit_size
  87               0);                   // item_bit_offset
  88     return true;
  89   }
  90   return false;
  91 }
  92
  93 bool RegisterValue::GetData(DataExtractor &data) const {
  94   return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
  95 }
  96
  97 uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
  98                                         uint32_t dst_len,
  99                                         lldb::ByteOrder dst_byte_order,
 100                                         Error &error) const {
 101   if (reg_info == nullptr) {
 102     error.SetErrorString("invalid register info argument.");
 103     return 0;
 104   }
 105
 106   // ReadRegister should have already been called on this object prior to
 107   // calling this.
 108   if (GetType() == eTypeInvalid) {
 109     // No value has been read into this object...
 110     error.SetErrorStringWithFormat(
 111         "invalid register value type for register %s", reg_info->name);
 112     return 0;
 113   }
 114
 115   if (dst_len > kMaxRegisterByteSize) {
 116     error.SetErrorString("destination is too big");
 117     return 0;
 118   }
 119
 120   const uint32_t src_len = reg_info->byte_size;
 121
 122   // Extract the register data into a data extractor
 123   DataExtractor reg_data;
 124   if (!GetData(reg_data)) {
 125     error.SetErrorString("invalid register value to copy into");
 126     return 0;
 127   }
 128
 129   // Prepare a memory buffer that contains some or all of the register value
 130   const uint32_t bytes_copied =
 131       reg_data.CopyByteOrderedData(0,               // src offset
 132                                    src_len,         // src length
 133                                    dst,             // dst buffer
 134                                    dst_len,         // dst length
 135                                    dst_byte_order); // dst byte order
 136   if (bytes_copied == 0)
 137     error.SetErrorStringWithFormat(
 138         "failed to copy data for register write of %s", reg_info->name);
 139
 140   return bytes_copied;
 141 }
 142
 143 uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo *reg_info,
 144                                           const void *src, uint32_t src_len,
 145                                           lldb::ByteOrder src_byte_order,
 146                                           Error &error) {
 147   if (reg_info == nullptr) {
 148     error.SetErrorString("invalid register info argument.");
 149     return 0;
 150   }
 151
 152   // Moving from addr into a register
 153   //
 154   // Case 1: src_len == dst_len
 155   //
 156   //   |AABBCCDD| Address contents
 157   //   |AABBCCDD| Register contents
 158   //
 159   // Case 2: src_len > dst_len
 160   //
 161   //   Error!  (The register should always be big enough to hold the data)
 162   //
 163   // Case 3: src_len < dst_len
 164   //
 165   //   |AABB| Address contents
 166   //   |AABB0000| Register contents [on little-endian hardware]
 167   //   |0000AABB| Register contents [on big-endian hardware]
 168   if (src_len > kMaxRegisterByteSize) {
 169     error.SetErrorStringWithFormat(
 170         "register buffer is too small to receive %u bytes of data.", src_len);
 171     return 0;
 172   }
 173
 174   const uint32_t dst_len = reg_info->byte_size;
 175
 176   if (src_len > dst_len) {
 177     error.SetErrorStringWithFormat(
 178         "%u bytes is too big to store in register %s (%u bytes)", src_len,
 179         reg_info->name, dst_len);
 180     return 0;
 181   }
 182
 183   // Use a data extractor to correctly copy and pad the bytes read into the
 184   // register value
 185   DataExtractor src_data(src, src_len, src_byte_order, 4);
 186
 187   error = SetValueFromData(reg_info, src_data, 0, true);
 188   if (error.Fail())
 189     return 0;
 190
 191   // If SetValueFromData succeeded, we must have copied all of src_len
 192   return src_len;
 193 }
 194
 195 bool RegisterValue::GetScalarValue(Scalar &scalar) const {
 196   switch (m_type) {
 197   case eTypeInvalid:
 198     break;
 199   case eTypeBytes: {
 200     switch (buffer.length) {
 201     default:
 202       break;
 203     case 1:
 204       scalar = *(const uint8_t *)buffer.bytes;
 205       return true;
 206     case 2:
 207       scalar = *(const uint16_t *)buffer.bytes;
 208       return true;
 209     case 4:
 210       scalar = *(const uint32_t *)buffer.bytes;
 211       return true;
 212     case 8:
 213       scalar = *(const uint64_t *)buffer.bytes;
 214       return true;
 215     case 16:
 216     case 32:
 217       if (buffer.length % sizeof(uint64_t) == 0) {
 218         const auto length_in_bits = buffer.length * 8;
 219         const auto length_in_uint64 = buffer.length / sizeof(uint64_t);
 220         scalar =
 221             llvm::APInt(length_in_bits,
 222                         llvm::ArrayRef<uint64_t>((const uint64_t *)buffer.bytes,
 223                                                  length_in_uint64));
 224         return true;
 225       }
 226       break;
 227     }
 228   } break;
 229   case eTypeUInt8:
 230   case eTypeUInt16:
 231   case eTypeUInt32:
 232   case eTypeUInt64:
 233   case eTypeUInt128:
 234   case eTypeFloat:
 235   case eTypeDouble:
 236   case eTypeLongDouble:
 237     scalar = m_scalar;
 238     return true;
 239   }
 240   return false;
 241 }
 242
 243 void RegisterValue::Clear() { m_type = eTypeInvalid; }
 244
 245 RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
 246   // To change the type, we simply copy the data in again, using the new format
 247   RegisterValue copy;
 248   DataExtractor copy_data;
 249   if (copy.CopyValue(*this) && copy.GetData(copy_data))
 250     SetValueFromData(reg_info, copy_data, 0, true);
 251
 252   return m_type;
 253 }
 254
 255 Error RegisterValue::SetValueFromData(const RegisterInfo *reg_info,
 256                                       DataExtractor &src,
 257                                       lldb::offset_t src_offset,
 258                                       bool partial_data_ok) {
 259   Error error;
 260
 261   if (src.GetByteSize() == 0) {
 262     error.SetErrorString("empty data.");
 263     return error;
 264   }
 265
 266   if (reg_info->byte_size == 0) {
 267     error.SetErrorString("invalid register info.");
 268     return error;
 269   }
 270
 271   uint32_t src_len = src.GetByteSize() - src_offset;
 272
 273   if (!partial_data_ok && (src_len < reg_info->byte_size)) {
 274     error.SetErrorString("not enough data.");
 275     return error;
 276   }
 277
 278   // Cap the data length if there is more than enough bytes for this register
 279   // value
 280   if (src_len > reg_info->byte_size)
 281     src_len = reg_info->byte_size;
 282
 283   // Zero out the value in case we get partial data...
 284   memset(buffer.bytes, 0, sizeof(buffer.bytes));
 285
 286   type128 int128;
 287
 288   m_type = eTypeInvalid;
 289   switch (reg_info->encoding) {
 290   case eEncodingInvalid:
 291     break;
 292   case eEncodingUint:
 293   case eEncodingSint:
 294     if (reg_info->byte_size == 1)
 295       SetUInt8(src.GetMaxU32(&src_offset, src_len));
 296     else if (reg_info->byte_size <= 2)
 297       SetUInt16(src.GetMaxU32(&src_offset, src_len));
 298     else if (reg_info->byte_size <= 4)
 299       SetUInt32(src.GetMaxU32(&src_offset, src_len));
 300     else if (reg_info->byte_size <= 8)
 301       SetUInt64(src.GetMaxU64(&src_offset, src_len));
 302     else if (reg_info->byte_size <= 16) {
 303       uint64_t data1 = src.GetU64(&src_offset);
 304       uint64_t data2 = src.GetU64(&src_offset);
 305       if (src.GetByteSize() == eByteOrderBig) {
 306         int128.x[0] = data1;
 307         int128.x[1] = data2;
 308       } else {
 309         int128.x[0] = data2;
 310         int128.x[1] = data1;
 311       }
 312       SetUInt128(llvm::APInt(128, 2, int128.x));
 313     }
 314     break;
 315   case eEncodingIEEE754:
 316     if (reg_info->byte_size == sizeof(float))
 317       SetFloat(src.GetFloat(&src_offset));
 318     else if (reg_info->byte_size == sizeof(double))
 319       SetDouble(src.GetDouble(&src_offset));
 320     else if (reg_info->byte_size == sizeof(long double))
 321       SetLongDouble(src.GetLongDouble(&src_offset));
 322     break;
 323   case eEncodingVector: {
 324     m_type = eTypeBytes;
 325     buffer.length = reg_info->byte_size;
 326     buffer.byte_order = src.GetByteOrder();
 327     assert(buffer.length <= kMaxRegisterByteSize);
 328     if (buffer.length > kMaxRegisterByteSize)
 329       buffer.length = kMaxRegisterByteSize;
 330     if (src.CopyByteOrderedData(
 331             src_offset,    // offset within "src" to start extracting data
 332             src_len,       // src length
 333             buffer.bytes,  // dst buffer
 334             buffer.length, // dst length
 335             buffer.byte_order) == 0) // dst byte order
 336     {
 337       error.SetErrorStringWithFormat(
 338           "failed to copy data for register write of %s", reg_info->name);
 339       return error;
 340     }
 341   }
 342   }
 343
 344   if (m_type == eTypeInvalid)
 345     error.SetErrorStringWithFormat(
 346         "invalid register value type for register %s", reg_info->name);
 347   return error;
 348 }
 349
 350 // Helper function for RegisterValue::SetValueFromString()
 351 static bool ParseVectorEncoding(const RegisterInfo *reg_info,
 352                                 llvm::StringRef vector_str,
 353                                 const uint32_t byte_size,
 354                                 RegisterValue *reg_value) {
 355   // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a
 356   // 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
 357   vector_str = vector_str.trim();
 358   vector_str.consume_front("{");
 359   vector_str.consume_back("}");
 360   vector_str = vector_str.trim();
 361
 362   char Sep = ' ';
 363
 364   // The first split should give us:
 365   // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f
 366   // 0x2a 0x3e').
 367   llvm::StringRef car;
 368   llvm::StringRef cdr = vector_str;
 369   std::tie(car, cdr) = vector_str.split(Sep);
 370   std::vector<uint8_t> bytes;
 371   unsigned byte = 0;
 372
 373   // Using radix auto-sensing by passing 0 as the radix.
 374   // Keep on processing the vector elements as long as the parsing succeeds and
 375   // the vector size is < byte_size.
 376   while (!car.getAsInteger(0, byte) && bytes.size() < byte_size) {
 377     bytes.push_back(byte);
 378     std::tie(car, cdr) = cdr.split(Sep);
 379   }
 380
 381   // Check for vector of exact byte_size elements.
 382   if (bytes.size() != byte_size)
 383     return false;
 384
 385   reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
 386   return true;
 387 }
 388
 389 Error RegisterValue::SetValueFromString(const RegisterInfo *reg_info,
 390                                         llvm::StringRef value_str) {
 391   Error error;
 392   if (reg_info == nullptr) {
 393     error.SetErrorString("Invalid register info argument.");
 394     return error;
 395   }
 396
 397   m_type = eTypeInvalid;
 398   if (value_str.empty()) {
 399     error.SetErrorString("Invalid c-string value string.");
 400     return error;
 401   }
 402   const uint32_t byte_size = reg_info->byte_size;
 403
 404   uint64_t uval64;
 405   int64_t ival64;
 406   float flt_val;
 407   double dbl_val;
 408   long double ldbl_val;
 409   switch (reg_info->encoding) {
 410   case eEncodingInvalid:
 411     error.SetErrorString("Invalid encoding.");
 412     break;
 413
 414   case eEncodingUint:
 415     if (byte_size > sizeof(uint64_t)) {
 416       error.SetErrorStringWithFormat(
 417           "unsupported unsigned integer byte size: %u", byte_size);
 418       break;
 419     }
 420     if (value_str.getAsInteger(0, uval64)) {
 421       error.SetErrorStringWithFormat(
 422           "'%s' is not a valid unsigned integer string value",
 423           value_str.str().c_str());
 424       break;
 425     }
 426
 427     if (!Args::UInt64ValueIsValidForByteSize(uval64, byte_size)) {
 428       error.SetErrorStringWithFormat(
 429           "value 0x%" PRIx64
 430           " is too large to fit in a %u byte unsigned integer value",
 431           uval64, byte_size);
 432       break;
 433     }
 434
 435     if (!SetUInt(uval64, reg_info->byte_size)) {
 436       error.SetErrorStringWithFormat(
 437           "unsupported unsigned integer byte size: %u", byte_size);
 438       break;
 439     }
 440     // TODO: Shouldn't we be setting m_type here?
 441     break;
 442
 443   case eEncodingSint:
 444     if (byte_size > sizeof(long long)) {
 445       error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
 446                                      byte_size);
 447       break;
 448     }
 449
 450     if (value_str.getAsInteger(0, ival64)) {
 451       error.SetErrorStringWithFormat(
 452           "'%s' is not a valid signed integer string value",
 453           value_str.str().c_str());
 454       break;
 455     }
 456
 457     if (!Args::SInt64ValueIsValidForByteSize(ival64, byte_size)) {
 458       error.SetErrorStringWithFormat(
 459           "value 0x%" PRIx64
 460           " is too large to fit in a %u byte signed integer value",
 461           ival64, byte_size);
 462       break;
 463     }
 464
 465     if (!SetUInt(ival64, reg_info->byte_size)) {
 466       error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
 467                                      byte_size);
 468       break;
 469     }
 470
 471     // TODO: Shouldn't we be setting m_type here?
 472     break;
 473
 474   case eEncodingIEEE754: {
 475     std::string value_string = value_str;
 476     if (byte_size == sizeof(float)) {
 477       if (::sscanf(value_string.c_str(), "%f", &flt_val) != 1) {
 478         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
 479                                        value_string.c_str());
 480         break;
 481       }
 482       m_scalar = flt_val;
 483       m_type = eTypeFloat;
 484     } else if (byte_size == sizeof(double)) {
 485       if (::sscanf(value_string.c_str(), "%lf", &dbl_val) != 1) {
 486         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
 487                                        value_string.c_str());
 488         break;
 489       }
 490       m_scalar = dbl_val;
 491       m_type = eTypeDouble;
 492     } else if (byte_size == sizeof(long double)) {
 493       if (::sscanf(value_string.c_str(), "%Lf", &ldbl_val) != 1) {
 494         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
 495                                        value_string.c_str());
 496         break;
 497       }
 498       m_scalar = ldbl_val;
 499       m_type = eTypeLongDouble;
 500     } else {
 501       error.SetErrorStringWithFormat("unsupported float byte size: %u",
 502                                      byte_size);
 503       return error;
 504     }
 505     break;
 506   }
 507   case eEncodingVector:
 508     if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
 509       error.SetErrorString("unrecognized vector encoding string value.");
 510     break;
 511   }
 512
 513   return error;
 514 }
 515
 516 bool RegisterValue::SignExtend(uint32_t sign_bitpos) {
 517   switch (m_type) {
 518   case eTypeInvalid:
 519     break;
 520
 521   case eTypeUInt8:
 522   case eTypeUInt16:
 523   case eTypeUInt32:
 524   case eTypeUInt64:
 525   case eTypeUInt128:
 526     return m_scalar.SignExtend(sign_bitpos);
 527   case eTypeFloat:
 528   case eTypeDouble:
 529   case eTypeLongDouble:
 530   case eTypeBytes:
 531     break;
 532   }
 533   return false;
 534 }
 535
 536 bool RegisterValue::CopyValue(const RegisterValue &rhs) {
 537   m_type = rhs.m_type;
 538   switch (m_type) {
 539   case eTypeInvalid:
 540     return false;
 541   case eTypeUInt8:
 542   case eTypeUInt16:
 543   case eTypeUInt32:
 544   case eTypeUInt64:
 545   case eTypeUInt128:
 546   case eTypeFloat:
 547   case eTypeDouble:
 548   case eTypeLongDouble:
 549     m_scalar = rhs.m_scalar;
 550     break;
 551   case eTypeBytes:
 552     assert(rhs.buffer.length <= kMaxRegisterByteSize);
 553     ::memcpy(buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
 554     buffer.length = rhs.buffer.length;
 555     buffer.byte_order = rhs.buffer.byte_order;
 556     break;
 557   }
 558   return true;
 559 }
 560
 561 uint16_t RegisterValue::GetAsUInt16(uint16_t fail_value,
 562                                     bool *success_ptr) const {
 563   if (success_ptr)
 564     *success_ptr = true;
 565
 566   switch (m_type) {
 567   default:
 568     break;
 569   case eTypeUInt8:
 570   case eTypeUInt16:
 571     return m_scalar.UShort(fail_value);
 572   case eTypeBytes: {
 573     switch (buffer.length) {
 574     default:
 575       break;
 576     case 1:
 577     case 2:
 578       return *(const uint16_t *)buffer.bytes;
 579     }
 580   } break;
 581   }
 582   if (success_ptr)
 583     *success_ptr = false;
 584   return fail_value;
 585 }
 586
 587 uint32_t RegisterValue::GetAsUInt32(uint32_t fail_value,
 588                                     bool *success_ptr) const {
 589   if (success_ptr)
 590     *success_ptr = true;
 591   switch (m_type) {
 592   default:
 593     break;
 594   case eTypeUInt8:
 595   case eTypeUInt16:
 596   case eTypeUInt32:
 597   case eTypeFloat:
 598   case eTypeDouble:
 599   case eTypeLongDouble:
 600     return m_scalar.UInt(fail_value);
 601   case eTypeBytes: {
 602     switch (buffer.length) {
 603     default:
 604       break;
 605     case 1:
 606     case 2:
 607     case 4:
 608       return *(const uint32_t *)buffer.bytes;
 609     }
 610   } break;
 611   }
 612   if (success_ptr)
 613     *success_ptr = false;
 614   return fail_value;
 615 }
 616
 617 uint64_t RegisterValue::GetAsUInt64(uint64_t fail_value,
 618                                     bool *success_ptr) const {
 619   if (success_ptr)
 620     *success_ptr = true;
 621   switch (m_type) {
 622   default:
 623     break;
 624   case eTypeUInt8:
 625   case eTypeUInt16:
 626   case eTypeUInt32:
 627   case eTypeUInt64:
 628   case eTypeFloat:
 629   case eTypeDouble:
 630   case eTypeLongDouble:
 631     return m_scalar.ULongLong(fail_value);
 632   case eTypeBytes: {
 633     switch (buffer.length) {
 634     default:
 635       break;
 636     case 1:
 637       return *(const uint8_t *)buffer.bytes;
 638     case 2:
 639       return *(const uint16_t *)buffer.bytes;
 640     case 4:
 641       return *(const uint32_t *)buffer.bytes;
 642     case 8:
 643       return *(const uint64_t *)buffer.bytes;
 644     }
 645   } break;
 646   }
 647   if (success_ptr)
 648     *success_ptr = false;
 649   return fail_value;
 650 }
 651
 652 llvm::APInt RegisterValue::GetAsUInt128(const llvm::APInt &fail_value,
 653                                         bool *success_ptr) const {
 654   if (success_ptr)
 655     *success_ptr = true;
 656   switch (m_type) {
 657   default:
 658     break;
 659   case eTypeUInt8:
 660   case eTypeUInt16:
 661   case eTypeUInt32:
 662   case eTypeUInt64:
 663   case eTypeUInt128:
 664   case eTypeFloat:
 665   case eTypeDouble:
 666   case eTypeLongDouble:
 667     return m_scalar.UInt128(fail_value);
 668   case eTypeBytes: {
 669     switch (buffer.length) {
 670     default:
 671       break;
 672     case 1:
 673     case 2:
 674     case 4:
 675     case 8:
 676     case 16:
 677       return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
 678                          ((const type128 *)buffer.bytes)->x);
 679     }
 680   } break;
 681   }
 682   if (success_ptr)
 683     *success_ptr = false;
 684   return fail_value;
 685 }
 686
 687 float RegisterValue::GetAsFloat(float fail_value, bool *success_ptr) const {
 688   if (success_ptr)
 689     *success_ptr = true;
 690   switch (m_type) {
 691   default:
 692     break;
 693   case eTypeUInt32:
 694   case eTypeUInt64:
 695   case eTypeUInt128:
 696   case eTypeFloat:
 697   case eTypeDouble:
 698   case eTypeLongDouble:
 699     return m_scalar.Float(fail_value);
 700   }
 701   if (success_ptr)
 702     *success_ptr = false;
 703   return fail_value;
 704 }
 705
 706 double RegisterValue::GetAsDouble(double fail_value, bool *success_ptr) const {
 707   if (success_ptr)
 708     *success_ptr = true;
 709   switch (m_type) {
 710   default:
 711     break;
 712
 713   case eTypeUInt32:
 714   case eTypeUInt64:
 715   case eTypeUInt128:
 716   case eTypeFloat:
 717   case eTypeDouble:
 718   case eTypeLongDouble:
 719     return m_scalar.Double(fail_value);
 720   }
 721   if (success_ptr)
 722     *success_ptr = false;
 723   return fail_value;
 724 }
 725
 726 long double RegisterValue::GetAsLongDouble(long double fail_value,
 727                                            bool *success_ptr) const {
 728   if (success_ptr)
 729     *success_ptr = true;
 730   switch (m_type) {
 731   default:
 732     break;
 733
 734   case eTypeUInt32:
 735   case eTypeUInt64:
 736   case eTypeUInt128:
 737   case eTypeFloat:
 738   case eTypeDouble:
 739   case eTypeLongDouble:
 740     return m_scalar.LongDouble();
 741   }
 742   if (success_ptr)
 743     *success_ptr = false;
 744   return fail_value;
 745 }
 746
 747 const void *RegisterValue::GetBytes() const {
 748   switch (m_type) {
 749   case eTypeInvalid:
 750     break;
 751   case eTypeUInt8:
 752   case eTypeUInt16:
 753   case eTypeUInt32:
 754   case eTypeUInt64:
 755   case eTypeUInt128:
 756   case eTypeFloat:
 757   case eTypeDouble:
 758   case eTypeLongDouble:
 759     return m_scalar.GetBytes();
 760   case eTypeBytes:
 761     return buffer.bytes;
 762   }
 763   return nullptr;
 764 }
 765
 766 uint32_t RegisterValue::GetByteSize() const {
 767   switch (m_type) {
 768   case eTypeInvalid:
 769     break;
 770   case eTypeUInt8:
 771     return 1;
 772   case eTypeUInt16:
 773     return 2;
 774   case eTypeUInt32:
 775   case eTypeUInt64:
 776   case eTypeUInt128:
 777   case eTypeFloat:
 778   case eTypeDouble:
 779   case eTypeLongDouble:
 780     return m_scalar.GetByteSize();
 781   case eTypeBytes:
 782     return buffer.length;
 783   }
 784   return 0;
 785 }
 786
 787 bool RegisterValue::SetUInt(uint64_t uint, uint32_t byte_size) {
 788   if (byte_size == 0) {
 789     SetUInt64(uint);
 790   } else if (byte_size == 1) {
 791     SetUInt8(uint);
 792   } else if (byte_size <= 2) {
 793     SetUInt16(uint);
 794   } else if (byte_size <= 4) {
 795     SetUInt32(uint);
 796   } else if (byte_size <= 8) {
 797     SetUInt64(uint);
 798   } else if (byte_size <= 16) {
 799     SetUInt128(llvm::APInt(128, uint));
 800   } else
 801     return false;
 802   return true;
 803 }
 804
 805 void RegisterValue::SetBytes(const void *bytes, size_t length,
 806                              lldb::ByteOrder byte_order) {
 807   // If this assertion fires off we need to increase the size of
 808   // buffer.bytes, or make it something that is allocated on
 809   // the heap. Since the data buffer is in a union, we can't make it
 810   // a collection class like SmallVector...
 811   if (bytes && length > 0) {
 812     assert(length <= sizeof(buffer.bytes) &&
 813            "Storing too many bytes in a RegisterValue.");
 814     m_type = eTypeBytes;
 815     buffer.length = length;
 816     memcpy(buffer.bytes, bytes, length);
 817     buffer.byte_order = byte_order;
 818   } else {
 819     m_type = eTypeInvalid;
 820     buffer.length = 0;
 821   }
 822 }
 823
 824 bool RegisterValue::operator==(const RegisterValue &rhs) const {
 825   if (m_type == rhs.m_type) {
 826     switch (m_type) {
 827     case eTypeInvalid:
 828       return true;
 829     case eTypeUInt8:
 830     case eTypeUInt16:
 831     case eTypeUInt32:
 832     case eTypeUInt64:
 833     case eTypeUInt128:
 834     case eTypeFloat:
 835     case eTypeDouble:
 836     case eTypeLongDouble:
 837       return m_scalar == rhs.m_scalar;
 838     case eTypeBytes:
 839       if (buffer.length != rhs.buffer.length)
 840         return false;
 841       else {
 842         uint8_t length = buffer.length;
 843         if (length > kMaxRegisterByteSize)
 844           length = kMaxRegisterByteSize;
 845         return memcmp(buffer.bytes, rhs.buffer.bytes, length) == 0;
 846       }
 847       break;
 848     }
 849   }
 850   return false;
 851 }
 852
 853 bool RegisterValue::operator!=(const RegisterValue &rhs) const {
 854   if (m_type != rhs.m_type)
 855     return true;
 856   switch (m_type) {
 857   case eTypeInvalid:
 858     return false;
 859   case eTypeUInt8:
 860   case eTypeUInt16:
 861   case eTypeUInt32:
 862   case eTypeUInt64:
 863   case eTypeUInt128:
 864   case eTypeFloat:
 865   case eTypeDouble:
 866   case eTypeLongDouble:
 867     return m_scalar != rhs.m_scalar;
 868   case eTypeBytes:
 869     if (buffer.length != rhs.buffer.length) {
 870       return true;
 871     } else {
 872       uint8_t length = buffer.length;
 873       if (length > kMaxRegisterByteSize)
 874         length = kMaxRegisterByteSize;
 875       return memcmp(buffer.bytes, rhs.buffer.bytes, length) != 0;
 876     }
 877     break;
 878   }
 879   return true;
 880 }
 881
 882 bool RegisterValue::ClearBit(uint32_t bit) {
 883   switch (m_type) {
 884   case eTypeInvalid:
 885     break;
 886
 887   case eTypeUInt8:
 888   case eTypeUInt16:
 889   case eTypeUInt32:
 890   case eTypeUInt64:
 891   case eTypeUInt128:
 892     if (bit < (GetByteSize() * 8)) {
 893       return m_scalar.ClearBit(bit);
 894     }
 895     break;
 896
 897   case eTypeFloat:
 898   case eTypeDouble:
 899   case eTypeLongDouble:
 900     break;
 901
 902   case eTypeBytes:
 903     if (buffer.byte_order == eByteOrderBig ||
 904         buffer.byte_order == eByteOrderLittle) {
 905       uint32_t byte_idx;
 906       if (buffer.byte_order == eByteOrderBig)
 907         byte_idx = buffer.length - (bit / 8) - 1;
 908       else
 909         byte_idx = bit / 8;
 910
 911       const uint32_t byte_bit = bit % 8;
 912       if (byte_idx < buffer.length) {
 913         buffer.bytes[byte_idx] &= ~(1u << byte_bit);
 914         return true;
 915       }
 916     }
 917     break;
 918   }
 919   return false;
 920 }
 921
 922 bool RegisterValue::SetBit(uint32_t bit) {
 923   switch (m_type) {
 924   case eTypeInvalid:
 925     break;
 926
 927   case eTypeUInt8:
 928   case eTypeUInt16:
 929   case eTypeUInt32:
 930   case eTypeUInt64:
 931   case eTypeUInt128:
 932     if (bit < (GetByteSize() * 8)) {
 933       return m_scalar.SetBit(bit);
 934     }
 935     break;
 936
 937   case eTypeFloat:
 938   case eTypeDouble:
 939   case eTypeLongDouble:
 940     break;
 941
 942   case eTypeBytes:
 943     if (buffer.byte_order == eByteOrderBig ||
 944         buffer.byte_order == eByteOrderLittle) {
 945       uint32_t byte_idx;
 946       if (buffer.byte_order == eByteOrderBig)
 947         byte_idx = buffer.length - (bit / 8) - 1;
 948       else
 949         byte_idx = bit / 8;
 950
 951       const uint32_t byte_bit = bit % 8;
 952       if (byte_idx < buffer.length) {
 953         buffer.bytes[byte_idx] |= (1u << byte_bit);
 954         return true;
 955       }
 956     }
 957     break;
 958   }
 959   return false;
 960 }