1 files changed, 348 insertions, 180 deletions

diff --git a/source/Utility/Scalar.cpp b/source/Utility/Scalar.cpp
index a2bb86ffdb15..23d50b9eaba5 100644
--- a/source/Utility/Scalar.cpp
+++ b/source/Utility/Scalar.cpp
@@ -1,9 +1,8 @@
 //===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -13,6 +12,7 @@
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/SmallString.h"
@@ -23,10 +23,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // Promote to max type currently follows the ANSI C rule for type promotion in
 // expressions.
-//----------------------------------------------------------------------
 static Scalar::Type PromoteToMaxType(
     const Scalar &lhs,  // The const left hand side object
     const Scalar &rhs,  // The const right hand side object
@@ -71,10 +69,7 @@ static Scalar::Type PromoteToMaxType(
   return Scalar::e_void;
 }
 
-Scalar::Scalar() : m_type(e_void), m_float((float)0) {}
-
-Scalar::Scalar(const Scalar &rhs)
-    : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
+Scalar::Scalar() : m_type(e_void), m_float(static_cast<float>(0)) {}
 
 bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
   size_t byte_size = GetByteSize();
@@ -107,7 +102,7 @@ const void *Scalar::GetBytes() const {
   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;
@@ -126,12 +121,12 @@ const void *Scalar::GetBytes() const {
         bytes += 8 - byte_size;
     }
     return bytes;
+  // getRawData always returns a pointer to an array of uint64_t values,
+  // where the least-significant word always comes first.  On big-endian
+  // systems we need to swap the words.
   case e_sint128:
   case e_uint128:
     apint_words = m_integer.getRawData();
-    // getRawData always returns a pointer to an array of two uint64_t values,
-    // where the least-significant word always comes first.  On big-endian
-    // systems we need to swap the two words.
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[1];
       swapped_words[1] = apint_words[0];
@@ -141,9 +136,6 @@ const void *Scalar::GetBytes() const {
   case e_sint256:
   case e_uint256:
     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[3];
       swapped_words[1] = apint_words[2];
@@ -152,6 +144,21 @@ const void *Scalar::GetBytes() const {
       apint_words = swapped_words;
     }
     return reinterpret_cast<const void *>(apint_words);
+  case e_sint512:
+  case e_uint512:
+    apint_words = m_integer.getRawData();
+    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);
@@ -188,6 +195,8 @@ size_t Scalar::GetByteSize() const {
   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);
@@ -214,6 +223,8 @@ bool Scalar::IsZero() const {
   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:
@@ -235,6 +246,7 @@ void Scalar::GetValue(Stream *s, bool show_type) const {
   case e_slonglong:
   case e_sint128:
   case e_sint256:
+  case e_sint512:
     s->PutCString(m_integer.toString(10, true));
     break;
   case e_uint:
@@ -242,6 +254,7 @@ void Scalar::GetValue(Stream *s, bool show_type) const {
   case e_ulonglong:
   case e_uint128:
   case e_uint256:
+  case e_uint512:
     s->PutCString(m_integer.toString(10, false));
     break;
   case e_float:
@@ -278,6 +291,10 @@ const char *Scalar::GetTypeAsCString() const {
     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:
@@ -348,13 +365,13 @@ Scalar &Scalar::operator=(double v) {
 Scalar &Scalar::operator=(long double v) {
   m_type = e_long_double;
   if (m_ieee_quad)
-    m_float = llvm::APFloat(
-        llvm::APFloat::IEEEquad(),
-        llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
+    m_float = llvm::APFloat(llvm::APFloat::IEEEquad(),
+                            llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                                        (reinterpret_cast<type128 *>(&v))->x));
   else
-    m_float = llvm::APFloat(
-        llvm::APFloat::x87DoubleExtended(),
-        llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
+    m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
+                            llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                                        (reinterpret_cast<type128 *>(&v))->x));
   return *this;
 }
 
@@ -387,6 +404,12 @@ Scalar &Scalar::operator=(llvm::APInt rhs) {
     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;
 }
@@ -443,6 +466,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -507,6 +536,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -567,6 +602,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -623,6 +664,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -675,6 +722,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -723,6 +776,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -771,6 +830,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -815,6 +880,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -859,6 +930,12 @@ bool Scalar::Promote(Scalar::Type type) {
       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,
@@ -899,6 +976,13 @@ bool Scalar::Promote(Scalar::Type type) {
     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,
@@ -923,6 +1007,11 @@ bool Scalar::Promote(Scalar::Type type) {
     }
     break;
 
+  case e_sint512:
+  case e_uint512:
+    lldbassert(false && "unimplemented");
+    break;
+
   case e_float:
     switch (type) {
     case e_void:
@@ -936,12 +1025,14 @@ bool Scalar::Promote(Scalar::Type type) {
     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());
+      m_float = llvm::APFloat(static_cast<double_t>(m_float.convertToFloat()));
       success = true;
       break;
 
@@ -969,6 +1060,8 @@ bool Scalar::Promote(Scalar::Type type) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
     case e_float:
       break;
     case e_double:
@@ -998,6 +1091,8 @@ bool Scalar::Promote(Scalar::Type type) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
     case e_float:
     case e_double:
       break;
@@ -1043,6 +1138,10 @@ const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
     return "int256_t";
   case e_uint256:
     return "uint256_t";
+  case e_sint512:
+    return "int512_t";
+  case e_uint512:
+    return "uint512_t";
   }
   return "???";
 }
@@ -1120,6 +1219,13 @@ bool Scalar::MakeSigned() {
     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;
@@ -1175,6 +1281,13 @@ bool Scalar::MakeUnsigned() {
   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;
@@ -1203,14 +1316,18 @@ signed char Scalar::SChar(char fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<schar_t>(
+        (m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
   case e_float:
-    return (schar_t)m_float.convertToFloat();
+    return static_cast<schar_t>(m_float.convertToFloat());
   case e_double:
-    return (schar_t)m_float.convertToDouble();
+    return static_cast<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();
+    return static_cast<schar_t>(
+        (ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
   }
   return fail_value;
 }
@@ -1229,14 +1346,18 @@ unsigned char Scalar::UChar(unsigned char fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<uchar_t>(
+        (m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
   case e_float:
-    return (uchar_t)m_float.convertToFloat();
+    return static_cast<uchar_t>(m_float.convertToFloat());
   case e_double:
-    return (uchar_t)m_float.convertToDouble();
+    return static_cast<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();
+    return static_cast<uchar_t>(
+        (ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
   }
   return fail_value;
 }
@@ -1255,16 +1376,18 @@ short Scalar::SShort(short fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
-        .getSExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<sshort_t>(
+        (m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
   case e_float:
-    return (sshort_t)m_float.convertToFloat();
+    return static_cast<sshort_t>(m_float.convertToFloat());
   case e_double:
-    return (sshort_t)m_float.convertToDouble();
+    return static_cast<sshort_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
-        .getSExtValue();
+    return static_cast<sshort_t>(
+        (ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
   }
   return fail_value;
 }
@@ -1283,16 +1406,18 @@ unsigned short Scalar::UShort(unsigned short fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
-        .getZExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<ushort_t>(
+        (m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
   case e_float:
-    return (ushort_t)m_float.convertToFloat();
+    return static_cast<ushort_t>(m_float.convertToFloat());
   case e_double:
-    return (ushort_t)m_float.convertToDouble();
+    return static_cast<ushort_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
-        .getZExtValue();
+    return static_cast<ushort_t>(
+        (ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
   }
   return fail_value;
 }
@@ -1311,14 +1436,18 @@ int Scalar::SInt(int fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<sint_t>(
+        (m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
   case e_float:
-    return (sint_t)m_float.convertToFloat();
+    return static_cast<sint_t>(m_float.convertToFloat());
   case e_double:
-    return (sint_t)m_float.convertToDouble();
+    return static_cast<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();
+    return static_cast<sint_t>(
+        (ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
   }
   return fail_value;
 }
@@ -1337,14 +1466,18 @@ unsigned int Scalar::UInt(unsigned int fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<uint_t>(
+        (m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
   case e_float:
-    return (uint_t)m_float.convertToFloat();
+    return static_cast<uint_t>(m_float.convertToFloat());
   case e_double:
-    return (uint_t)m_float.convertToDouble();
+    return static_cast<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();
+    return static_cast<uint_t>(
+        (ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
   }
   return fail_value;
 }
@@ -1363,14 +1496,18 @@ long Scalar::SLong(long fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<slong_t>(
+        (m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
   case e_float:
-    return (slong_t)m_float.convertToFloat();
+    return static_cast<slong_t>(m_float.convertToFloat());
   case e_double:
-    return (slong_t)m_float.convertToDouble();
+    return static_cast<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();
+    return static_cast<slong_t>(
+        (ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
   }
   return fail_value;
 }
@@ -1389,14 +1526,18 @@ unsigned long Scalar::ULong(unsigned long fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<ulong_t>(
+        (m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
   case e_float:
-    return (ulong_t)m_float.convertToFloat();
+    return static_cast<ulong_t>(m_float.convertToFloat());
   case e_double:
-    return (ulong_t)m_float.convertToDouble();
+    return static_cast<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();
+    return static_cast<ulong_t>(
+        (ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
   }
   return fail_value;
 }
@@ -1415,16 +1556,18 @@ long long Scalar::SLongLong(long long fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
-        .getSExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<slonglong_t>(
+        (m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
   case e_float:
-    return (slonglong_t)m_float.convertToFloat();
+    return static_cast<slonglong_t>(m_float.convertToFloat());
   case e_double:
-    return (slonglong_t)m_float.convertToDouble();
+    return static_cast<slonglong_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
-        .getSExtValue();
+    return static_cast<slonglong_t>(
+        (ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
   }
   return fail_value;
 }
@@ -1443,21 +1586,23 @@ unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
-        .getZExtValue();
+  case e_sint512:
+  case e_uint512:
+    return static_cast<ulonglong_t>(
+        (m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
   case e_float:
-    return (ulonglong_t)m_float.convertToFloat();
+    return static_cast<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);
-    return (ulonglong_t)(rounded_double.zextOrTrunc(sizeof(ulonglong_t) * 8))
-        .getZExtValue();
+    return static_cast<ulonglong_t>(
+        (rounded_double.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
   }
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8))
-        .getZExtValue();
+    return static_cast<ulonglong_t>(
+        (ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
   }
   return fail_value;
 }
@@ -1476,6 +1621,8 @@ llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     return m_integer;
   case e_float:
   case e_double:
@@ -1499,52 +1646,8 @@ llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    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:
-    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:
@@ -1568,11 +1671,13 @@ float Scalar::Float(float fail_value) const {
   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();
+    return static_cast<float_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return ldbl_val.bitsToFloat();
@@ -1594,9 +1699,11 @@ double Scalar::Double(double fail_value) const {
   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();
+    return static_cast<double_t>(m_float.convertToFloat());
   case e_double:
     return m_float.convertToDouble();
   case e_long_double:
@@ -1620,14 +1727,17 @@ long double Scalar::LongDouble(long double fail_value) const {
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
+  case e_sint512:
+  case e_uint512:
+    return static_cast<long_double_t>(
+        llvm::APIntOps::RoundAPIntToDouble(m_integer));
   case e_float:
-    return (long_double_t)m_float.convertToFloat();
+    return static_cast<long_double_t>(m_float.convertToFloat());
   case e_double:
-    return (long_double_t)m_float.convertToDouble();
+    return static_cast<long_double_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return (long_double_t)ldbl_val.bitsToDouble();
+    return static_cast<long_double_t>(ldbl_val.bitsToDouble());
   }
   return fail_value;
 }
@@ -1651,6 +1761,8 @@ Scalar &Scalar::operator+=(const Scalar &rhs) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = a->m_integer + b->m_integer;
       break;
 
@@ -1683,6 +1795,8 @@ Scalar &Scalar::operator<<=(const Scalar &rhs) {
   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:
@@ -1700,6 +1814,8 @@ Scalar &Scalar::operator<<=(const Scalar &rhs) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = m_integer << rhs.m_integer;
       break;
     }
@@ -1727,6 +1843,8 @@ bool Scalar::ShiftRightLogical(const Scalar &rhs) {
   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:
@@ -1744,6 +1862,8 @@ bool Scalar::ShiftRightLogical(const Scalar &rhs) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = m_integer.lshr(rhs.m_integer);
       break;
     }
@@ -1771,6 +1891,8 @@ Scalar &Scalar::operator>>=(const Scalar &rhs) {
   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:
@@ -1788,6 +1910,8 @@ Scalar &Scalar::operator>>=(const Scalar &rhs) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer = m_integer.ashr(rhs.m_integer);
       break;
     }
@@ -1815,6 +1939,8 @@ Scalar &Scalar::operator&=(const Scalar &rhs) {
   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:
@@ -1832,6 +1958,8 @@ Scalar &Scalar::operator&=(const Scalar &rhs) {
     case e_uint128:
     case e_sint256:
     case e_uint256:
+    case e_sint512:
+    case e_uint512:
       m_integer &= rhs.m_integer;
       break;
     }
@@ -1850,6 +1978,7 @@ bool Scalar::AbsoluteValue() {
   case e_slonglong:
   case e_sint128:
   case e_sint256:
+  case e_sint512:
     if (m_integer.isNegative())
       m_integer = -m_integer;
     return true;
@@ -1860,6 +1989,7 @@ bool Scalar::AbsoluteValue() {
     return true;
   case e_uint128:
   case e_uint256:
+  case e_uint512:
   case e_float:
   case e_double:
   case e_long_double:
@@ -1883,6 +2013,8 @@ bool Scalar::UnaryNegate() {
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer = -m_integer;
     return true;
   case e_float:
@@ -1906,6 +2038,8 @@ bool Scalar::OnesComplement() {
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer = ~m_integer;
     return true;
 
@@ -1938,6 +2072,8 @@ const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
     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:
@@ -1970,6 +2106,8 @@ const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
     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:
@@ -1997,6 +2135,7 @@ const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
     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;
@@ -2007,6 +2146,7 @@ const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
     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;
@@ -2048,6 +2188,8 @@ const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
     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:
@@ -2078,6 +2220,8 @@ const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
     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:
@@ -2110,6 +2254,8 @@ const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
     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;
 
@@ -2142,6 +2288,7 @@ const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
     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;
@@ -2152,6 +2299,7 @@ const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
     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;
@@ -2181,6 +2329,8 @@ const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
     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;
 
@@ -2227,10 +2377,10 @@ Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
         error.SetErrorStringWithFormat(
             "'%s' is not a valid unsigned integer string value", value_str);
       else if (!UIntValueIsValidForSize(uval64, byte_size))
-        error.SetErrorStringWithFormat("value 0x%" PRIx64
-                                       " is too large to fit in a %" PRIu64
-                                       " byte unsigned integer value",
-                                       uval64, (uint64_t)byte_size);
+        error.SetErrorStringWithFormat(
+            "value 0x%" PRIx64 " is too large to fit in a %" PRIu64
+            " byte unsigned integer value",
+            uval64, static_cast<uint64_t>(byte_size));
       else {
         m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
         switch (m_type) {
@@ -2246,14 +2396,14 @@ Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
         default:
           error.SetErrorStringWithFormat(
               "unsupported unsigned integer byte size: %" PRIu64 "",
-              (uint64_t)byte_size);
+              static_cast<uint64_t>(byte_size));
           break;
         }
       }
     } else {
       error.SetErrorStringWithFormat(
           "unsupported unsigned integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
+          static_cast<uint64_t>(byte_size));
       return error;
     }
     break;
@@ -2265,10 +2415,10 @@ Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
         error.SetErrorStringWithFormat(
             "'%s' is not a valid signed integer string value", value_str);
       else if (!SIntValueIsValidForSize(sval64, byte_size))
-        error.SetErrorStringWithFormat("value 0x%" PRIx64
-                                       " is too large to fit in a %" PRIu64
-                                       " byte signed integer value",
-                                       sval64, (uint64_t)byte_size);
+        error.SetErrorStringWithFormat(
+            "value 0x%" PRIx64 " is too large to fit in a %" PRIu64
+            " byte signed integer value",
+            sval64, static_cast<uint64_t>(byte_size));
       else {
         m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
         switch (m_type) {
@@ -2284,14 +2434,14 @@ Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
         default:
           error.SetErrorStringWithFormat(
               "unsupported signed integer byte size: %" PRIu64 "",
-              (uint64_t)byte_size);
+              static_cast<uint64_t>(byte_size));
           break;
         }
       }
     } else {
       error.SetErrorStringWithFormat(
           "unsupported signed integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
+          static_cast<uint64_t>(byte_size));
       return error;
     }
     break;
@@ -2316,17 +2466,17 @@ Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
                                        value_str);
     } else if (byte_size == sizeof(long double)) {
       if (::sscanf(value_str, "%Lf", &l_val) == 1) {
-        m_float =
-            llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                          llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
-                                      ((type128 *)&l_val)->x));
+        m_float = llvm::APFloat(
+            llvm::APFloat::x87DoubleExtended(),
+            llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
+                        (reinterpret_cast<type128 *>(&l_val))->x));
         m_type = e_long_double;
       } else
         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
                                        value_str);
     } else {
       error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
-                                     (uint64_t)byte_size);
+                                     static_cast<uint64_t>(byte_size));
       return error;
     }
     break;
@@ -2359,45 +2509,45 @@ Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
 
     switch (byte_size) {
     case 1:
-      operator=((uint8_t)data.GetU8(&offset));
+      operator=(data.GetU8(&offset));
       break;
     case 2:
-      operator=((uint16_t)data.GetU16(&offset));
+      operator=(data.GetU16(&offset));
       break;
     case 4:
-      operator=((uint32_t)data.GetU32(&offset));
+      operator=(data.GetU32(&offset));
       break;
     case 8:
-      operator=((uint64_t)data.GetU64(&offset));
+      operator=(data.GetU64(&offset));
       break;
     case 16:
       if (data.GetByteOrder() == eByteOrderBig) {
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
+        int128.x[1] = data.GetU64(&offset);
+        int128.x[0] = data.GetU64(&offset);
       } else {
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
+        int128.x[0] = data.GetU64(&offset);
+        int128.x[1] = data.GetU64(&offset);
       }
       operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
       break;
     case 32:
       if (data.GetByteOrder() == eByteOrderBig) {
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
+        int256.x[3] = data.GetU64(&offset);
+        int256.x[2] = data.GetU64(&offset);
+        int256.x[1] = data.GetU64(&offset);
+        int256.x[0] = data.GetU64(&offset);
       } else {
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
+        int256.x[0] = data.GetU64(&offset);
+        int256.x[1] = data.GetU64(&offset);
+        int256.x[2] = data.GetU64(&offset);
+        int256.x[3] = data.GetU64(&offset);
       }
       operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
       break;
     default:
       error.SetErrorStringWithFormat(
           "unsupported unsigned integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
+          static_cast<uint64_t>(byte_size));
       break;
     }
   } break;
@@ -2406,45 +2556,45 @@ Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
 
     switch (byte_size) {
     case 1:
-      operator=((int8_t)data.GetU8(&offset));
+      operator=(static_cast<int8_t>(data.GetU8(&offset)));
       break;
     case 2:
-      operator=((int16_t)data.GetU16(&offset));
+      operator=(static_cast<int16_t>(data.GetU16(&offset)));
       break;
     case 4:
-      operator=((int32_t)data.GetU32(&offset));
+      operator=(static_cast<int32_t>(data.GetU32(&offset)));
       break;
     case 8:
-      operator=((int64_t)data.GetU64(&offset));
+      operator=(static_cast<int64_t>(data.GetU64(&offset)));
       break;
     case 16:
       if (data.GetByteOrder() == eByteOrderBig) {
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
+        int128.x[1] = data.GetU64(&offset);
+        int128.x[0] = data.GetU64(&offset);
       } else {
-        int128.x[0] = (uint64_t)data.GetU64(&offset);
-        int128.x[1] = (uint64_t)data.GetU64(&offset);
+        int128.x[0] = data.GetU64(&offset);
+        int128.x[1] = data.GetU64(&offset);
       }
       operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
       break;
     case 32:
       if (data.GetByteOrder() == eByteOrderBig) {
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
+        int256.x[3] = data.GetU64(&offset);
+        int256.x[2] = data.GetU64(&offset);
+        int256.x[1] = data.GetU64(&offset);
+        int256.x[0] = data.GetU64(&offset);
       } else {
-        int256.x[0] = (uint64_t)data.GetU64(&offset);
-        int256.x[1] = (uint64_t)data.GetU64(&offset);
-        int256.x[2] = (uint64_t)data.GetU64(&offset);
-        int256.x[3] = (uint64_t)data.GetU64(&offset);
+        int256.x[0] = data.GetU64(&offset);
+        int256.x[1] = data.GetU64(&offset);
+        int256.x[2] = data.GetU64(&offset);
+        int256.x[3] = data.GetU64(&offset);
       }
       operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
       break;
     default:
       error.SetErrorStringWithFormat(
           "unsupported signed integer byte size: %" PRIu64 "",
-          (uint64_t)byte_size);
+          static_cast<uint64_t>(byte_size));
       break;
     }
   } break;
@@ -2452,14 +2602,14 @@ Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
     lldb::offset_t offset = 0;
 
     if (byte_size == sizeof(float))
-      operator=((float)data.GetFloat(&offset));
+      operator=(data.GetFloat(&offset));
     else if (byte_size == sizeof(double))
-      operator=((double)data.GetDouble(&offset));
+      operator=(data.GetDouble(&offset));
     else if (byte_size == sizeof(long double))
-      operator=((long double)data.GetLongDouble(&offset));
+      operator=(data.GetLongDouble(&offset));
     else
       error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
-                                     (uint64_t)byte_size);
+                                     static_cast<uint64_t>(byte_size));
   } break;
   }
 
@@ -2487,6 +2637,8 @@ bool Scalar::SignExtend(uint32_t sign_bit_pos) {
     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)) {
@@ -2546,6 +2698,7 @@ bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
   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());
@@ -2556,6 +2709,7 @@ bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
   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());
@@ -2586,6 +2740,8 @@ bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
   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:
@@ -2617,6 +2773,8 @@ bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
   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:
@@ -2660,6 +2818,8 @@ bool Scalar::ClearBit(uint32_t bit) {
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer.clearBit(bit);
     return true;
   case e_float:
@@ -2684,6 +2844,8 @@ bool Scalar::SetBit(uint32_t bit) {
   case e_uint128:
   case e_sint256:
   case e_uint256:
+  case e_sint512:
+  case e_uint512:
     m_integer.setBit(bit);
     return true;
   case e_float:
@@ -2693,3 +2855,9 @@ bool Scalar::SetBit(uint32_t bit) {
   }
   return false;
 }
+
+llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os, const Scalar &scalar) {
+  StreamString s;
+  scalar.GetValue(&s, /*show_type*/ true);
+  return os << s.GetString();
+}