[Scalar] Add support for 512-bits values.

[davide]

Summary

rdar://problem/46886288

[davide]

@clayborg, this is fairly mechanical, but I would appreciate if you can sign it off.

[aprantl]

lldb/source/Utility/RegisterValue.cpp

159

I'm curious, everything else in this patch refers to 512, how does this fit in?

lldb/source/Utility/Scalar.cpp

168

std::reverse perhaps?

[davide]

lldb/source/Utility/RegisterValue.cpp

159

512 bits / 8 (bits per byte) = 64 bytes.
I can change the number to be in bits, if you want.

lldb/source/Utility/Scalar.cpp

168

We might want to change this everywhere.

[davide]

Thanks for the review, Greg!

[zturner]

lldb/source/Utility/Scalar.cpp

161

I'm confused. You say it returns a pointer to an array of four uint64_t values, but here you're clearly swapping the order of eight uint64_t values. Is the comment wrong?

Anyway, how about:

std::swap(apint_words[0], apint_words[7]);
std::swap(apint_words[1], apint_words[6]);
std::swap(apint_words[2], apint_words[5]);
std::swap(apint_words[3], apint_words[4]);

[davide]

lldb/source/Utility/Scalar.cpp

161

Yes the comment is wrong. I need to update it.

[davide]

lldb/source/Utility/Scalar.cpp

168

I updated the comment but I can't really easily use std::swap or std::reverse because they operate on vectors and the unit of currency here is an array.
I thought about initializing a vector from the array we read and then call std::reverse (and then covert back to a pointer), but that didn't seem better than what we have now (or, at least, less ugly).

[zturner]

lldb/source/Utility/Scalar.cpp

168

I'm confused why std::swap(swapped_words[7], swapped_words[0]); and similar for the other 4 doesn't work though.

[davide]

lldb/source/Utility/Scalar.cpp

168

/Users/davide/llvm-monorepo/llvm-mono/llvm/tools/lldb/source/Utility/Scalar.cpp:144:7: error: no matching function for call to 'swap'
      std::swap(apint_words[0], apint_words[3]);
      ^~~~~~~~~
/Applications/Xcode4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/type_traits:4515:1: note: candidate template ignored: requirement 'is_move_assignable<const unsigned long long>::value' was not satisfied [with _Tp = const unsigned long long]
swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&

lldb/include/lldb/Utility/Scalar.h

 class DataExtractor;
 class Stream;
 } // namespace lldb_private
 
 #define NUM_OF_WORDS_INT128 2
 #define BITWIDTH_INT128 128
 #define NUM_OF_WORDS_INT256 4
 #define BITWIDTH_INT256 256
+#define NUM_OF_WORDS_INT512 8
+#define BITWIDTH_INT512 512
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // A class designed to hold onto values and their corresponding types.
 // Operators are defined and Scalar objects will correctly promote their types
 // and values before performing these operations. Type promotion currently
 // follows the ANSI C type promotion rules.
 //----------------------------------------------------------------------
 class Scalar {
 public:
   enum Type {
     e_void = 0,
     e_sint,
     e_uint,
     e_slong,
     e_ulong,
     e_slonglong,
     e_ulonglong,
     e_sint128,
     e_uint128,
     e_sint256,
     e_uint256,
+    e_sint512,
+    e_uint512,
     e_float,
     e_double,
     e_long_double
   };
 
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
case 64:
       m_type = e_slonglong;
       return;
     case 128:
       m_type = e_sint128;
       return;
     case 256:
       m_type = e_sint256;
       return;
+    case 512:
+      m_type = e_sint512;
+      return;
     }
     lldbassert(false && "unsupported bitwidth");
   }
   Scalar(const Scalar &rhs);
   // Scalar(const RegisterValue& reg_value);
   virtual ~Scalar();
 
   bool SignExtend(uint32_t bit_pos);

lldb/source/Utility/RegisterValue.cpp

case eTypeBytes: {
     case 4:
       scalar = *(const uint32_t *)buffer.bytes;
       return true;
     case 8:
       scalar = *(const uint64_t *)buffer.bytes;
       return true;
     case 16:
     case 32:
+    case 64:
       if (buffer.length % sizeof(uint64_t) == 0) {
         const auto length_in_bits = buffer.length * 8;
         const auto length_in_uint64 = buffer.length / sizeof(uint64_t);
         scalar =
             llvm::APInt(length_in_bits,
                         llvm::ArrayRef<uint64_t>((const uint64_t *)buffer.bytes,
                                                  length_in_uint64));
         return true;

lldb/source/Utility/Scalar.cpp

bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
   return false;
 }
 
 const void *Scalar::GetBytes() const {
   const uint64_t *apint_words;
   const uint8_t *bytes;
   static float_t flt_val;
   static double_t dbl_val;
-  static uint64_t swapped_words[4];
+  static uint64_t swapped_words[8];
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
case e_uint256:
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[3];
       swapped_words[1] = apint_words[2];
       swapped_words[2] = apint_words[1];
       swapped_words[3] = apint_words[0];
       apint_words = swapped_words;
     }
     return reinterpret_cast<const void *>(apint_words);
+  case e_sint512:
+  case e_uint512:
+    apint_words = m_integer.getRawData();
+    // getRawData always returns a pointer to an array of four uint64_t values,
+    // where the least-significant word always comes first.  On big-endian
+    // systems we need to swap the four words.
+    if (endian::InlHostByteOrder() == eByteOrderBig) {
+      swapped_words[0] = apint_words[7];
+      swapped_words[1] = apint_words[6];
+      swapped_words[2] = apint_words[5];
+      swapped_words[3] = apint_words[4];
+      swapped_words[4] = apint_words[3];
+      swapped_words[5] = apint_words[2];
+      swapped_words[6] = apint_words[1];
+      swapped_words[7] = apint_words[0];
+      apint_words = swapped_words;
+    }
+    return reinterpret_cast<const void *>(apint_words);
   case e_float:
     flt_val = m_float.convertToFloat();
     return reinterpret_cast<const void *>(&flt_val);
   case e_double:
     dbl_val = m_float.convertToDouble();
     return reinterpret_cast<const void *>(&dbl_val);
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
size_t Scalar::GetByteSize() const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (m_integer.getBitWidth() / 8);
   case e_float:
     return sizeof(float_t);
   case e_double:
     return sizeof(double_t);
   case e_long_double:
     return sizeof(long_double_t);
   }
bool Scalar::IsZero() const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_uint512:
+  case e_sint512:
     return llvm::APInt::isSameValue(zero_int, m_integer);
   case e_float:
   case e_double:
   case e_long_double:
     return m_float.isZero();
   }
   return false;
 }
 
 void Scalar::GetValue(Stream *s, bool show_type) const {
   if (show_type)
     s->Printf("(%s) ", GetTypeAsCString());
 
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_slong:
   case e_slonglong:
   case e_sint128:
   case e_sint256:
+  case e_sint512:
     s->PutCString(m_integer.toString(10, true));
     break;
   case e_uint:
   case e_ulong:
   case e_ulonglong:
   case e_uint128:
   case e_uint256:
+  case e_uint512:
     s->PutCString(m_integer.toString(10, false));
     break;
   case e_float:
   case e_double:
   case e_long_double:
     llvm::SmallString<24> string;
     m_float.toString(string);
     s->Printf("%s", string.c_str());
const char *Scalar::GetTypeAsCString() const {
   case e_sint128:
     return "int128_t";
   case e_uint128:
     return "unsigned int128_t";
   case e_sint256:
     return "int256_t";
   case e_uint256:
     return "unsigned int256_t";
+  case e_sint512:
+    return "int512_t";
+  case e_uint512:
+    return "unsigned int512_t";
   case e_float:
     return "float";
   case e_double:
     return "double";
   case e_long_double:
     return "long double";
   }
   return "<invalid Scalar type>";
else
       m_type = e_uint128;
     break;
   case 256:
     if (m_integer.isSignedIntN(BITWIDTH_INT256))
       m_type = e_sint256;
     else
       m_type = e_uint256;
     break;
+  case 512:
+    if (m_integer.isSignedIntN(BITWIDTH_INT512))
+      m_type = e_sint512;
+    else
+      m_type = e_uint512;
+    break;
   }
   return *this;
 }
 
 Scalar::~Scalar() = default;
 
 bool Scalar::Promote(Scalar::Type type) {
   bool success = false;
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, true,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, true,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, true,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       break;
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, true,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint128:
       success = true;
       break;
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_sint256:
     case e_sint256:
       success = true;
       break;
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, true,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
case e_uint256:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
       break;
     case e_uint256:
       success = true;
       break;
+
+    case e_sint512:
+    case e_uint512:
+      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
+      success = true;
+      break;
+
     case e_float:
       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
       m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
                                           : llvm::APFloat::x87DoubleExtended());
       m_float.convertFromAPInt(m_integer, false,
                                llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
+  case e_sint512:
+  case e_uint512:
+    lldbassert(false && "unimplemented");
+    break;
+
   case e_float:
     switch (type) {
     case e_void:
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_uint512:
+    case e_sint512:
       break;
     case e_float:
       success = true;
       break;
     case e_double:
       m_float = llvm::APFloat((double_t)m_float.convertToFloat());
       success = true;
       break;
case e_double:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
     case e_float:
       break;
     case e_double:
       success = true;
       break;
     case e_long_double: {
       bool ignore;
       m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
case e_long_double:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
     case e_float:
     case e_double:
       break;
     case e_long_double:
       success = true;
       break;
     }
     break;
const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
   case e_sint128:
     return "int128_t";
   case e_uint128:
     return "uint128_t";
   case e_sint256:
     return "int256_t";
   case e_uint256:
     return "uint256_t";
+  case e_sint512:
+    return "int512_t";
+  case e_uint512:
+    return "uint512_t";
   }
   return "???";
 }
 
 Scalar::Type
 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
   if (byte_size <= sizeof(sint_t))
     return e_sint;
case e_uint128:
     break;
   case e_sint256:
     success = true;
     break;
   case e_uint256:
     m_type = e_sint256;
     success = true;
     break;
+  case e_sint512:
+    success = true;
+    break;
+  case e_uint512:
+    m_type = e_sint512;
+    success = true;
+    break;
   case e_float:
     success = true;
     break;
   case e_double:
     success = true;
     break;
   case e_long_double:
     success = true;
case e_uint128:
     break;
   case e_sint256:
     m_type = e_uint256;
     success = true;
     break;
   case e_uint256:
     success = true;
     break;
+  case e_sint512:
+    m_type = e_uint512;
+    success = true;
+    break;
+  case e_uint512:
+    success = true;
+    break;
   case e_float:
     success = true;
     break;
   case e_double:
     success = true;
     break;
   case e_long_double:
     success = true;
signed char Scalar::SChar(char fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
   case e_float:
     return (schar_t)m_float.convertToFloat();
   case e_double:
     return (schar_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
unsigned char Scalar::UChar(unsigned char fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
   case e_float:
     return (uchar_t)m_float.convertToFloat();
   case e_double:
     return (uchar_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
short Scalar::SShort(short fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
         .getSExtValue();
   case e_float:
     return (sshort_t)m_float.convertToFloat();
   case e_double:
     return (sshort_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
unsigned short Scalar::UShort(unsigned short fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
         .getZExtValue();
   case e_float:
     return (ushort_t)m_float.convertToFloat();
   case e_double:
     return (ushort_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
int Scalar::SInt(int fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
   case e_float:
     return (sint_t)m_float.convertToFloat();
   case e_double:
     return (sint_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
unsigned int Scalar::UInt(unsigned int fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
   case e_float:
     return (uint_t)m_float.convertToFloat();
   case e_double:
     return (uint_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
long Scalar::SLong(long fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
   case e_float:
     return (slong_t)m_float.convertToFloat();
   case e_double:
     return (slong_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
unsigned long Scalar::ULong(unsigned long fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
   case e_float:
     return (ulong_t)m_float.convertToFloat();
   case e_double:
     return (ulong_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
long long Scalar::SLongLong(long long fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
         .getSExtValue();
   case e_float:
     return (slonglong_t)m_float.convertToFloat();
   case e_double:
     return (slonglong_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
         .getZExtValue();
   case e_float:
     return (ulonglong_t)m_float.convertToFloat();
   case e_double: {
     double d_val = m_float.convertToDouble();
     llvm::APInt rounded_double =
         llvm::APIntOps::RoundDoubleToAPInt(d_val, sizeof(ulonglong_t) * 8);
llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return m_integer;
   case e_float:
   case e_double:
   case e_long_double:
     return m_float.bitcastToAPInt();
   }
   return fail_value;
 }
 
 llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return m_integer;
   case e_float:
   case e_double:
   case e_long_double:
     return m_float.bitcastToAPInt();
   }
   return fail_value;
 }
 
 llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_uint512:
+  case e_sint512:
     return m_integer;
   case e_float:
   case e_double:
   case e_long_double:
     return m_float.bitcastToAPInt();
   }
   return fail_value;
 }
 
 llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return m_integer;
   case e_float:
   case e_double:
   case e_long_double:
     return m_float.bitcastToAPInt();
   }
   return fail_value;
 }
 
 float Scalar::Float(float fail_value) const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return llvm::APIntOps::RoundAPIntToFloat(m_integer);
   case e_float:
     return m_float.convertToFloat();
   case e_double:
     return (float_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return ldbl_val.bitsToFloat();
double Scalar::Double(double fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return llvm::APIntOps::RoundAPIntToDouble(m_integer);
   case e_float:
     return (double_t)m_float.convertToFloat();
   case e_double:
     return m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return ldbl_val.bitsToFloat();
long double Scalar::LongDouble(long double fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
   case e_float:
     return (long_double_t)m_float.convertToFloat();
   case e_double:
     return (long_double_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (long_double_t)ldbl_val.bitsToDouble();
if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = a->m_integer + b->m_integer;
       break;
 
     case e_float:
     case e_double:
     case e_long_double:
       m_float = a->m_float + b->m_float;
       break;
Scalar &Scalar::operator<<=(const Scalar &rhs) {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     switch (rhs.m_type) {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
       m_type = e_void;
       break;
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = m_integer << rhs.m_integer;
       break;
     }
     break;
   }
   return *this;
 }
 
bool Scalar::ShiftRightLogical(const Scalar &rhs) {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     switch (rhs.m_type) {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
       m_type = e_void;
       break;
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = m_integer.lshr(rhs.m_integer);
       break;
     }
     break;
   }
   return m_type != e_void;
 }
 
Scalar &Scalar::operator>>=(const Scalar &rhs) {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     switch (rhs.m_type) {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
       m_type = e_void;
       break;
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = m_integer.ashr(rhs.m_integer);
       break;
     }
     break;
   }
   return *this;
 }
 
Scalar &Scalar::operator&=(const Scalar &rhs) {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     switch (rhs.m_type) {
     case e_void:
     case e_float:
     case e_double:
     case e_long_double:
       m_type = e_void;
       break;
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer &= rhs.m_integer;
       break;
     }
     break;
   }
   return *this;
 }
 
 bool Scalar::AbsoluteValue() {
   switch (m_type) {
   case e_void:
     break;
 
   case e_sint:
   case e_slong:
   case e_slonglong:
   case e_sint128:
   case e_sint256:
+  case e_sint512:
     if (m_integer.isNegative())
       m_integer = -m_integer;
     return true;
 
   case e_uint:
   case e_ulong:
   case e_ulonglong:
     return true;
   case e_uint128:
   case e_uint256:
+  case e_uint512:
   case e_float:
   case e_double:
   case e_long_double:
     m_float.clearSign();
     return true;
   }
   return false;
 }
 
 bool Scalar::UnaryNegate() {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer = -m_integer;
     return true;
   case e_float:
   case e_double:
   case e_long_double:
     m_float.changeSign();
     return true;
   }
   return false;
 }
 
 bool Scalar::OnesComplement() {
   switch (m_type) {
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer = ~m_integer;
     return true;
 
   case e_void:
   case e_float:
   case e_double:
   case e_long_double:
     break;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       result.m_integer = a->m_integer + b->m_integer;
       break;
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
       result.m_float = a->m_float + b->m_float;
       break;
     }
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       result.m_integer = a->m_integer - b->m_integer;
       break;
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
       result.m_float = a->m_float - b->m_float;
       break;
     }
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     switch (result.m_type) {
     case Scalar::e_void:
       break;
     case Scalar::e_sint:
     case Scalar::e_slong:
     case Scalar::e_slonglong:
     case Scalar::e_sint128:
     case Scalar::e_sint256:
+    case Scalar::e_sint512:
       if (b->m_integer != 0) {
         result.m_integer = a->m_integer.sdiv(b->m_integer);
         return result;
       }
       break;
     case Scalar::e_uint:
     case Scalar::e_ulong:
     case Scalar::e_ulonglong:
     case Scalar::e_uint128:
     case Scalar::e_uint256:
+    case Scalar::e_uint512:
       if (b->m_integer != 0) {
         result.m_integer = a->m_integer.udiv(b->m_integer);
         return result;
       }
       break;
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       result.m_integer = a->m_integer * b->m_integer;
       break;
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
       result.m_float = a->m_float * b->m_float;
       break;
     }
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       result.m_integer = a->m_integer & b->m_integer;
       break;
     case Scalar::e_void:
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
       // No bitwise AND on floats, doubles of long doubles
       result.m_type = Scalar::e_void;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       result.m_integer = a->m_integer | b->m_integer;
       break;
 
     case Scalar::e_void:
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
       // No bitwise AND on floats, doubles of long doubles
default:
       break;
     case Scalar::e_void:
       break;
     case Scalar::e_sint:
     case Scalar::e_slong:
     case Scalar::e_slonglong:
     case Scalar::e_sint128:
     case Scalar::e_sint256:
+    case Scalar::e_sint512:
       if (b->m_integer != 0) {
         result.m_integer = a->m_integer.srem(b->m_integer);
         return result;
       }
       break;
     case Scalar::e_uint:
     case Scalar::e_ulong:
     case Scalar::e_ulonglong:
     case Scalar::e_uint128:
     case Scalar::e_uint256:
+    case Scalar::e_uint512:
       if (b->m_integer != 0) {
         result.m_integer = a->m_integer.urem(b->m_integer);
         return result;
       }
       break;
     }
   }
   result.m_type = Scalar::e_void;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       result.m_integer = a->m_integer ^ b->m_integer;
       break;
 
     case Scalar::e_void:
     case Scalar::e_float:
     case Scalar::e_double:
     case Scalar::e_long_double:
       // No bitwise AND on floats, doubles of long doubles
if (sign_bit_pos < max_bit_pos) {
     case Scalar::e_slong:
     case Scalar::e_ulong:
     case Scalar::e_slonglong:
     case Scalar::e_ulonglong:
     case Scalar::e_sint128:
     case Scalar::e_uint128:
     case Scalar::e_sint256:
     case Scalar::e_uint256:
+    case Scalar::e_sint512:
+    case Scalar::e_uint512:
       if (max_bit_pos == sign_bit_pos)
         return true;
       else if (sign_bit_pos < (max_bit_pos - 1)) {
         llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
         llvm::APInt bitwize_and = m_integer & sign_bit;
         if (bitwize_and.getBoolValue()) {
           const llvm::APInt mask =
               ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
   case Scalar::e_long_double:
     break;
 
   case Scalar::e_sint:
   case Scalar::e_slong:
   case Scalar::e_slonglong:
   case Scalar::e_sint128:
   case Scalar::e_sint256:
+  case Scalar::e_sint512:
     m_integer = m_integer.ashr(bit_offset)
                     .sextOrTrunc(bit_size)
                     .sextOrSelf(8 * GetByteSize());
     return true;
 
   case Scalar::e_uint:
   case Scalar::e_ulong:
   case Scalar::e_ulonglong:
   case Scalar::e_uint128:
   case Scalar::e_uint256:
+  case Scalar::e_uint512:
     m_integer = m_integer.lshr(bit_offset)
                     .zextOrTrunc(bit_size)
                     .zextOrSelf(8 * GetByteSize());
     return true;
   }
   return false;
 }
 
bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
   case Scalar::e_slong:
   case Scalar::e_ulong:
   case Scalar::e_slonglong:
   case Scalar::e_ulonglong:
   case Scalar::e_sint128:
   case Scalar::e_uint128:
   case Scalar::e_sint256:
   case Scalar::e_uint256:
+  case Scalar::e_sint512:
+  case Scalar::e_uint512:
     return a->m_integer == b->m_integer;
   case Scalar::e_float:
   case Scalar::e_double:
   case Scalar::e_long_double:
     result = a->m_float.compare(b->m_float);
     if (result == llvm::APFloat::cmpEqual)
       return true;
   }
bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
   case Scalar::e_void:
     break;
   case Scalar::e_sint:
   case Scalar::e_slong:
   case Scalar::e_slonglong:
   case Scalar::e_sint128:
   case Scalar::e_sint256:
+  case Scalar::e_sint512:
+  case Scalar::e_uint512:
     return a->m_integer.slt(b->m_integer);
   case Scalar::e_uint:
   case Scalar::e_ulong:
   case Scalar::e_ulonglong:
   case Scalar::e_uint128:
   case Scalar::e_uint256:
     return a->m_integer.ult(b->m_integer);
   case Scalar::e_float:
bool Scalar::ClearBit(uint32_t bit) {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer.clearBit(bit);
     return true;
   case e_float:
   case e_double:
   case e_long_double:
     break;
   }
   return false;
 }
 
 bool Scalar::SetBit(uint32_t bit) {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer.setBit(bit);
     return true;
   case e_float:
   case e_double:
   case e_long_double:
     break;
   }
   return false;
 }

lldb/unittests/Utility/ScalarTest.cpp

TEST(ScalarTest, APIntConstructor) {
   }
 
   Scalar B(APInt(64, 42));
   EXPECT_EQ(B.GetType(), Scalar::e_slonglong);
   Scalar C(APInt(128, 96));
   EXPECT_EQ(C.GetType(), Scalar::e_sint128);
   Scalar D(APInt(256, 156));
   EXPECT_EQ(D.GetType(), Scalar::e_sint256);
+  Scalar E(APInt(512, 456));
+  EXPECT_EQ(E.GetType(), Scalar::e_sint512);
+}
+
+TEST(ScalarTest, Scalar_512) {
+  Scalar Z(APInt(512, 0));
+  ASSERT_TRUE(Z.IsZero());
+  Z.MakeUnsigned();
+  ASSERT_TRUE(Z.IsZero());
+
+  Scalar S(APInt(512, 2000));
+  EXPECT_EQ(S.GetTypeAsCString(), "int512_t");
+  EXPECT_EQ(S.GetValueTypeAsCString(Scalar::e_sint512), "int512_t");
+
+  ASSERT_TRUE(S.MakeUnsigned());
+  EXPECT_EQ(S.GetType(), Scalar::e_uint512);
+  EXPECT_EQ(S.GetTypeAsCString(), "unsigned int512_t");
+  EXPECT_EQ(S.GetValueTypeAsCString(Scalar::e_uint512), "uint512_t");
+  EXPECT_EQ(S.GetByteSize(), 64U);
+
+  ASSERT_TRUE(S.MakeSigned());
+  EXPECT_EQ(S.GetType(), Scalar::e_sint512);
+  EXPECT_EQ(S.GetByteSize(), 64U);
 }