contrib/llvm/tools/lldb/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 // 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
  29 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
 103 RegisterValue::GetData (DataExtractor &data) const
 104 {
 105     return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
 106 }
 107
 108
 109 uint32_t
 110 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
 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
 236 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
 267 RegisterValue::Clear()
 268 {
 269     m_type = eTypeInvalid;
 270 }
 271
 272 RegisterValue::Type
 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
 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>
 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 }
 402 static inline void LStrip(llvm::StringRef &Str, char c)
 403 {
 404     if (!Str.empty() && Str.front() == c)
 405         Str = Str.substr(1);
 406 }
 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
 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
 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
 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
 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
 673 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
 700 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
 740 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
 783 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
 828 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
 865 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
 903 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 *
 938 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 *
 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
 980 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
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
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
1059 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
1093 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
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
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