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