contrib/llvm/tools/lldb/source/Core/Scalar.cpp

   1 //===-- Scalar.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/Scalar.h"
  11
  12 #include "lldb/Utility/DataExtractor.h"
  13 #include "lldb/Utility/Endian.h"
  14 #include "lldb/Utility/Status.h"
  15 #include "lldb/Utility/Stream.h"
  16 #include "lldb/lldb-types.h" // for offset_t
  17
  18 #include "llvm/ADT/SmallString.h"
  19
  20 #include <cinttypes>
  21 #include <cstdio>
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 //----------------------------------------------------------------------
  27 // Promote to max type currently follows the ANSI C rule for type promotion in
  28 // expressions.
  29 //----------------------------------------------------------------------
  30 static Scalar::Type PromoteToMaxType(
  31     const Scalar &lhs,  // The const left hand side object
  32     const Scalar &rhs,  // The const right hand side object
  33     Scalar &temp_value, // A modifiable temp value than can be used to hold
  34                         // either the promoted lhs or rhs object
  35     const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
  36                                      // promoted value of lhs (at most one of
  37                                      // lhs/rhs will get promoted)
  38     const Scalar *&promoted_rhs_ptr  // Pointer to the resulting possibly
  39                                      // promoted value of rhs (at most one of
  40                                      // lhs/rhs will get promoted)
  41     ) {
  42   Scalar result;
  43   // Initialize the promoted values for both the right and left hand side
  44   // values to be the objects themselves. If no promotion is needed (both right
  45   // and left have the same type), then the temp_value will not get used.
  46   promoted_lhs_ptr = &lhs;
  47   promoted_rhs_ptr = &rhs;
  48   // Extract the types of both the right and left hand side values
  49   Scalar::Type lhs_type = lhs.GetType();
  50   Scalar::Type rhs_type = rhs.GetType();
  51
  52   if (lhs_type > rhs_type) {
  53     // Right hand side need to be promoted
  54     temp_value = rhs; // Copy right hand side into the temp value
  55     if (temp_value.Promote(lhs_type)) // Promote it
  56       promoted_rhs_ptr =
  57           &temp_value; // Update the pointer for the promoted right hand side
  58   } else if (lhs_type < rhs_type) {
  59     // Left hand side need to be promoted
  60     temp_value = lhs; // Copy left hand side value into the temp value
  61     if (temp_value.Promote(rhs_type)) // Promote it
  62       promoted_lhs_ptr =
  63           &temp_value; // Update the pointer for the promoted left hand side
  64   }
  65
  66   // Make sure our type promotion worked as expected
  67   if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
  68     return promoted_lhs_ptr->GetType(); // Return the resulting max type
  69
  70   // Return the void type (zero) if we fail to promote either of the values.
  71   return Scalar::e_void;
  72 }
  73
  74 Scalar::Scalar() : m_type(e_void), m_float((float)0) {}
  75
  76 Scalar::Scalar(const Scalar &rhs)
  77     : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
  78
  79 // Scalar::Scalar(const RegisterValue& reg) :
  80 //  m_type(e_void),
  81 //  m_data()
  82 //{
  83 //  switch (reg.info.encoding)
  84 //  {
  85 //  case eEncodingUint:     // unsigned integer
  86 //      switch (reg.info.byte_size)
  87 //      {
  88 //      case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
  89 //      case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
  90 //      case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
  91 //      case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64;
  92 //      break;
  93 //      break;
  94 //      }
  95 //      break;
  96 //
  97 //  case eEncodingSint:     // signed integer
  98 //      switch (reg.info.byte_size)
  99 //      {
 100 //      case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
 101 //      case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
 102 //      case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
 103 //      case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64;
 104 //      break;
 105 //      break;
 106 //      }
 107 //      break;
 108 //
 109 //  case eEncodingIEEE754:  // float
 110 //      switch (reg.info.byte_size)
 111 //      {
 112 //      case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
 113 //      case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
 114 //      break;
 115 //      }
 116 //      break;
 117 //    case eEncodingVector: // vector registers
 118 //      break;
 119 //  }
 120 //}
 121
 122 bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
 123   size_t byte_size = GetByteSize();
 124   if (byte_size > 0) {
 125     const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
 126
 127     if (limit_byte_size < byte_size) {
 128       if (endian::InlHostByteOrder() == eByteOrderLittle) {
 129         // On little endian systems if we want fewer bytes from the current
 130         // type we just specify fewer bytes since the LSByte is first...
 131         byte_size = limit_byte_size;
 132       } else if (endian::InlHostByteOrder() == eByteOrderBig) {
 133         // On big endian systems if we want fewer bytes from the current type
 134         // have to advance our initial byte pointer and trim down the number of
 135         // bytes since the MSByte is first
 136         bytes += byte_size - limit_byte_size;
 137         byte_size = limit_byte_size;
 138       }
 139     }
 140
 141     data.SetData(bytes, byte_size, endian::InlHostByteOrder());
 142     return true;
 143   }
 144   data.Clear();
 145   return false;
 146 }
 147
 148 const void *Scalar::GetBytes() const {
 149   const uint64_t *apint_words;
 150   const uint8_t *bytes;
 151   static float_t flt_val;
 152   static double_t dbl_val;
 153   static uint64_t swapped_words[4];
 154   switch (m_type) {
 155   case e_void:
 156     break;
 157   case e_sint:
 158   case e_uint:
 159   case e_slong:
 160   case e_ulong:
 161   case e_slonglong:
 162   case e_ulonglong:
 163     bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
 164     // getRawData always returns a pointer to an uint64_t.  If we have a
 165     // smaller type, we need to update the pointer on big-endian systems.
 166     if (endian::InlHostByteOrder() == eByteOrderBig) {
 167       size_t byte_size = m_integer.getBitWidth() / 8;
 168       if (byte_size < 8)
 169         bytes += 8 - byte_size;
 170     }
 171     return bytes;
 172   case e_sint128:
 173   case e_uint128:
 174     apint_words = m_integer.getRawData();
 175     // getRawData always returns a pointer to an array of two uint64_t values,
 176     // where the least-significant word always comes first.  On big-endian
 177     // systems we need to swap the two words.
 178     if (endian::InlHostByteOrder() == eByteOrderBig) {
 179       swapped_words[0] = apint_words[1];
 180       swapped_words[1] = apint_words[0];
 181       apint_words = swapped_words;
 182     }
 183     return reinterpret_cast<const void *>(apint_words);
 184   case e_sint256:
 185   case e_uint256:
 186     apint_words = m_integer.getRawData();
 187     // getRawData always returns a pointer to an array of four uint64_t values,
 188     // where the least-significant word always comes first.  On big-endian
 189     // systems we need to swap the four words.
 190     if (endian::InlHostByteOrder() == eByteOrderBig) {
 191       swapped_words[0] = apint_words[3];
 192       swapped_words[1] = apint_words[2];
 193       swapped_words[2] = apint_words[1];
 194       swapped_words[3] = apint_words[0];
 195       apint_words = swapped_words;
 196     }
 197     return reinterpret_cast<const void *>(apint_words);
 198   case e_float:
 199     flt_val = m_float.convertToFloat();
 200     return reinterpret_cast<const void *>(&flt_val);
 201   case e_double:
 202     dbl_val = m_float.convertToDouble();
 203     return reinterpret_cast<const void *>(&dbl_val);
 204   case e_long_double:
 205     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
 206     apint_words = ldbl_val.getRawData();
 207     // getRawData always returns a pointer to an array of two uint64_t values,
 208     // where the least-significant word always comes first.  On big-endian
 209     // systems we need to swap the two words.
 210     if (endian::InlHostByteOrder() == eByteOrderBig) {
 211       swapped_words[0] = apint_words[1];
 212       swapped_words[1] = apint_words[0];
 213       apint_words = swapped_words;
 214     }
 215     return reinterpret_cast<const void *>(apint_words);
 216   }
 217   return nullptr;
 218 }
 219
 220 size_t Scalar::GetByteSize() const {
 221   switch (m_type) {
 222   case e_void:
 223     break;
 224   case e_sint:
 225   case e_uint:
 226   case e_slong:
 227   case e_ulong:
 228   case e_slonglong:
 229   case e_ulonglong:
 230   case e_sint128:
 231   case e_uint128:
 232   case e_sint256:
 233   case e_uint256:
 234     return (m_integer.getBitWidth() / 8);
 235   case e_float:
 236     return sizeof(float_t);
 237   case e_double:
 238     return sizeof(double_t);
 239   case e_long_double:
 240     return sizeof(long_double_t);
 241   }
 242   return 0;
 243 }
 244
 245 bool Scalar::IsZero() const {
 246   llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
 247   switch (m_type) {
 248   case e_void:
 249     break;
 250   case e_sint:
 251   case e_uint:
 252   case e_slong:
 253   case e_ulong:
 254   case e_slonglong:
 255   case e_ulonglong:
 256   case e_sint128:
 257   case e_uint128:
 258   case e_sint256:
 259   case e_uint256:
 260     return llvm::APInt::isSameValue(zero_int, m_integer);
 261   case e_float:
 262   case e_double:
 263   case e_long_double:
 264     return m_float.isZero();
 265   }
 266   return false;
 267 }
 268
 269 void Scalar::GetValue(Stream *s, bool show_type) const {
 270   if (show_type)
 271     s->Printf("(%s) ", GetTypeAsCString());
 272
 273   switch (m_type) {
 274   case e_void:
 275     break;
 276   case e_sint:
 277   case e_slong:
 278   case e_slonglong:
 279   case e_sint128:
 280   case e_sint256:
 281     s->PutCString(m_integer.toString(10, true));
 282     break;
 283   case e_uint:
 284   case e_ulong:
 285   case e_ulonglong:
 286   case e_uint128:
 287   case e_uint256:
 288     s->PutCString(m_integer.toString(10, false));
 289     break;
 290   case e_float:
 291   case e_double:
 292   case e_long_double:
 293     llvm::SmallString<24> string;
 294     m_float.toString(string);
 295     s->Printf("%s", string.c_str());
 296     break;
 297   }
 298 }
 299
 300 const char *Scalar::GetTypeAsCString() const {
 301   switch (m_type) {
 302   case e_void:
 303     return "void";
 304   case e_sint:
 305     return "int";
 306   case e_uint:
 307     return "unsigned int";
 308   case e_slong:
 309     return "long";
 310   case e_ulong:
 311     return "unsigned long";
 312   case e_slonglong:
 313     return "long long";
 314   case e_ulonglong:
 315     return "unsigned long long";
 316   case e_sint128:
 317     return "int128_t";
 318   case e_uint128:
 319     return "unsigned int128_t";
 320   case e_sint256:
 321     return "int256_t";
 322   case e_uint256:
 323     return "unsigned int256_t";
 324   case e_float:
 325     return "float";
 326   case e_double:
 327     return "double";
 328   case e_long_double:
 329     return "long double";
 330   }
 331   return "<invalid Scalar type>";
 332 }
 333
 334 Scalar &Scalar::operator=(const Scalar &rhs) {
 335   if (this != &rhs) {
 336     m_type = rhs.m_type;
 337     m_integer = llvm::APInt(rhs.m_integer);
 338     m_float = rhs.m_float;
 339   }
 340   return *this;
 341 }
 342
 343 Scalar &Scalar::operator=(const int v) {
 344   m_type = e_sint;
 345   m_integer = llvm::APInt(sizeof(int) * 8, v, true);
 346   return *this;
 347 }
 348
 349 Scalar &Scalar::operator=(unsigned int v) {
 350   m_type = e_uint;
 351   m_integer = llvm::APInt(sizeof(int) * 8, v);
 352   return *this;
 353 }
 354
 355 Scalar &Scalar::operator=(long v) {
 356   m_type = e_slong;
 357   m_integer = llvm::APInt(sizeof(long) * 8, v, true);
 358   return *this;
 359 }
 360
 361 Scalar &Scalar::operator=(unsigned long v) {
 362   m_type = e_ulong;
 363   m_integer = llvm::APInt(sizeof(long) * 8, v);
 364   return *this;
 365 }
 366
 367 Scalar &Scalar::operator=(long long v) {
 368   m_type = e_slonglong;
 369   m_integer = llvm::APInt(sizeof(long) * 8, v, true);
 370   return *this;
 371 }
 372
 373 Scalar &Scalar::operator=(unsigned long long v) {
 374   m_type = e_ulonglong;
 375   m_integer = llvm::APInt(sizeof(long long) * 8, v);
 376   return *this;
 377 }
 378
 379 Scalar &Scalar::operator=(float v) {
 380   m_type = e_float;
 381   m_float = llvm::APFloat(v);
 382   return *this;
 383 }
 384
 385 Scalar &Scalar::operator=(double v) {
 386   m_type = e_double;
 387   m_float = llvm::APFloat(v);
 388   return *this;
 389 }
 390
 391 Scalar &Scalar::operator=(long double v) {
 392   m_type = e_long_double;
 393   if (m_ieee_quad)
 394     m_float = llvm::APFloat(
 395         llvm::APFloat::IEEEquad(),
 396         llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
 397   else
 398     m_float = llvm::APFloat(
 399         llvm::APFloat::x87DoubleExtended(),
 400         llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
 401   return *this;
 402 }
 403
 404 Scalar &Scalar::operator=(llvm::APInt rhs) {
 405   m_integer = llvm::APInt(rhs);
 406   switch (m_integer.getBitWidth()) {
 407   case 8:
 408   case 16:
 409   case 32:
 410     if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
 411       m_type = e_sint;
 412     else
 413       m_type = e_uint;
 414     break;
 415   case 64:
 416     if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
 417       m_type = e_slonglong;
 418     else
 419       m_type = e_ulonglong;
 420     break;
 421   case 128:
 422     if (m_integer.isSignedIntN(BITWIDTH_INT128))
 423       m_type = e_sint128;
 424     else
 425       m_type = e_uint128;
 426     break;
 427   case 256:
 428     if (m_integer.isSignedIntN(BITWIDTH_INT256))
 429       m_type = e_sint256;
 430     else
 431       m_type = e_uint256;
 432     break;
 433   }
 434   return *this;
 435 }
 436
 437 Scalar::~Scalar() = default;
 438
 439 bool Scalar::Promote(Scalar::Type type) {
 440   bool success = false;
 441   switch (m_type) {
 442   case e_void:
 443     break;
 444
 445   case e_sint:
 446     switch (type) {
 447     case e_void:
 448       break;
 449     case e_sint:
 450       success = true;
 451       break;
 452     case e_uint:
 453       m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
 454       success = true;
 455       break;
 456
 457     case e_slong:
 458       m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
 459       success = true;
 460       break;
 461
 462     case e_ulong:
 463       m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
 464       success = true;
 465       break;
 466
 467     case e_slonglong:
 468       m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
 469       success = true;
 470       break;
 471
 472     case e_ulonglong:
 473       m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
 474       success = true;
 475       break;
 476
 477     case e_sint128:
 478     case e_uint128:
 479       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
 480       success = true;
 481       break;
 482
 483     case e_sint256:
 484     case e_uint256:
 485       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
 486       success = true;
 487       break;
 488
 489     case e_float:
 490       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 491       m_float.convertFromAPInt(m_integer, true,
 492                                llvm::APFloat::rmNearestTiesToEven);
 493       success = true;
 494       break;
 495
 496     case e_double:
 497       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 498       m_float.convertFromAPInt(m_integer, true,
 499                                llvm::APFloat::rmNearestTiesToEven);
 500       success = true;
 501       break;
 502
 503     case e_long_double:
 504       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 505                                           : llvm::APFloat::x87DoubleExtended());
 506       m_float.convertFromAPInt(m_integer, true,
 507                                llvm::APFloat::rmNearestTiesToEven);
 508       success = true;
 509       break;
 510     }
 511     break;
 512
 513   case e_uint:
 514     switch (type) {
 515     case e_void:
 516     case e_sint:
 517       break;
 518     case e_uint:
 519       success = true;
 520       break;
 521     case e_slong:
 522       m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
 523       success = true;
 524       break;
 525
 526     case e_ulong:
 527       m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
 528       success = true;
 529       break;
 530
 531     case e_slonglong:
 532       m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
 533       success = true;
 534       break;
 535
 536     case e_ulonglong:
 537       m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
 538       success = true;
 539       break;
 540
 541     case e_sint128:
 542     case e_uint128:
 543       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
 544       success = true;
 545       break;
 546
 547     case e_sint256:
 548     case e_uint256:
 549       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
 550       success = true;
 551       break;
 552
 553     case e_float:
 554       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 555       m_float.convertFromAPInt(m_integer, false,
 556                                llvm::APFloat::rmNearestTiesToEven);
 557       success = true;
 558       break;
 559
 560     case e_double:
 561       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 562       m_float.convertFromAPInt(m_integer, false,
 563                                llvm::APFloat::rmNearestTiesToEven);
 564       success = true;
 565       break;
 566
 567     case e_long_double:
 568       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 569                                           : llvm::APFloat::x87DoubleExtended());
 570       m_float.convertFromAPInt(m_integer, false,
 571                                llvm::APFloat::rmNearestTiesToEven);
 572       success = true;
 573       break;
 574     }
 575     break;
 576
 577   case e_slong:
 578     switch (type) {
 579     case e_void:
 580     case e_sint:
 581     case e_uint:
 582       break;
 583     case e_slong:
 584       success = true;
 585       break;
 586     case e_ulong:
 587       m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
 588       success = true;
 589       break;
 590
 591     case e_slonglong:
 592       m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
 593       success = true;
 594       break;
 595
 596     case e_ulonglong:
 597       m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
 598       success = true;
 599       break;
 600
 601     case e_sint128:
 602     case e_uint128:
 603       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
 604       success = true;
 605       break;
 606
 607     case e_sint256:
 608     case e_uint256:
 609       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
 610       success = true;
 611       break;
 612
 613     case e_float:
 614       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 615       m_float.convertFromAPInt(m_integer, true,
 616                                llvm::APFloat::rmNearestTiesToEven);
 617       success = true;
 618       break;
 619
 620     case e_double:
 621       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 622       m_float.convertFromAPInt(m_integer, true,
 623                                llvm::APFloat::rmNearestTiesToEven);
 624       success = true;
 625       break;
 626
 627     case e_long_double:
 628       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 629                                           : llvm::APFloat::x87DoubleExtended());
 630       m_float.convertFromAPInt(m_integer, true,
 631                                llvm::APFloat::rmNearestTiesToEven);
 632       success = true;
 633       break;
 634     }
 635     break;
 636
 637   case e_ulong:
 638     switch (type) {
 639     case e_void:
 640     case e_sint:
 641     case e_uint:
 642     case e_slong:
 643       break;
 644     case e_ulong:
 645       success = true;
 646       break;
 647     case e_slonglong:
 648       m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
 649       success = true;
 650       break;
 651
 652     case e_ulonglong:
 653       m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
 654       success = true;
 655       break;
 656
 657     case e_sint128:
 658     case e_uint128:
 659       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
 660       success = true;
 661       break;
 662
 663     case e_sint256:
 664     case e_uint256:
 665       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
 666       success = true;
 667       break;
 668
 669     case e_float:
 670       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 671       m_float.convertFromAPInt(m_integer, false,
 672                                llvm::APFloat::rmNearestTiesToEven);
 673       success = true;
 674       break;
 675
 676     case e_double:
 677       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 678       m_float.convertFromAPInt(m_integer, false,
 679                                llvm::APFloat::rmNearestTiesToEven);
 680       success = true;
 681       break;
 682
 683     case e_long_double:
 684       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 685                                           : llvm::APFloat::x87DoubleExtended());
 686       m_float.convertFromAPInt(m_integer, false,
 687                                llvm::APFloat::rmNearestTiesToEven);
 688       success = true;
 689       break;
 690     }
 691     break;
 692
 693   case e_slonglong:
 694     switch (type) {
 695     case e_void:
 696     case e_sint:
 697     case e_uint:
 698     case e_slong:
 699     case e_ulong:
 700       break;
 701     case e_slonglong:
 702       success = true;
 703       break;
 704     case e_ulonglong:
 705       m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
 706       success = true;
 707       break;
 708
 709     case e_sint128:
 710     case e_uint128:
 711       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
 712       success = true;
 713       break;
 714
 715     case e_sint256:
 716     case e_uint256:
 717       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
 718       success = true;
 719       break;
 720
 721     case e_float:
 722       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 723       m_float.convertFromAPInt(m_integer, true,
 724                                llvm::APFloat::rmNearestTiesToEven);
 725       success = true;
 726       break;
 727
 728     case e_double:
 729       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 730       m_float.convertFromAPInt(m_integer, true,
 731                                llvm::APFloat::rmNearestTiesToEven);
 732       success = true;
 733       break;
 734
 735     case e_long_double:
 736       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 737                                           : llvm::APFloat::x87DoubleExtended());
 738       m_float.convertFromAPInt(m_integer, true,
 739                                llvm::APFloat::rmNearestTiesToEven);
 740       success = true;
 741       break;
 742     }
 743     break;
 744
 745   case e_ulonglong:
 746     switch (type) {
 747     case e_void:
 748     case e_sint:
 749     case e_uint:
 750     case e_slong:
 751     case e_ulong:
 752     case e_slonglong:
 753       break;
 754     case e_ulonglong:
 755       success = true;
 756       break;
 757     case e_sint128:
 758     case e_uint128:
 759       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
 760       success = true;
 761       break;
 762
 763     case e_sint256:
 764     case e_uint256:
 765       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
 766       success = true;
 767       break;
 768
 769     case e_float:
 770       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 771       m_float.convertFromAPInt(m_integer, false,
 772                                llvm::APFloat::rmNearestTiesToEven);
 773       success = true;
 774       break;
 775
 776     case e_double:
 777       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 778       m_float.convertFromAPInt(m_integer, false,
 779                                llvm::APFloat::rmNearestTiesToEven);
 780       success = true;
 781       break;
 782
 783     case e_long_double:
 784       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 785                                           : llvm::APFloat::x87DoubleExtended());
 786       m_float.convertFromAPInt(m_integer, false,
 787                                llvm::APFloat::rmNearestTiesToEven);
 788       success = true;
 789       break;
 790     }
 791     break;
 792
 793   case e_sint128:
 794     switch (type) {
 795     case e_void:
 796     case e_sint:
 797     case e_uint:
 798     case e_slong:
 799     case e_ulong:
 800     case e_slonglong:
 801     case e_ulonglong:
 802       break;
 803     case e_sint128:
 804       success = true;
 805       break;
 806     case e_uint128:
 807       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
 808       success = true;
 809       break;
 810
 811     case e_sint256:
 812     case e_uint256:
 813       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
 814       success = true;
 815       break;
 816
 817     case e_float:
 818       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 819       m_float.convertFromAPInt(m_integer, true,
 820                                llvm::APFloat::rmNearestTiesToEven);
 821       success = true;
 822       break;
 823
 824     case e_double:
 825       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 826       m_float.convertFromAPInt(m_integer, true,
 827                                llvm::APFloat::rmNearestTiesToEven);
 828       success = true;
 829       break;
 830
 831     case e_long_double:
 832       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 833                                           : llvm::APFloat::x87DoubleExtended());
 834       m_float.convertFromAPInt(m_integer, true,
 835                                llvm::APFloat::rmNearestTiesToEven);
 836       success = true;
 837       break;
 838     }
 839     break;
 840
 841   case e_uint128:
 842     switch (type) {
 843     case e_void:
 844     case e_sint:
 845     case e_uint:
 846     case e_slong:
 847     case e_ulong:
 848     case e_slonglong:
 849     case e_ulonglong:
 850     case e_sint128:
 851       break;
 852     case e_uint128:
 853       success = true;
 854       break;
 855     case e_sint256:
 856     case e_uint256:
 857       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
 858       success = true;
 859       break;
 860
 861     case e_float:
 862       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 863       m_float.convertFromAPInt(m_integer, false,
 864                                llvm::APFloat::rmNearestTiesToEven);
 865       success = true;
 866       break;
 867
 868     case e_double:
 869       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 870       m_float.convertFromAPInt(m_integer, false,
 871                                llvm::APFloat::rmNearestTiesToEven);
 872       success = true;
 873       break;
 874
 875     case e_long_double:
 876       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 877                                           : llvm::APFloat::x87DoubleExtended());
 878       m_float.convertFromAPInt(m_integer, false,
 879                                llvm::APFloat::rmNearestTiesToEven);
 880       success = true;
 881       break;
 882     }
 883     break;
 884
 885   case e_sint256:
 886     switch (type) {
 887     case e_void:
 888     case e_sint:
 889     case e_uint:
 890     case e_slong:
 891     case e_ulong:
 892     case e_slonglong:
 893     case e_ulonglong:
 894     case e_sint128:
 895     case e_uint128:
 896       break;
 897     case e_sint256:
 898       success = true;
 899       break;
 900     case e_uint256:
 901       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
 902       success = true;
 903       break;
 904
 905     case e_float:
 906       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 907       m_float.convertFromAPInt(m_integer, true,
 908                                llvm::APFloat::rmNearestTiesToEven);
 909       success = true;
 910       break;
 911
 912     case e_double:
 913       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 914       m_float.convertFromAPInt(m_integer, true,
 915                                llvm::APFloat::rmNearestTiesToEven);
 916       success = true;
 917       break;
 918
 919     case e_long_double:
 920       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 921                                           : llvm::APFloat::x87DoubleExtended());
 922       m_float.convertFromAPInt(m_integer, true,
 923                                llvm::APFloat::rmNearestTiesToEven);
 924       success = true;
 925       break;
 926     }
 927     break;
 928
 929   case e_uint256:
 930     switch (type) {
 931     case e_void:
 932     case e_sint:
 933     case e_uint:
 934     case e_slong:
 935     case e_ulong:
 936     case e_slonglong:
 937     case e_ulonglong:
 938     case e_sint128:
 939     case e_uint128:
 940     case e_sint256:
 941       break;
 942     case e_uint256:
 943       success = true;
 944       break;
 945     case e_float:
 946       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
 947       m_float.convertFromAPInt(m_integer, false,
 948                                llvm::APFloat::rmNearestTiesToEven);
 949       success = true;
 950       break;
 951
 952     case e_double:
 953       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
 954       m_float.convertFromAPInt(m_integer, false,
 955                                llvm::APFloat::rmNearestTiesToEven);
 956       success = true;
 957       break;
 958
 959     case e_long_double:
 960       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
 961                                           : llvm::APFloat::x87DoubleExtended());
 962       m_float.convertFromAPInt(m_integer, false,
 963                                llvm::APFloat::rmNearestTiesToEven);
 964       success = true;
 965       break;
 966     }
 967     break;
 968
 969   case e_float:
 970     switch (type) {
 971     case e_void:
 972     case e_sint:
 973     case e_uint:
 974     case e_slong:
 975     case e_ulong:
 976     case e_slonglong:
 977     case e_ulonglong:
 978     case e_sint128:
 979     case e_uint128:
 980     case e_sint256:
 981     case e_uint256:
 982       break;
 983     case e_float:
 984       success = true;
 985       break;
 986     case e_double:
 987       m_float = llvm::APFloat((double_t)m_float.convertToFloat());
 988       success = true;
 989       break;
 990
 991     case e_long_double: {
 992       bool ignore;
 993       m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
 994                                   : llvm::APFloat::x87DoubleExtended(),
 995                       llvm::APFloat::rmNearestTiesToEven, &ignore);
 996       success = true;
 997       break;
 998     }
 999     }
1000     break;
1001
1002   case e_double:
1003     switch (type) {
1004     case e_void:
1005     case e_sint:
1006     case e_uint:
1007     case e_slong:
1008     case e_ulong:
1009     case e_slonglong:
1010     case e_ulonglong:
1011     case e_sint128:
1012     case e_uint128:
1013     case e_sint256:
1014     case e_uint256:
1015     case e_float:
1016       break;
1017     case e_double:
1018       success = true;
1019       break;
1020     case e_long_double: {
1021       bool ignore;
1022       m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
1023                                   : llvm::APFloat::x87DoubleExtended(),
1024                       llvm::APFloat::rmNearestTiesToEven, &ignore);
1025       success = true;
1026       break;
1027     }
1028     }
1029     break;
1030
1031   case e_long_double:
1032     switch (type) {
1033     case e_void:
1034     case e_sint:
1035     case e_uint:
1036     case e_slong:
1037     case e_ulong:
1038     case e_slonglong:
1039     case e_ulonglong:
1040     case e_sint128:
1041     case e_uint128:
1042     case e_sint256:
1043     case e_uint256:
1044     case e_float:
1045     case e_double:
1046       break;
1047     case e_long_double:
1048       success = true;
1049       break;
1050     }
1051     break;
1052   }
1053
1054   if (success)
1055     m_type = type;
1056   return success;
1057 }
1058
1059 const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
1060   switch (type) {
1061   case e_void:
1062     return "void";
1063   case e_sint:
1064     return "int";
1065   case e_uint:
1066     return "unsigned int";
1067   case e_slong:
1068     return "long";
1069   case e_ulong:
1070     return "unsigned long";
1071   case e_slonglong:
1072     return "long long";
1073   case e_ulonglong:
1074     return "unsigned long long";
1075   case e_float:
1076     return "float";
1077   case e_double:
1078     return "double";
1079   case e_long_double:
1080     return "long double";
1081   case e_sint128:
1082     return "int128_t";
1083   case e_uint128:
1084     return "uint128_t";
1085   case e_sint256:
1086     return "int256_t";
1087   case e_uint256:
1088     return "uint256_t";
1089   }
1090   return "???";
1091 }
1092
1093 Scalar::Type
1094 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
1095   if (byte_size <= sizeof(sint_t))
1096     return e_sint;
1097   if (byte_size <= sizeof(slong_t))
1098     return e_slong;
1099   if (byte_size <= sizeof(slonglong_t))
1100     return e_slonglong;
1101   return e_void;
1102 }
1103
1104 Scalar::Type
1105 Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
1106   if (byte_size <= sizeof(uint_t))
1107     return e_uint;
1108   if (byte_size <= sizeof(ulong_t))
1109     return e_ulong;
1110   if (byte_size <= sizeof(ulonglong_t))
1111     return e_ulonglong;
1112   return e_void;
1113 }
1114
1115 Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
1116   if (byte_size == sizeof(float_t))
1117     return e_float;
1118   if (byte_size == sizeof(double_t))
1119     return e_double;
1120   if (byte_size == sizeof(long_double_t))
1121     return e_long_double;
1122   return e_void;
1123 }
1124
1125 bool Scalar::MakeSigned() {
1126   bool success = false;
1127
1128   switch (m_type) {
1129   case e_void:
1130     break;
1131   case e_sint:
1132     success = true;
1133     break;
1134   case e_uint:
1135     m_type = e_sint;
1136     success = true;
1137     break;
1138   case e_slong:
1139     success = true;
1140     break;
1141   case e_ulong:
1142     m_type = e_slong;
1143     success = true;
1144     break;
1145   case e_slonglong:
1146     success = true;
1147     break;
1148   case e_ulonglong:
1149     m_type = e_slonglong;
1150     success = true;
1151     break;
1152   case e_sint128:
1153     success = true;
1154     break;
1155   case e_uint128:
1156     m_type = e_sint128;
1157     success = true;
1158     break;
1159   case e_sint256:
1160     success = true;
1161     break;
1162   case e_uint256:
1163     m_type = e_sint256;
1164     success = true;
1165     break;
1166   case e_float:
1167     success = true;
1168     break;
1169   case e_double:
1170     success = true;
1171     break;
1172   case e_long_double:
1173     success = true;
1174     break;
1175   }
1176
1177   return success;
1178 }
1179
1180 bool Scalar::MakeUnsigned() {
1181   bool success = false;
1182
1183   switch (m_type) {
1184   case e_void:
1185     break;
1186   case e_sint:
1187     m_type = e_uint;
1188     success = true;
1189     break;
1190   case e_uint:
1191     success = true;
1192     break;
1193   case e_slong:
1194     m_type = e_ulong;
1195     success = true;
1196     break;
1197   case e_ulong:
1198     success = true;
1199     break;
1200   case e_slonglong:
1201     m_type = e_ulonglong;
1202     success = true;
1203     break;
1204   case e_ulonglong:
1205     success = true;
1206     break;
1207   case e_sint128:
1208     m_type = e_uint128;
1209     success = true;
1210     break;
1211   case e_uint128:
1212     success = true;
1213     break;
1214   case e_sint256:
1215     m_type = e_uint256;
1216     success = true;
1217     break;
1218   case e_uint256:
1219     success = true;
1220     break;
1221   case e_float:
1222     success = true;
1223     break;
1224   case e_double:
1225     success = true;
1226     break;
1227   case e_long_double:
1228     success = true;
1229     break;
1230   }
1231
1232   return success;
1233 }
1234
1235 signed char Scalar::SChar(char fail_value) const {
1236   switch (m_type) {
1237   case e_void:
1238     break;
1239   case e_sint:
1240   case e_uint:
1241   case e_slong:
1242   case e_ulong:
1243   case e_slonglong:
1244   case e_ulonglong:
1245   case e_sint128:
1246   case e_uint128:
1247   case e_sint256:
1248   case e_uint256:
1249     return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
1250   case e_float:
1251     return (schar_t)m_float.convertToFloat();
1252   case e_double:
1253     return (schar_t)m_float.convertToDouble();
1254   case e_long_double:
1255     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1256     return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
1257   }
1258   return fail_value;
1259 }
1260
1261 unsigned char Scalar::UChar(unsigned char fail_value) const {
1262   switch (m_type) {
1263   case e_void:
1264     break;
1265   case e_sint:
1266   case e_uint:
1267   case e_slong:
1268   case e_ulong:
1269   case e_slonglong:
1270   case e_ulonglong:
1271   case e_sint128:
1272   case e_uint128:
1273   case e_sint256:
1274   case e_uint256:
1275     return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
1276   case e_float:
1277     return (uchar_t)m_float.convertToFloat();
1278   case e_double:
1279     return (uchar_t)m_float.convertToDouble();
1280   case e_long_double:
1281     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1282     return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
1283   }
1284   return fail_value;
1285 }
1286
1287 short Scalar::SShort(short fail_value) const {
1288   switch (m_type) {
1289   case e_void:
1290     break;
1291   case e_sint:
1292   case e_uint:
1293   case e_slong:
1294   case e_ulong:
1295   case e_slonglong:
1296   case e_ulonglong:
1297   case e_sint128:
1298   case e_uint128:
1299   case e_sint256:
1300   case e_uint256:
1301     return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
1302         .getSExtValue();
1303   case e_float:
1304     return (sshort_t)m_float.convertToFloat();
1305   case e_double:
1306     return (sshort_t)m_float.convertToDouble();
1307   case e_long_double:
1308     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1309     return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
1310         .getSExtValue();
1311   }
1312   return fail_value;
1313 }
1314
1315 unsigned short Scalar::UShort(unsigned short fail_value) const {
1316   switch (m_type) {
1317   case e_void:
1318     break;
1319   case e_sint:
1320   case e_uint:
1321   case e_slong:
1322   case e_ulong:
1323   case e_slonglong:
1324   case e_ulonglong:
1325   case e_sint128:
1326   case e_uint128:
1327   case e_sint256:
1328   case e_uint256:
1329     return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
1330         .getZExtValue();
1331   case e_float:
1332     return (ushort_t)m_float.convertToFloat();
1333   case e_double:
1334     return (ushort_t)m_float.convertToDouble();
1335   case e_long_double:
1336     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1337     return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
1338         .getZExtValue();
1339   }
1340   return fail_value;
1341 }
1342
1343 int Scalar::SInt(int fail_value) const {
1344   switch (m_type) {
1345   case e_void:
1346     break;
1347   case e_sint:
1348   case e_uint:
1349   case e_slong:
1350   case e_ulong:
1351   case e_slonglong:
1352   case e_ulonglong:
1353   case e_sint128:
1354   case e_uint128:
1355   case e_sint256:
1356   case e_uint256:
1357     return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
1358   case e_float:
1359     return (sint_t)m_float.convertToFloat();
1360   case e_double:
1361     return (sint_t)m_float.convertToDouble();
1362   case e_long_double:
1363     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1364     return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
1365   }
1366   return fail_value;
1367 }
1368
1369 unsigned int Scalar::UInt(unsigned int fail_value) const {
1370   switch (m_type) {
1371   case e_void:
1372     break;
1373   case e_sint:
1374   case e_uint:
1375   case e_slong:
1376   case e_ulong:
1377   case e_slonglong:
1378   case e_ulonglong:
1379   case e_sint128:
1380   case e_uint128:
1381   case e_sint256:
1382   case e_uint256:
1383     return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
1384   case e_float:
1385     return (uint_t)m_float.convertToFloat();
1386   case e_double:
1387     return (uint_t)m_float.convertToDouble();
1388   case e_long_double:
1389     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1390     return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
1391   }
1392   return fail_value;
1393 }
1394
1395 long Scalar::SLong(long fail_value) const {
1396   switch (m_type) {
1397   case e_void:
1398     break;
1399   case e_sint:
1400   case e_uint:
1401   case e_slong:
1402   case e_ulong:
1403   case e_slonglong:
1404   case e_ulonglong:
1405   case e_sint128:
1406   case e_uint128:
1407   case e_sint256:
1408   case e_uint256:
1409     return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
1410   case e_float:
1411     return (slong_t)m_float.convertToFloat();
1412   case e_double:
1413     return (slong_t)m_float.convertToDouble();
1414   case e_long_double:
1415     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1416     return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
1417   }
1418   return fail_value;
1419 }
1420
1421 unsigned long Scalar::ULong(unsigned long fail_value) const {
1422   switch (m_type) {
1423   case e_void:
1424     break;
1425   case e_sint:
1426   case e_uint:
1427   case e_slong:
1428   case e_ulong:
1429   case e_slonglong:
1430   case e_ulonglong:
1431   case e_sint128:
1432   case e_uint128:
1433   case e_sint256:
1434   case e_uint256:
1435     return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
1436   case e_float:
1437     return (ulong_t)m_float.convertToFloat();
1438   case e_double:
1439     return (ulong_t)m_float.convertToDouble();
1440   case e_long_double:
1441     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1442     return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
1443   }
1444   return fail_value;
1445 }
1446
1447 long long Scalar::SLongLong(long long fail_value) const {
1448   switch (m_type) {
1449   case e_void:
1450     break;
1451   case e_sint:
1452   case e_uint:
1453   case e_slong:
1454   case e_ulong:
1455   case e_slonglong:
1456   case e_ulonglong:
1457   case e_sint128:
1458   case e_uint128:
1459   case e_sint256:
1460   case e_uint256:
1461     return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
1462         .getSExtValue();
1463   case e_float:
1464     return (slonglong_t)m_float.convertToFloat();
1465   case e_double:
1466     return (slonglong_t)m_float.convertToDouble();
1467   case e_long_double:
1468     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1469     return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
1470         .getSExtValue();
1471   }
1472   return fail_value;
1473 }
1474
1475 unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
1476   switch (m_type) {
1477   case e_void:
1478     break;
1479   case e_sint:
1480   case e_uint:
1481   case e_slong:
1482   case e_ulong:
1483   case e_slonglong:
1484   case e_ulonglong:
1485   case e_sint128:
1486   case e_uint128:
1487   case e_sint256:
1488   case e_uint256:
1489     return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
1490         .getZExtValue();
1491   case e_float:
1492     return (ulonglong_t)m_float.convertToFloat();
1493   case e_double:
1494     return (ulonglong_t)m_float.convertToDouble();
1495   case e_long_double:
1496     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1497     return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8))
1498         .getZExtValue();
1499   }
1500   return fail_value;
1501 }
1502
1503 llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
1504   switch (m_type) {
1505   case e_void:
1506     break;
1507   case e_sint:
1508   case e_uint:
1509   case e_slong:
1510   case e_ulong:
1511   case e_slonglong:
1512   case e_ulonglong:
1513   case e_sint128:
1514   case e_uint128:
1515   case e_sint256:
1516   case e_uint256:
1517     return m_integer;
1518   case e_float:
1519   case e_double:
1520   case e_long_double:
1521     return m_float.bitcastToAPInt();
1522   }
1523   return fail_value;
1524 }
1525
1526 llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
1527   switch (m_type) {
1528   case e_void:
1529     break;
1530   case e_sint:
1531   case e_uint:
1532   case e_slong:
1533   case e_ulong:
1534   case e_slonglong:
1535   case e_ulonglong:
1536   case e_sint128:
1537   case e_uint128:
1538   case e_sint256:
1539   case e_uint256:
1540     return m_integer;
1541   case e_float:
1542   case e_double:
1543   case e_long_double:
1544     return m_float.bitcastToAPInt();
1545   }
1546   return fail_value;
1547 }
1548
1549 llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
1550   switch (m_type) {
1551   case e_void:
1552     break;
1553   case e_sint:
1554   case e_uint:
1555   case e_slong:
1556   case e_ulong:
1557   case e_slonglong:
1558   case e_ulonglong:
1559   case e_sint128:
1560   case e_uint128:
1561   case e_sint256:
1562   case e_uint256:
1563     return m_integer;
1564   case e_float:
1565   case e_double:
1566   case e_long_double:
1567     return m_float.bitcastToAPInt();
1568   }
1569   return fail_value;
1570 }
1571
1572 llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
1573   switch (m_type) {
1574   case e_void:
1575     break;
1576   case e_sint:
1577   case e_uint:
1578   case e_slong:
1579   case e_ulong:
1580   case e_slonglong:
1581   case e_ulonglong:
1582   case e_sint128:
1583   case e_uint128:
1584   case e_sint256:
1585   case e_uint256:
1586     return m_integer;
1587   case e_float:
1588   case e_double:
1589   case e_long_double:
1590     return m_float.bitcastToAPInt();
1591   }
1592   return fail_value;
1593 }
1594
1595 float Scalar::Float(float fail_value) const {
1596   switch (m_type) {
1597   case e_void:
1598     break;
1599   case e_sint:
1600   case e_uint:
1601   case e_slong:
1602   case e_ulong:
1603   case e_slonglong:
1604   case e_ulonglong:
1605   case e_sint128:
1606   case e_uint128:
1607   case e_sint256:
1608   case e_uint256:
1609     return llvm::APIntOps::RoundAPIntToFloat(m_integer);
1610   case e_float:
1611     return m_float.convertToFloat();
1612   case e_double:
1613     return (float_t)m_float.convertToDouble();
1614   case e_long_double:
1615     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1616     return ldbl_val.bitsToFloat();
1617   }
1618   return fail_value;
1619 }
1620
1621 double Scalar::Double(double fail_value) const {
1622   switch (m_type) {
1623   case e_void:
1624     break;
1625   case e_sint:
1626   case e_uint:
1627   case e_slong:
1628   case e_ulong:
1629   case e_slonglong:
1630   case e_ulonglong:
1631   case e_sint128:
1632   case e_uint128:
1633   case e_sint256:
1634   case e_uint256:
1635     return llvm::APIntOps::RoundAPIntToDouble(m_integer);
1636   case e_float:
1637     return (double_t)m_float.convertToFloat();
1638   case e_double:
1639     return m_float.convertToDouble();
1640   case e_long_double:
1641     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1642     return ldbl_val.bitsToFloat();
1643   }
1644   return fail_value;
1645 }
1646
1647 long double Scalar::LongDouble(long double fail_value) const {
1648   switch (m_type) {
1649   case e_void:
1650     break;
1651   case e_sint:
1652   case e_uint:
1653   case e_slong:
1654   case e_ulong:
1655   case e_slonglong:
1656   case e_ulonglong:
1657   case e_sint128:
1658   case e_uint128:
1659   case e_sint256:
1660   case e_uint256:
1661     return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
1662   case e_float:
1663     return (long_double_t)m_float.convertToFloat();
1664   case e_double:
1665     return (long_double_t)m_float.convertToDouble();
1666   case e_long_double:
1667     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1668     return (long_double_t)ldbl_val.bitsToDouble();
1669   }
1670   return fail_value;
1671 }
1672
1673 Scalar &Scalar::operator+=(const Scalar &rhs) {
1674   Scalar temp_value;
1675   const Scalar *a;
1676   const Scalar *b;
1677   if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
1678       Scalar::e_void) {
1679     switch (m_type) {
1680     case e_void:
1681       break;
1682     case e_sint:
1683     case e_uint:
1684     case e_slong:
1685     case e_ulong:
1686     case e_slonglong:
1687     case e_ulonglong:
1688     case e_sint128:
1689     case e_uint128:
1690     case e_sint256:
1691     case e_uint256:
1692       m_integer = a->m_integer + b->m_integer;
1693       break;
1694
1695     case e_float:
1696     case e_double:
1697     case e_long_double:
1698       m_float = a->m_float + b->m_float;
1699       break;
1700     }
1701   }
1702   return *this;
1703 }
1704
1705 Scalar &Scalar::operator<<=(const Scalar &rhs) {
1706   switch (m_type) {
1707   case e_void:
1708   case e_float:
1709   case e_double:
1710   case e_long_double:
1711     m_type = e_void;
1712     break;
1713
1714   case e_sint:
1715   case e_uint:
1716   case e_slong:
1717   case e_ulong:
1718   case e_slonglong:
1719   case e_ulonglong:
1720   case e_sint128:
1721   case e_uint128:
1722   case e_sint256:
1723   case e_uint256:
1724     switch (rhs.m_type) {
1725     case e_void:
1726     case e_float:
1727     case e_double:
1728     case e_long_double:
1729       m_type = e_void;
1730       break;
1731     case e_sint:
1732     case e_uint:
1733     case e_slong:
1734     case e_ulong:
1735     case e_slonglong:
1736     case e_ulonglong:
1737     case e_sint128:
1738     case e_uint128:
1739     case e_sint256:
1740     case e_uint256:
1741       m_integer = m_integer << rhs.m_integer;
1742       break;
1743     }
1744     break;
1745   }
1746   return *this;
1747 }
1748
1749 bool Scalar::ShiftRightLogical(const Scalar &rhs) {
1750   switch (m_type) {
1751   case e_void:
1752   case e_float:
1753   case e_double:
1754   case e_long_double:
1755     m_type = e_void;
1756     break;
1757
1758   case e_sint:
1759   case e_uint:
1760   case e_slong:
1761   case e_ulong:
1762   case e_slonglong:
1763   case e_ulonglong:
1764   case e_sint128:
1765   case e_uint128:
1766   case e_sint256:
1767   case e_uint256:
1768     switch (rhs.m_type) {
1769     case e_void:
1770     case e_float:
1771     case e_double:
1772     case e_long_double:
1773       m_type = e_void;
1774       break;
1775     case e_sint:
1776     case e_uint:
1777     case e_slong:
1778     case e_ulong:
1779     case e_slonglong:
1780     case e_ulonglong:
1781     case e_sint128:
1782     case e_uint128:
1783     case e_sint256:
1784     case e_uint256:
1785       m_integer = m_integer.lshr(rhs.m_integer);
1786       break;
1787     }
1788     break;
1789   }
1790   return m_type != e_void;
1791 }
1792
1793 Scalar &Scalar::operator>>=(const Scalar &rhs) {
1794   switch (m_type) {
1795   case e_void:
1796   case e_float:
1797   case e_double:
1798   case e_long_double:
1799     m_type = e_void;
1800     break;
1801
1802   case e_sint:
1803   case e_uint:
1804   case e_slong:
1805   case e_ulong:
1806   case e_slonglong:
1807   case e_ulonglong:
1808   case e_sint128:
1809   case e_uint128:
1810   case e_sint256:
1811   case e_uint256:
1812     switch (rhs.m_type) {
1813     case e_void:
1814     case e_float:
1815     case e_double:
1816     case e_long_double:
1817       m_type = e_void;
1818       break;
1819     case e_sint:
1820     case e_uint:
1821     case e_slong:
1822     case e_ulong:
1823     case e_slonglong:
1824     case e_ulonglong:
1825     case e_sint128:
1826     case e_uint128:
1827     case e_sint256:
1828     case e_uint256:
1829       m_integer = m_integer.ashr(rhs.m_integer);
1830       break;
1831     }
1832     break;
1833   }
1834   return *this;
1835 }
1836
1837 Scalar &Scalar::operator&=(const Scalar &rhs) {
1838   switch (m_type) {
1839   case e_void:
1840   case e_float:
1841   case e_double:
1842   case e_long_double:
1843     m_type = e_void;
1844     break;
1845
1846   case e_sint:
1847   case e_uint:
1848   case e_slong:
1849   case e_ulong:
1850   case e_slonglong:
1851   case e_ulonglong:
1852   case e_sint128:
1853   case e_uint128:
1854   case e_sint256:
1855   case e_uint256:
1856     switch (rhs.m_type) {
1857     case e_void:
1858     case e_float:
1859     case e_double:
1860     case e_long_double:
1861       m_type = e_void;
1862       break;
1863     case e_sint:
1864     case e_uint:
1865     case e_slong:
1866     case e_ulong:
1867     case e_slonglong:
1868     case e_ulonglong:
1869     case e_sint128:
1870     case e_uint128:
1871     case e_sint256:
1872     case e_uint256:
1873       m_integer &= rhs.m_integer;
1874       break;
1875     }
1876     break;
1877   }
1878   return *this;
1879 }
1880
1881 bool Scalar::AbsoluteValue() {
1882   switch (m_type) {
1883   case e_void:
1884     break;
1885
1886   case e_sint:
1887   case e_slong:
1888   case e_slonglong:
1889   case e_sint128:
1890   case e_sint256:
1891     if (m_integer.isNegative())
1892       m_integer = -m_integer;
1893     return true;
1894
1895   case e_uint:
1896   case e_ulong:
1897   case e_ulonglong:
1898     return true;
1899   case e_uint128:
1900   case e_uint256:
1901   case e_float:
1902   case e_double:
1903   case e_long_double:
1904     m_float.clearSign();
1905     return true;
1906   }
1907   return false;
1908 }
1909
1910 bool Scalar::UnaryNegate() {
1911   switch (m_type) {
1912   case e_void:
1913     break;
1914   case e_sint:
1915   case e_uint:
1916   case e_slong:
1917   case e_ulong:
1918   case e_slonglong:
1919   case e_ulonglong:
1920   case e_sint128:
1921   case e_uint128:
1922   case e_sint256:
1923   case e_uint256:
1924     m_integer = -m_integer;
1925     return true;
1926   case e_float:
1927   case e_double:
1928   case e_long_double:
1929     m_float.changeSign();
1930     return true;
1931   }
1932   return false;
1933 }
1934
1935 bool Scalar::OnesComplement() {
1936   switch (m_type) {
1937   case e_sint:
1938   case e_uint:
1939   case e_slong:
1940   case e_ulong:
1941   case e_slonglong:
1942   case e_ulonglong:
1943   case e_sint128:
1944   case e_uint128:
1945   case e_sint256:
1946   case e_uint256:
1947     m_integer = ~m_integer;
1948     return true;
1949
1950   case e_void:
1951   case e_float:
1952   case e_double:
1953   case e_long_double:
1954     break;
1955   }
1956   return false;
1957 }
1958
1959 const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
1960   Scalar result;
1961   Scalar temp_value;
1962   const Scalar *a;
1963   const Scalar *b;
1964   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
1965       Scalar::e_void) {
1966     switch (result.m_type) {
1967     case Scalar::e_void:
1968       break;
1969     case Scalar::e_sint:
1970     case Scalar::e_uint:
1971     case Scalar::e_slong:
1972     case Scalar::e_ulong:
1973     case Scalar::e_slonglong:
1974     case Scalar::e_ulonglong:
1975     case Scalar::e_sint128:
1976     case Scalar::e_uint128:
1977     case Scalar::e_sint256:
1978     case Scalar::e_uint256:
1979       result.m_integer = a->m_integer + b->m_integer;
1980       break;
1981     case Scalar::e_float:
1982     case Scalar::e_double:
1983     case Scalar::e_long_double:
1984       result.m_float = a->m_float + b->m_float;
1985       break;
1986     }
1987   }
1988   return result;
1989 }
1990
1991 const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
1992   Scalar result;
1993   Scalar temp_value;
1994   const Scalar *a;
1995   const Scalar *b;
1996   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
1997       Scalar::e_void) {
1998     switch (result.m_type) {
1999     case Scalar::e_void:
2000       break;
2001     case Scalar::e_sint:
2002     case Scalar::e_uint:
2003     case Scalar::e_slong:
2004     case Scalar::e_ulong:
2005     case Scalar::e_slonglong:
2006     case Scalar::e_ulonglong:
2007     case Scalar::e_sint128:
2008     case Scalar::e_uint128:
2009     case Scalar::e_sint256:
2010     case Scalar::e_uint256:
2011       result.m_integer = a->m_integer - b->m_integer;
2012       break;
2013     case Scalar::e_float:
2014     case Scalar::e_double:
2015     case Scalar::e_long_double:
2016       result.m_float = a->m_float - b->m_float;
2017       break;
2018     }
2019   }
2020   return result;
2021 }
2022
2023 const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
2024   Scalar result;
2025   Scalar temp_value;
2026   const Scalar *a;
2027   const Scalar *b;
2028   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2029       Scalar::e_void) {
2030     switch (result.m_type) {
2031     case Scalar::e_void:
2032       break;
2033     case Scalar::e_sint:
2034     case Scalar::e_slong:
2035     case Scalar::e_slonglong:
2036     case Scalar::e_sint128:
2037     case Scalar::e_sint256:
2038       if (b->m_integer != 0) {
2039         result.m_integer = a->m_integer.sdiv(b->m_integer);
2040         return result;
2041       }
2042       break;
2043     case Scalar::e_uint:
2044     case Scalar::e_ulong:
2045     case Scalar::e_ulonglong:
2046     case Scalar::e_uint128:
2047     case Scalar::e_uint256:
2048       if (b->m_integer != 0) {
2049         result.m_integer = a->m_integer.udiv(b->m_integer);
2050         return result;
2051       }
2052       break;
2053     case Scalar::e_float:
2054     case Scalar::e_double:
2055     case Scalar::e_long_double:
2056       if (!b->m_float.isZero()) {
2057         result.m_float = a->m_float / b->m_float;
2058         return result;
2059       }
2060       break;
2061     }
2062   }
2063   // For division only, the only way it should make it here is if a promotion
2064   // failed, or if we are trying to do a divide by zero.
2065   result.m_type = Scalar::e_void;
2066   return result;
2067 }
2068
2069 const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
2070   Scalar result;
2071   Scalar temp_value;
2072   const Scalar *a;
2073   const Scalar *b;
2074   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2075       Scalar::e_void) {
2076     switch (result.m_type) {
2077     case Scalar::e_void:
2078       break;
2079     case Scalar::e_sint:
2080     case Scalar::e_uint:
2081     case Scalar::e_slong:
2082     case Scalar::e_ulong:
2083     case Scalar::e_slonglong:
2084     case Scalar::e_ulonglong:
2085     case Scalar::e_sint128:
2086     case Scalar::e_uint128:
2087     case Scalar::e_sint256:
2088     case Scalar::e_uint256:
2089       result.m_integer = a->m_integer * b->m_integer;
2090       break;
2091     case Scalar::e_float:
2092     case Scalar::e_double:
2093     case Scalar::e_long_double:
2094       result.m_float = a->m_float * b->m_float;
2095       break;
2096     }
2097   }
2098   return result;
2099 }
2100
2101 const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
2102   Scalar result;
2103   Scalar temp_value;
2104   const Scalar *a;
2105   const Scalar *b;
2106   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2107       Scalar::e_void) {
2108     switch (result.m_type) {
2109     case Scalar::e_sint:
2110     case Scalar::e_uint:
2111     case Scalar::e_slong:
2112     case Scalar::e_ulong:
2113     case Scalar::e_slonglong:
2114     case Scalar::e_ulonglong:
2115     case Scalar::e_sint128:
2116     case Scalar::e_uint128:
2117     case Scalar::e_sint256:
2118     case Scalar::e_uint256:
2119       result.m_integer = a->m_integer & b->m_integer;
2120       break;
2121     case Scalar::e_void:
2122     case Scalar::e_float:
2123     case Scalar::e_double:
2124     case Scalar::e_long_double:
2125       // No bitwise AND on floats, doubles of long doubles
2126       result.m_type = Scalar::e_void;
2127       break;
2128     }
2129   }
2130   return result;
2131 }
2132
2133 const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
2134   Scalar result;
2135   Scalar temp_value;
2136   const Scalar *a;
2137   const Scalar *b;
2138   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2139       Scalar::e_void) {
2140     switch (result.m_type) {
2141     case Scalar::e_sint:
2142     case Scalar::e_uint:
2143     case Scalar::e_slong:
2144     case Scalar::e_ulong:
2145     case Scalar::e_slonglong:
2146     case Scalar::e_ulonglong:
2147     case Scalar::e_sint128:
2148     case Scalar::e_uint128:
2149     case Scalar::e_sint256:
2150     case Scalar::e_uint256:
2151       result.m_integer = a->m_integer | b->m_integer;
2152       break;
2153
2154     case Scalar::e_void:
2155     case Scalar::e_float:
2156     case Scalar::e_double:
2157     case Scalar::e_long_double:
2158       // No bitwise AND on floats, doubles of long doubles
2159       result.m_type = Scalar::e_void;
2160       break;
2161     }
2162   }
2163   return result;
2164 }
2165
2166 const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
2167   Scalar result;
2168   Scalar temp_value;
2169   const Scalar *a;
2170   const Scalar *b;
2171   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2172       Scalar::e_void) {
2173     switch (result.m_type) {
2174     default:
2175       break;
2176     case Scalar::e_void:
2177       break;
2178     case Scalar::e_sint:
2179     case Scalar::e_slong:
2180     case Scalar::e_slonglong:
2181     case Scalar::e_sint128:
2182     case Scalar::e_sint256:
2183       if (b->m_integer != 0) {
2184         result.m_integer = a->m_integer.srem(b->m_integer);
2185         return result;
2186       }
2187       break;
2188     case Scalar::e_uint:
2189     case Scalar::e_ulong:
2190     case Scalar::e_ulonglong:
2191     case Scalar::e_uint128:
2192     case Scalar::e_uint256:
2193       if (b->m_integer != 0) {
2194         result.m_integer = a->m_integer.urem(b->m_integer);
2195         return result;
2196       }
2197       break;
2198     }
2199   }
2200   result.m_type = Scalar::e_void;
2201   return result;
2202 }
2203
2204 const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
2205   Scalar result;
2206   Scalar temp_value;
2207   const Scalar *a;
2208   const Scalar *b;
2209   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2210       Scalar::e_void) {
2211     switch (result.m_type) {
2212     case Scalar::e_sint:
2213     case Scalar::e_uint:
2214     case Scalar::e_slong:
2215     case Scalar::e_ulong:
2216     case Scalar::e_slonglong:
2217     case Scalar::e_ulonglong:
2218     case Scalar::e_sint128:
2219     case Scalar::e_uint128:
2220     case Scalar::e_sint256:
2221     case Scalar::e_uint256:
2222       result.m_integer = a->m_integer ^ b->m_integer;
2223       break;
2224
2225     case Scalar::e_void:
2226     case Scalar::e_float:
2227     case Scalar::e_double:
2228     case Scalar::e_long_double:
2229       // No bitwise AND on floats, doubles of long doubles
2230       result.m_type = Scalar::e_void;
2231       break;
2232     }
2233   }
2234   return result;
2235 }
2236
2237 const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
2238   Scalar result = lhs;
2239   result <<= rhs;
2240   return result;
2241 }
2242
2243 const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
2244   Scalar result = lhs;
2245   result >>= rhs;
2246   return result;
2247 }
2248
2249 Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
2250                                    size_t byte_size) {
2251   Status error;
2252   if (value_str == nullptr || value_str[0] == '\0') {
2253     error.SetErrorString("Invalid c-string value string.");
2254     return error;
2255   }
2256   switch (encoding) {
2257   case eEncodingInvalid:
2258     error.SetErrorString("Invalid encoding.");
2259     break;
2260
2261   case eEncodingUint:
2262     if (byte_size <= sizeof(uint64_t)) {
2263       uint64_t uval64;
2264       if (!llvm::to_integer(value_str, uval64))
2265         error.SetErrorStringWithFormat(
2266             "'%s' is not a valid unsigned integer string value", value_str);
2267       else if (!UIntValueIsValidForSize(uval64, byte_size))
2268         error.SetErrorStringWithFormat("value 0x%" PRIx64
2269                                        " is too large to fit in a %" PRIu64
2270                                        " byte unsigned integer value",
2271                                        uval64, (uint64_t)byte_size);
2272       else {
2273         m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
2274         switch (m_type) {
2275         case e_uint:
2276           m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
2277           break;
2278         case e_ulong:
2279           m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
2280           break;
2281         case e_ulonglong:
2282           m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
2283           break;
2284         default:
2285           error.SetErrorStringWithFormat(
2286               "unsupported unsigned integer byte size: %" PRIu64 "",
2287               (uint64_t)byte_size);
2288           break;
2289         }
2290       }
2291     } else {
2292       error.SetErrorStringWithFormat(
2293           "unsupported unsigned integer byte size: %" PRIu64 "",
2294           (uint64_t)byte_size);
2295       return error;
2296     }
2297     break;
2298
2299   case eEncodingSint:
2300     if (byte_size <= sizeof(int64_t)) {
2301       int64_t sval64;
2302       if (!llvm::to_integer(value_str, sval64))
2303         error.SetErrorStringWithFormat(
2304             "'%s' is not a valid signed integer string value", value_str);
2305       else if (!SIntValueIsValidForSize(sval64, byte_size))
2306         error.SetErrorStringWithFormat("value 0x%" PRIx64
2307                                        " is too large to fit in a %" PRIu64
2308                                        " byte signed integer value",
2309                                        sval64, (uint64_t)byte_size);
2310       else {
2311         m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
2312         switch (m_type) {
2313         case e_sint:
2314           m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
2315           break;
2316         case e_slong:
2317           m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
2318           break;
2319         case e_slonglong:
2320           m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
2321           break;
2322         default:
2323           error.SetErrorStringWithFormat(
2324               "unsupported signed integer byte size: %" PRIu64 "",
2325               (uint64_t)byte_size);
2326           break;
2327         }
2328       }
2329     } else {
2330       error.SetErrorStringWithFormat(
2331           "unsupported signed integer byte size: %" PRIu64 "",
2332           (uint64_t)byte_size);
2333       return error;
2334     }
2335     break;
2336
2337   case eEncodingIEEE754:
2338     static float f_val;
2339     static double d_val;
2340     static long double l_val;
2341     if (byte_size == sizeof(float)) {
2342       if (::sscanf(value_str, "%f", &f_val) == 1) {
2343         m_float = llvm::APFloat(f_val);
2344         m_type = e_float;
2345       } else
2346         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2347                                        value_str);
2348     } else if (byte_size == sizeof(double)) {
2349       if (::sscanf(value_str, "%lf", &d_val) == 1) {
2350         m_float = llvm::APFloat(d_val);
2351         m_type = e_double;
2352       } else
2353         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2354                                        value_str);
2355     } else if (byte_size == sizeof(long double)) {
2356       if (::sscanf(value_str, "%Lf", &l_val) == 1) {
2357         m_float =
2358             llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
2359                           llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
2360                                       ((type128 *)&l_val)->x));
2361         m_type = e_long_double;
2362       } else
2363         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2364                                        value_str);
2365     } else {
2366       error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
2367                                      (uint64_t)byte_size);
2368       return error;
2369     }
2370     break;
2371
2372   case eEncodingVector:
2373     error.SetErrorString("vector encoding unsupported.");
2374     break;
2375   }
2376   if (error.Fail())
2377     m_type = e_void;
2378
2379   return error;
2380 }
2381
2382 Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
2383                                 size_t byte_size) {
2384   Status error;
2385
2386   type128 int128;
2387   type256 int256;
2388   switch (encoding) {
2389   case lldb::eEncodingInvalid:
2390     error.SetErrorString("invalid encoding");
2391     break;
2392   case lldb::eEncodingVector:
2393     error.SetErrorString("vector encoding unsupported");
2394     break;
2395   case lldb::eEncodingUint: {
2396     lldb::offset_t offset = 0;
2397
2398     switch (byte_size) {
2399     case 1:
2400       operator=((uint8_t)data.GetU8(&offset));
2401       break;
2402     case 2:
2403       operator=((uint16_t)data.GetU16(&offset));
2404       break;
2405     case 4:
2406       operator=((uint32_t)data.GetU32(&offset));
2407       break;
2408     case 8:
2409       operator=((uint64_t)data.GetU64(&offset));
2410       break;
2411     case 16:
2412       if (data.GetByteOrder() == eByteOrderBig) {
2413         int128.x[1] = (uint64_t)data.GetU64(&offset);
2414         int128.x[0] = (uint64_t)data.GetU64(&offset);
2415       } else {
2416         int128.x[0] = (uint64_t)data.GetU64(&offset);
2417         int128.x[1] = (uint64_t)data.GetU64(&offset);
2418       }
2419       operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2420       break;
2421     case 32:
2422       if (data.GetByteOrder() == eByteOrderBig) {
2423         int256.x[3] = (uint64_t)data.GetU64(&offset);
2424         int256.x[2] = (uint64_t)data.GetU64(&offset);
2425         int256.x[1] = (uint64_t)data.GetU64(&offset);
2426         int256.x[0] = (uint64_t)data.GetU64(&offset);
2427       } else {
2428         int256.x[0] = (uint64_t)data.GetU64(&offset);
2429         int256.x[1] = (uint64_t)data.GetU64(&offset);
2430         int256.x[2] = (uint64_t)data.GetU64(&offset);
2431         int256.x[3] = (uint64_t)data.GetU64(&offset);
2432       }
2433       operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2434       break;
2435     default:
2436       error.SetErrorStringWithFormat(
2437           "unsupported unsigned integer byte size: %" PRIu64 "",
2438           (uint64_t)byte_size);
2439       break;
2440     }
2441   } break;
2442   case lldb::eEncodingSint: {
2443     lldb::offset_t offset = 0;
2444
2445     switch (byte_size) {
2446     case 1:
2447       operator=((int8_t)data.GetU8(&offset));
2448       break;
2449     case 2:
2450       operator=((int16_t)data.GetU16(&offset));
2451       break;
2452     case 4:
2453       operator=((int32_t)data.GetU32(&offset));
2454       break;
2455     case 8:
2456       operator=((int64_t)data.GetU64(&offset));
2457       break;
2458     case 16:
2459       if (data.GetByteOrder() == eByteOrderBig) {
2460         int128.x[1] = (uint64_t)data.GetU64(&offset);
2461         int128.x[0] = (uint64_t)data.GetU64(&offset);
2462       } else {
2463         int128.x[0] = (uint64_t)data.GetU64(&offset);
2464         int128.x[1] = (uint64_t)data.GetU64(&offset);
2465       }
2466       operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2467       break;
2468     case 32:
2469       if (data.GetByteOrder() == eByteOrderBig) {
2470         int256.x[3] = (uint64_t)data.GetU64(&offset);
2471         int256.x[2] = (uint64_t)data.GetU64(&offset);
2472         int256.x[1] = (uint64_t)data.GetU64(&offset);
2473         int256.x[0] = (uint64_t)data.GetU64(&offset);
2474       } else {
2475         int256.x[0] = (uint64_t)data.GetU64(&offset);
2476         int256.x[1] = (uint64_t)data.GetU64(&offset);
2477         int256.x[2] = (uint64_t)data.GetU64(&offset);
2478         int256.x[3] = (uint64_t)data.GetU64(&offset);
2479       }
2480       operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2481       break;
2482     default:
2483       error.SetErrorStringWithFormat(
2484           "unsupported signed integer byte size: %" PRIu64 "",
2485           (uint64_t)byte_size);
2486       break;
2487     }
2488   } break;
2489   case lldb::eEncodingIEEE754: {
2490     lldb::offset_t offset = 0;
2491
2492     if (byte_size == sizeof(float))
2493       operator=((float)data.GetFloat(&offset));
2494     else if (byte_size == sizeof(double))
2495       operator=((double)data.GetDouble(&offset));
2496     else if (byte_size == sizeof(long double))
2497       operator=((long double)data.GetLongDouble(&offset));
2498     else
2499       error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
2500                                      (uint64_t)byte_size);
2501   } break;
2502   }
2503
2504   return error;
2505 }
2506
2507 bool Scalar::SignExtend(uint32_t sign_bit_pos) {
2508   const uint32_t max_bit_pos = GetByteSize() * 8;
2509
2510   if (sign_bit_pos < max_bit_pos) {
2511     switch (m_type) {
2512     case Scalar::e_void:
2513     case Scalar::e_float:
2514     case Scalar::e_double:
2515     case Scalar::e_long_double:
2516       return false;
2517
2518     case Scalar::e_sint:
2519     case Scalar::e_uint:
2520     case Scalar::e_slong:
2521     case Scalar::e_ulong:
2522     case Scalar::e_slonglong:
2523     case Scalar::e_ulonglong:
2524     case Scalar::e_sint128:
2525     case Scalar::e_uint128:
2526     case Scalar::e_sint256:
2527     case Scalar::e_uint256:
2528       if (max_bit_pos == sign_bit_pos)
2529         return true;
2530       else if (sign_bit_pos < (max_bit_pos - 1)) {
2531         llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
2532         llvm::APInt bitwize_and = m_integer & sign_bit;
2533         if (bitwize_and.getBoolValue()) {
2534           const llvm::APInt mask =
2535               ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
2536           m_integer |= mask;
2537         }
2538         return true;
2539       }
2540       break;
2541     }
2542   }
2543   return false;
2544 }
2545
2546 size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
2547                                lldb::ByteOrder dst_byte_order,
2548                                Status &error) const {
2549   // Get a data extractor that points to the native scalar data
2550   DataExtractor data;
2551   if (!GetData(data)) {
2552     error.SetErrorString("invalid scalar value");
2553     return 0;
2554   }
2555
2556   const size_t src_len = data.GetByteSize();
2557
2558   // Prepare a memory buffer that contains some or all of the register value
2559   const size_t bytes_copied =
2560       data.CopyByteOrderedData(0,               // src offset
2561                                src_len,         // src length
2562                                dst,             // dst buffer
2563                                dst_len,         // dst length
2564                                dst_byte_order); // dst byte order
2565   if (bytes_copied == 0)
2566     error.SetErrorString("failed to copy data");
2567
2568   return bytes_copied;
2569 }
2570
2571 bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
2572   if (bit_size == 0)
2573     return true;
2574
2575   switch (m_type) {
2576   case Scalar::e_void:
2577   case Scalar::e_float:
2578   case Scalar::e_double:
2579   case Scalar::e_long_double:
2580     break;
2581
2582   case Scalar::e_sint:
2583   case Scalar::e_slong:
2584   case Scalar::e_slonglong:
2585   case Scalar::e_sint128:
2586   case Scalar::e_sint256:
2587     m_integer = m_integer.ashr(bit_offset)
2588                     .sextOrTrunc(bit_size)
2589                     .sextOrSelf(8 * GetByteSize());
2590     return true;
2591
2592   case Scalar::e_uint:
2593   case Scalar::e_ulong:
2594   case Scalar::e_ulonglong:
2595   case Scalar::e_uint128:
2596   case Scalar::e_uint256:
2597     m_integer = m_integer.lshr(bit_offset)
2598                     .zextOrTrunc(bit_size)
2599                     .zextOrSelf(8 * GetByteSize());
2600     return true;
2601   }
2602   return false;
2603 }
2604
2605 bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
2606   // If either entry is void then we can just compare the types
2607   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2608     return lhs.m_type == rhs.m_type;
2609
2610   Scalar temp_value;
2611   const Scalar *a;
2612   const Scalar *b;
2613   llvm::APFloat::cmpResult result;
2614   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2615   case Scalar::e_void:
2616     break;
2617   case Scalar::e_sint:
2618   case Scalar::e_uint:
2619   case Scalar::e_slong:
2620   case Scalar::e_ulong:
2621   case Scalar::e_slonglong:
2622   case Scalar::e_ulonglong:
2623   case Scalar::e_sint128:
2624   case Scalar::e_uint128:
2625   case Scalar::e_sint256:
2626   case Scalar::e_uint256:
2627     return a->m_integer == b->m_integer;
2628   case Scalar::e_float:
2629   case Scalar::e_double:
2630   case Scalar::e_long_double:
2631     result = a->m_float.compare(b->m_float);
2632     if (result == llvm::APFloat::cmpEqual)
2633       return true;
2634   }
2635   return false;
2636 }
2637
2638 bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
2639   // If either entry is void then we can just compare the types
2640   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2641     return lhs.m_type != rhs.m_type;
2642
2643   Scalar
2644       temp_value; // A temp value that might get a copy of either promoted value
2645   const Scalar *a;
2646   const Scalar *b;
2647   llvm::APFloat::cmpResult result;
2648   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2649   case Scalar::e_void:
2650     break;
2651   case Scalar::e_sint:
2652   case Scalar::e_uint:
2653   case Scalar::e_slong:
2654   case Scalar::e_ulong:
2655   case Scalar::e_slonglong:
2656   case Scalar::e_ulonglong:
2657   case Scalar::e_sint128:
2658   case Scalar::e_uint128:
2659   case Scalar::e_sint256:
2660   case Scalar::e_uint256:
2661     return a->m_integer != b->m_integer;
2662   case Scalar::e_float:
2663   case Scalar::e_double:
2664   case Scalar::e_long_double:
2665     result = a->m_float.compare(b->m_float);
2666     if (result != llvm::APFloat::cmpEqual)
2667       return true;
2668   }
2669   return true;
2670 }
2671
2672 bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
2673   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2674     return false;
2675
2676   Scalar temp_value;
2677   const Scalar *a;
2678   const Scalar *b;
2679   llvm::APFloat::cmpResult result;
2680   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2681   case Scalar::e_void:
2682     break;
2683   case Scalar::e_sint:
2684   case Scalar::e_slong:
2685   case Scalar::e_slonglong:
2686   case Scalar::e_sint128:
2687   case Scalar::e_sint256:
2688     return a->m_integer.slt(b->m_integer);
2689   case Scalar::e_uint:
2690   case Scalar::e_ulong:
2691   case Scalar::e_ulonglong:
2692   case Scalar::e_uint128:
2693   case Scalar::e_uint256:
2694     return a->m_integer.ult(b->m_integer);
2695   case Scalar::e_float:
2696   case Scalar::e_double:
2697   case Scalar::e_long_double:
2698     result = a->m_float.compare(b->m_float);
2699     if (result == llvm::APFloat::cmpLessThan)
2700       return true;
2701   }
2702   return false;
2703 }
2704
2705 bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
2706   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2707     return false;
2708
2709   Scalar temp_value;
2710   const Scalar *a;
2711   const Scalar *b;
2712   llvm::APFloat::cmpResult result;
2713   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2714   case Scalar::e_void:
2715     break;
2716   case Scalar::e_sint:
2717   case Scalar::e_slong:
2718   case Scalar::e_slonglong:
2719   case Scalar::e_sint128:
2720   case Scalar::e_sint256:
2721     return a->m_integer.sle(b->m_integer);
2722   case Scalar::e_uint:
2723   case Scalar::e_ulong:
2724   case Scalar::e_ulonglong:
2725   case Scalar::e_uint128:
2726   case Scalar::e_uint256:
2727     return a->m_integer.ule(b->m_integer);
2728   case Scalar::e_float:
2729   case Scalar::e_double:
2730   case Scalar::e_long_double:
2731     result = a->m_float.compare(b->m_float);
2732     if (result == llvm::APFloat::cmpLessThan ||
2733         result == llvm::APFloat::cmpEqual)
2734       return true;
2735   }
2736   return false;
2737 }
2738
2739 bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
2740   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2741     return false;
2742
2743   Scalar temp_value;
2744   const Scalar *a;
2745   const Scalar *b;
2746   llvm::APFloat::cmpResult result;
2747   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2748   case Scalar::e_void:
2749     break;
2750   case Scalar::e_sint:
2751   case Scalar::e_slong:
2752   case Scalar::e_slonglong:
2753   case Scalar::e_sint128:
2754   case Scalar::e_sint256:
2755     return a->m_integer.sgt(b->m_integer);
2756   case Scalar::e_uint:
2757   case Scalar::e_ulong:
2758   case Scalar::e_ulonglong:
2759   case Scalar::e_uint128:
2760   case Scalar::e_uint256:
2761     return a->m_integer.ugt(b->m_integer);
2762   case Scalar::e_float:
2763   case Scalar::e_double:
2764   case Scalar::e_long_double:
2765     result = a->m_float.compare(b->m_float);
2766     if (result == llvm::APFloat::cmpGreaterThan)
2767       return true;
2768   }
2769   return false;
2770 }
2771
2772 bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
2773   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2774     return false;
2775
2776   Scalar temp_value;
2777   const Scalar *a;
2778   const Scalar *b;
2779   llvm::APFloat::cmpResult result;
2780   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2781   case Scalar::e_void:
2782     break;
2783   case Scalar::e_sint:
2784   case Scalar::e_slong:
2785   case Scalar::e_slonglong:
2786   case Scalar::e_sint128:
2787   case Scalar::e_sint256:
2788     return a->m_integer.sge(b->m_integer);
2789   case Scalar::e_uint:
2790   case Scalar::e_ulong:
2791   case Scalar::e_ulonglong:
2792   case Scalar::e_uint128:
2793   case Scalar::e_uint256:
2794     return a->m_integer.uge(b->m_integer);
2795   case Scalar::e_float:
2796   case Scalar::e_double:
2797   case Scalar::e_long_double:
2798     result = a->m_float.compare(b->m_float);
2799     if (result == llvm::APFloat::cmpGreaterThan ||
2800         result == llvm::APFloat::cmpEqual)
2801       return true;
2802   }
2803   return false;
2804 }
2805
2806 bool Scalar::ClearBit(uint32_t bit) {
2807   switch (m_type) {
2808   case e_void:
2809     break;
2810   case e_sint:
2811   case e_uint:
2812   case e_slong:
2813   case e_ulong:
2814   case e_slonglong:
2815   case e_ulonglong:
2816   case e_sint128:
2817   case e_uint128:
2818   case e_sint256:
2819   case e_uint256:
2820     m_integer.clearBit(bit);
2821     return true;
2822   case e_float:
2823   case e_double:
2824   case e_long_double:
2825     break;
2826   }
2827   return false;
2828 }
2829
2830 bool Scalar::SetBit(uint32_t bit) {
2831   switch (m_type) {
2832   case e_void:
2833     break;
2834   case e_sint:
2835   case e_uint:
2836   case e_slong:
2837   case e_ulong:
2838   case e_slonglong:
2839   case e_ulonglong:
2840   case e_sint128:
2841   case e_uint128:
2842   case e_sint256:
2843   case e_uint256:
2844     m_integer.setBit(bit);
2845     return true;
2846   case e_float:
2847   case e_double:
2848   case e_long_double:
2849     break;
2850   }
2851   return false;
2852 }