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
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26
  27 bool
  28 RegisterValue::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
 101 bool
 102 RegisterValue::GetData (DataExtractor &data) const
 103 {
 104     return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
 105 }
 106
 107
 108 uint32_t
 109 RegisterValue::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
 158 uint32_t
 159 RegisterValue::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
 234 bool
 235 RegisterValue::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
 265 void
 266 RegisterValue::Clear()
 267 {
 268     m_type = eTypeInvalid;
 269 }
 270
 271 RegisterValue::Type
 272 RegisterValue::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
 313 Error
 314 RegisterValue::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>
 394 static 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 }
 401 static inline void LStrip(llvm::StringRef &Str, char c)
 402 {
 403     if (!Str.empty() && Str.front() == c)
 404         Str = Str.substr(1);
 405 }
 406 static 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()
 412 static bool
 413 ParseVectorEncoding(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 }
 444 Error
 445 RegisterValue::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
 550 bool
 551 RegisterValue::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
 643 bool
 644 RegisterValue::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
 671 uint16_t
 672 RegisterValue::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
 698 uint32_t
 699 RegisterValue::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
 738 uint64_t
 739 RegisterValue::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
 782 RegisterValue::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
 826 float
 827 RegisterValue::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
 863 double
 864 RegisterValue::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
 901 long double
 902 RegisterValue::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
 936 const void *
 937 RegisterValue::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
 957 void *
 958 RegisterValue::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
 978 uint32_t
 979 RegisterValue::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
1000 bool
1001 RegisterValue::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
1034 void
1035 RegisterValue::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
1057 bool
1058 RegisterValue::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
1091 bool
1092 RegisterValue::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
1126 bool
1127 RegisterValue::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
1200 bool
1201 RegisterValue::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