/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Utility/Scalar.cpp

Bug Summary

File:	tools/lldb/source/Utility/Scalar.cpp
Warning:	line 172, column 5 Address of stack memory associated with local variable 'ldbl_val' returned to caller
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Scalar.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/Utility -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Utility -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/Utility -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Utility/Scalar.cpp -faddrsig
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//===----------------------------------------------------------------------===//

10#include "lldb/Utility/Scalar.h"

12#include "lldb/Utility/DataExtractor.h"
13#include "lldb/Utility/Endian.h"
14#include "lldb/Utility/Status.h"
15#include "lldb/Utility/Stream.h"
16#include "lldb/lldb-types.h" // for offset_t

18#include "llvm/ADT/SmallString.h"

20#include <cinttypes>
21#include <cstdio>

23using namespace lldb;
24using namespace lldb_private;

26//----------------------------------------------------------------------
27// Promote to max type currently follows the ANSI C rule for type promotion in
28// expressions.
29//----------------------------------------------------------------------
30static Scalar::Type PromoteToMaxType(
  const Scalar &lhs,  // The const left hand side object
  const Scalar &rhs,  // The const right hand side object
  Scalar &temp_value, // A modifiable temp value than can be used to hold
                      // either the promoted lhs or rhs object
  const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
                                   // promoted value of lhs (at most one of
                                   // lhs/rhs will get promoted)
  const Scalar *&promoted_rhs_ptr  // Pointer to the resulting possibly
                                   // promoted value of rhs (at most one of
                                   // lhs/rhs will get promoted)
41) {
Scalar result;
// Initialize the promoted values for both the right and left hand side
// values to be the objects themselves. If no promotion is needed (both right
// and left have the same type), then the temp_value will not get used.
promoted_lhs_ptr = &lhs;
promoted_rhs_ptr = &rhs;
// Extract the types of both the right and left hand side values
Scalar::Type lhs_type = lhs.GetType();
Scalar::Type rhs_type = rhs.GetType();

if (lhs_type > rhs_type) {
  // Right hand side need to be promoted
  temp_value = rhs; // Copy right hand side into the temp value
  if (temp_value.Promote(lhs_type)) // Promote it
    promoted_rhs_ptr =
        &temp_value; // Update the pointer for the promoted right hand side
} else if (lhs_type < rhs_type) {
  // Left hand side need to be promoted
  temp_value = lhs; // Copy left hand side value into the temp value
  if (temp_value.Promote(rhs_type)) // Promote it
    promoted_lhs_ptr =
        &temp_value; // Update the pointer for the promoted left hand side
}

// Make sure our type promotion worked as expected
if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
  return promoted_lhs_ptr->GetType(); // Return the resulting max type

// Return the void type (zero) if we fail to promote either of the values.
return Scalar::e_void;
72}

74Scalar::Scalar() : m_type(e_void), m_float((float)0) {}

76Scalar::Scalar(const Scalar &rhs)
  : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}

79bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
size_t byte_size = GetByteSize();
if (byte_size > 0) {
2
←
Taking true branch→
  const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
3
←
Calling 'Scalar::GetBytes'→

  if (limit_byte_size < byte_size) {
    if (endian::InlHostByteOrder() == eByteOrderLittle) {
      // On little endian systems if we want fewer bytes from the current
      // type we just specify fewer bytes since the LSByte is first...
      byte_size = limit_byte_size;
    } else if (endian::InlHostByteOrder() == eByteOrderBig) {
      // On big endian systems if we want fewer bytes from the current type
      // have to advance our initial byte pointer and trim down the number of
      // bytes since the MSByte is first
      bytes += byte_size - limit_byte_size;
      byte_size = limit_byte_size;
    }
  }

  data.SetData(bytes, byte_size, endian::InlHostByteOrder());
  return true;
}
data.Clear();
return false;
103}

105const 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];
switch (m_type) {
4
←
Control jumps to 'case e_long_double:'  at line 161→
case e_void:
  break;
case e_sint:
case e_uint:
case e_slong:
case e_ulong:
case e_slonglong:
case e_ulonglong:
  bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
  // getRawData always returns a pointer to an uint64_t.  If we have a
  // smaller type, we need to update the pointer on big-endian systems.
  if (endian::InlHostByteOrder() == eByteOrderBig) {
    size_t byte_size = m_integer.getBitWidth() / 8;
    if (byte_size < 8)
      bytes += 8 - byte_size;
  }
  return bytes;
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];
    apint_words = swapped_words;
  }
  return reinterpret_cast<const void *>(apint_words);
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];
    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_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();
  apint_words = ldbl_val.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) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
    swapped_words[0] = apint_words[1];
    swapped_words[1] = apint_words[0];
    apint_words = swapped_words;
  }
  return reinterpret_cast<const void *>(apint_words);
7
←
Address of stack memory associated with local variable 'ldbl_val' returned to caller
}
return nullptr;
175}

177size_t Scalar::GetByteSize() 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.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);
}
return 0;
200}

202bool Scalar::IsZero() const {
llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 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_ulonglong:
case e_sint128:
case e_uint128:
case e_sint256:
case e_uint256:
  return llvm::APInt::isSameValue(zero_int, m_integer);
case e_float:
case e_double:
case e_long_double:
  return m_float.isZero();
}
return false;
224}

226void 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:
  s->PutCString(m_integer.toString(10, true));
  break;
case e_uint:
case e_ulong:
case e_ulonglong:
case e_uint128:
case e_uint256:
  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());
  break;
}
255}

257const char *Scalar::GetTypeAsCString() const {
switch (m_type) {
case e_void:
  return "void";
case e_sint:
  return "int";
case e_uint:
  return "unsigned int";
case e_slong:
  return "long";
case e_ulong:
  return "unsigned long";
case e_slonglong:
  return "long long";
case e_ulonglong:
  return "unsigned long long";
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_float:
  return "float";
case e_double:
  return "double";
case e_long_double:
  return "long double";
}
return "<invalid Scalar type>";
289}

291Scalar &Scalar::operator=(const Scalar &rhs) {
if (this != &rhs) {
  m_type = rhs.m_type;
  m_integer = llvm::APInt(rhs.m_integer);
  m_float = rhs.m_float;
}
return *this;
298}

300Scalar &Scalar::operator=(const int v) {
m_type = e_sint;
m_integer = llvm::APInt(sizeof(int) * 8, v, true);
return *this;
304}

306Scalar &Scalar::operator=(unsigned int v) {
m_type = e_uint;
m_integer = llvm::APInt(sizeof(int) * 8, v);
return *this;
310}

312Scalar &Scalar::operator=(long v) {
m_type = e_slong;
m_integer = llvm::APInt(sizeof(long) * 8, v, true);
return *this;
316}

318Scalar &Scalar::operator=(unsigned long v) {
m_type = e_ulong;
m_integer = llvm::APInt(sizeof(long) * 8, v);
return *this;
322}

324Scalar &Scalar::operator=(long long v) {
m_type = e_slonglong;
m_integer = llvm::APInt(sizeof(long) * 8, v, true);
return *this;
328}

330Scalar &Scalar::operator=(unsigned long long v) {
m_type = e_ulonglong;
m_integer = llvm::APInt(sizeof(long long) * 8, v);
return *this;
334}

336Scalar &Scalar::operator=(float v) {
m_type = e_float;
m_float = llvm::APFloat(v);
return *this;
340}

342Scalar &Scalar::operator=(double v) {
m_type = e_double;
m_float = llvm::APFloat(v);
return *this;
346}

348Scalar &Scalar::operator=(long double v) {
m_type = e_long_double;
if (m_ieee_quad)
  m_float = llvm::APFloat(
      llvm::APFloat::IEEEquad(),
      llvm::APInt(BITWIDTH_INT128128, NUM_OF_WORDS_INT1282, ((type128 *)&v)->x));
else
  m_float = llvm::APFloat(
      llvm::APFloat::x87DoubleExtended(),
      llvm::APInt(BITWIDTH_INT128128, NUM_OF_WORDS_INT1282, ((type128 *)&v)->x));
return *this;
359}

361Scalar &Scalar::operator=(llvm::APInt rhs) {
m_integer = llvm::APInt(rhs);
switch (m_integer.getBitWidth()) {
case 8:
case 16:
case 32:
  if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
    m_type = e_sint;
  else
    m_type = e_uint;
  break;
case 64:
  if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
    m_type = e_slonglong;
  else
    m_type = e_ulonglong;
  break;
case 128:
  if (m_integer.isSignedIntN(BITWIDTH_INT128128))
    m_type = e_sint128;
  else
    m_type = e_uint128;
  break;
case 256:
  if (m_integer.isSignedIntN(BITWIDTH_INT256256))
    m_type = e_sint256;
  else
    m_type = e_uint256;
  break;
}
return *this;
392}

394Scalar::~Scalar() = default;

396bool Scalar::Promote(Scalar::Type type) {
bool success = false;
switch (m_type) {
case e_void:
  break;

case e_sint:
  switch (type) {
  case e_void:
    break;
  case e_sint:
    success = true;
    break;
  case e_uint:
    m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
    success = true;
    break;

  case e_slong:
    m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
    success = true;
    break;

  case e_ulong:
    m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
    success = true;
    break;

  case e_slonglong:
    m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
    success = true;
    break;

  case e_ulonglong:
    m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
    success = true;
    break;

  case e_sint128:
  case e_uint128:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256256);
    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:
    m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
    m_float.convertFromAPInt(m_integer, true,
                             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, true,
                             llvm::APFloat::rmNearestTiesToEven);
    success = true;
    break;
  }
  break;

case e_uint:
  switch (type) {
  case e_void:
  case e_sint:
    break;
  case e_uint:
    success = true;
    break;
  case e_slong:
    m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
    success = true;
    break;

  case e_ulong:
    m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
    success = true;
    break;

  case e_slonglong:
    m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
    success = true;
    break;

  case e_ulonglong:
    m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
    success = true;
    break;

  case e_sint128:
  case e_uint128:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256256);
    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_slong:
  switch (type) {
  case e_void:
  case e_sint:
  case e_uint:
    break;
  case e_slong:
    success = true;
    break;
  case e_ulong:
    m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
    success = true;
    break;

  case e_slonglong:
    m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
    success = true;
    break;

  case e_ulonglong:
    m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
    success = true;
    break;

  case e_sint128:
  case e_uint128:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256256);
    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:
    m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
    m_float.convertFromAPInt(m_integer, true,
                             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, true,
                             llvm::APFloat::rmNearestTiesToEven);
    success = true;
    break;
  }
  break;

case e_ulong:
  switch (type) {
  case e_void:
  case e_sint:
  case e_uint:
  case e_slong:
    break;
  case e_ulong:
    success = true;
    break;
  case e_slonglong:
    m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
    success = true;
    break;

  case e_ulonglong:
    m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
    success = true;
    break;

  case e_sint128:
  case e_uint128:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256256);
    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_slonglong:
  switch (type) {
  case e_void:
  case e_sint:
  case e_uint:
  case e_slong:
  case e_ulong:
    break;
  case e_slonglong:
    success = true;
    break;
  case e_ulonglong:
    m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
    success = true;
    break;

  case e_sint128:
  case e_uint128:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256256);
    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:
    m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
    m_float.convertFromAPInt(m_integer, true,
                             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, true,
                             llvm::APFloat::rmNearestTiesToEven);
    success = true;
    break;
  }
  break;

case e_ulonglong:
  switch (type) {
  case e_void:
  case e_sint:
  case e_uint:
  case e_slong:
  case e_ulong:
  case e_slonglong:
    break;
  case e_ulonglong:
    success = true;
    break;
  case e_sint128:
  case e_uint128:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256256);
    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_sint128:
  switch (type) {
  case e_void:
  case e_sint:
  case e_uint:
  case e_slong:
  case e_ulong:
  case e_slonglong:
  case e_ulonglong:
    break;
  case e_sint128:
    success = true;
    break;
  case e_uint128:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128128);
    success = true;
    break;

  case e_sint256:
  case e_uint256:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256256);
    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:
    m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
    m_float.convertFromAPInt(m_integer, true,
                             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, true,
                             llvm::APFloat::rmNearestTiesToEven);
    success = true;
    break;
  }
  break;

case e_uint128:
  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:
    break;
  case e_uint128:
    success = true;
    break;
  case e_sint256:
  case e_uint256:
    m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256256);
    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_sint256:
  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:
    break;
  case e_sint256:
    success = true;
    break;
  case e_uint256:
    m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256256);
    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:
    m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
    m_float.convertFromAPInt(m_integer, true,
                             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, true,
                             llvm::APFloat::rmNearestTiesToEven);
    success = true;
    break;
  }
  break;

case e_uint256:
  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:
    break;
  case e_uint256:
    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_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:
    break;
  case e_float:
    success = true;
    break;
  case e_double:
    m_float = llvm::APFloat((double_t)m_float.convertToFloat());
    success = true;
    break;

  case e_long_double: {
    bool ignore;
    m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
                                : llvm::APFloat::x87DoubleExtended(),
                    llvm::APFloat::rmNearestTiesToEven, &ignore);
    success = true;
    break;
  }
  }
  break;

case e_double:
  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_float:
    break;
  case e_double:
    success = true;
    break;
  case e_long_double: {
    bool ignore;
    m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
                                : llvm::APFloat::x87DoubleExtended(),
                    llvm::APFloat::rmNearestTiesToEven, &ignore);
    success = true;
    break;
  }
  }
  break;

case e_long_double:
  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_float:
  case e_double:
    break;
  case e_long_double:
    success = true;
    break;
  }
  break;
}

if (success)
  m_type = type;
return success;
1014}

1016const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
switch (type) {
case e_void:
  return "void";
case e_sint:
  return "int";
case e_uint:
  return "unsigned int";
case e_slong:
  return "long";
case e_ulong:
  return "unsigned long";
case e_slonglong:
  return "long long";
case e_ulonglong:
  return "unsigned long long";
case e_float:
  return "float";
case e_double:
  return "double";
case e_long_double:
  return "long double";
case e_sint128:
  return "int128_t";
case e_uint128:
  return "uint128_t";
case e_sint256:
  return "int256_t";
case e_uint256:
  return "uint256_t";
}
return "???";
1048}

1050Scalar::Type
1051Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
if (byte_size <= sizeof(sint_t))
  return e_sint;
if (byte_size <= sizeof(slong_t))
  return e_slong;
if (byte_size <= sizeof(slonglong_t))
  return e_slonglong;
return e_void;
1059}

1061Scalar::Type
1062Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
if (byte_size <= sizeof(uint_t))
  return e_uint;
if (byte_size <= sizeof(ulong_t))
  return e_ulong;
if (byte_size <= sizeof(ulonglong_t))
  return e_ulonglong;
return e_void;
1070}

1072Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
if (byte_size == sizeof(float_t))
  return e_float;
if (byte_size == sizeof(double_t))
  return e_double;
if (byte_size == sizeof(long_double_t))
  return e_long_double;
return e_void;
1080}

1082bool Scalar::MakeSigned() {
bool success = false;

switch (m_type) {
case e_void:
  break;
case e_sint:
  success = true;
  break;
case e_uint:
  m_type = e_sint;
  success = true;
  break;
case e_slong:
  success = true;
  break;
case e_ulong:
  m_type = e_slong;
  success = true;
  break;
case e_slonglong:
  success = true;
  break;
case e_ulonglong:
  m_type = e_slonglong;
  success = true;
  break;
case e_sint128:
  success = true;
  break;
case e_uint128:
  m_type = e_sint128;
  success = true;
  break;
case e_sint256:
  success = true;
  break;
case e_uint256:
  m_type = e_sint256;
  success = true;
  break;
case e_float:
  success = true;
  break;
case e_double:
  success = true;
  break;
case e_long_double:
  success = true;
  break;
}

return success;
1135}

1137bool Scalar::MakeUnsigned() {
bool success = false;

switch (m_type) {
case e_void:
  break;
case e_sint:
  m_type = e_uint;
  success = true;
  break;
case e_uint:
  success = true;
  break;
case e_slong:
  m_type = e_ulong;
  success = true;
  break;
case e_ulong:
  success = true;
  break;
case e_slonglong:
  m_type = e_ulonglong;
  success = true;
  break;
case e_ulonglong:
  success = true;
  break;
case e_sint128:
  m_type = e_uint128;
  success = true;
  break;
case e_uint128:
  success = true;
  break;
case e_sint256:
  m_type = e_uint256;
  success = true;
  break;
case e_uint256:
  success = true;
  break;
case e_float:
  success = true;
  break;
case e_double:
  success = true;
  break;
case e_long_double:
  success = true;
  break;
}

return success;
1190}

1192signed char Scalar::SChar(char 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 (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();
}
return fail_value;
1216}

1218unsigned char Scalar::UChar(unsigned char 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 (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();
}
return fail_value;
1242}

1244short Scalar::SShort(short 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 (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();
  return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
      .getSExtValue();
}
return fail_value;
1270}

1272unsigned short Scalar::UShort(unsigned short 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 (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();
  return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
      .getZExtValue();
}
return fail_value;
1298}

1300int Scalar::SInt(int 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 (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();
}
return fail_value;
1324}

1326unsigned int Scalar::UInt(unsigned int 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 (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();
}
return fail_value;
1350}

1352long Scalar::SLong(long 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 (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();
}
return fail_value;
1376}

1378unsigned long Scalar::ULong(unsigned long 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 (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();
}
return fail_value;
1402}

1404long long Scalar::SLongLong(long long 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 (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();
  return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
      .getSExtValue();
}
return fail_value;
1430}

1432unsigned long long Scalar::ULongLong(unsigned long long 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 (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);
  return (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 fail_value;
1463}

1465llvm::APInt Scalar::SInt128(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;
1486}

1488llvm::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:
  return m_integer;
case e_float:
case e_double:
case e_long_double:
  return m_float.bitcastToAPInt();
}
return fail_value;
1509}

1511llvm::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;
1532}

1534llvm::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:
  return m_integer;
case e_float:
case e_double:
case e_long_double:
  return m_float.bitcastToAPInt();
}
return fail_value;
1555}

1557float 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:
  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();
}
return fail_value;
1581}

1583double Scalar::Double(double 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 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();
}
return fail_value;
1607}

1609long double Scalar::LongDouble(long double 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 (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();
}
return fail_value;
1633}

1635Scalar &Scalar::operator+=(const Scalar &rhs) {
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  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:
    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;
  }
}
return *this;
1665}

1667Scalar &Scalar::operator<<=(const Scalar &rhs) {
switch (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:
  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:
    m_integer = m_integer << rhs.m_integer;
    break;
  }
  break;
}
return *this;
1709}

1711bool Scalar::ShiftRightLogical(const Scalar &rhs) {
switch (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:
  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:
    m_integer = m_integer.lshr(rhs.m_integer);
    break;
  }
  break;
}
return m_type != e_void;
1753}

1755Scalar &Scalar::operator>>=(const Scalar &rhs) {
switch (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:
  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:
    m_integer = m_integer.ashr(rhs.m_integer);
    break;
  }
  break;
}
return *this;
1797}

1799Scalar &Scalar::operator&=(const Scalar &rhs) {
switch (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:
  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:
    m_integer &= rhs.m_integer;
    break;
  }
  break;
}
return *this;
1841}

1843bool Scalar::AbsoluteValue() {
switch (m_type) {
case e_void:
  break;

case e_sint:
case e_slong:
case e_slonglong:
case e_sint128:
case e_sint256:
  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_float:
case e_double:
case e_long_double:
  m_float.clearSign();
  return true;
}
return false;
1870}

1872bool 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:
  m_integer = -m_integer;
  return true;
case e_float:
case e_double:
case e_long_double:
  m_float.changeSign();
  return true;
}
return false;
1895}

1897bool 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:
  m_integer = ~m_integer;
  return true;

case e_void:
case e_float:
case e_double:
case e_long_double:
  break;
}
return false;
1919}

1921const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  case Scalar::e_void:
    break;
  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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;
  }
}
return result;
1951}

1953const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  case Scalar::e_void:
    break;
  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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;
  }
}
return result;
1983}

1985const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  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:
    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:
    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 (!b->m_float.isZero()) {
      result.m_float = a->m_float / b->m_float;
      return result;
    }
    break;
  }
}
// For division only, the only way it should make it here is if a promotion
// failed, or if we are trying to do a divide by zero.
result.m_type = Scalar::e_void;
return result;
2029}

2031const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  case Scalar::e_void:
    break;
  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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;
  }
}
return result;
2061}

2063const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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;
    break;
  }
}
return result;
2093}

2095const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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;
    break;
  }
}
return result;
2126}

2128const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  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:
    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:
    if (b->m_integer != 0) {
      result.m_integer = a->m_integer.urem(b->m_integer);
      return result;
    }
    break;
  }
}
result.m_type = Scalar::e_void;
return result;
2164}

2166const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
Scalar result;
Scalar temp_value;
const Scalar *a;
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
    Scalar::e_void) {
  switch (result.m_type) {
  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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;
    break;
  }
}
return result;
2197}

2199const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
Scalar result = lhs;
result <<= rhs;
return result;
2203}

2205const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
Scalar result = lhs;
result >>= rhs;
return result;
2209}

2211Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
                                 size_t byte_size) {
Status error;
if (value_str == nullptr || value_str[0] == '\0') {
  error.SetErrorString("Invalid c-string value string.");
  return error;
}
switch (encoding) {
case eEncodingInvalid:
  error.SetErrorString("Invalid encoding.");
  break;

case eEncodingUint:
  if (byte_size <= sizeof(uint64_t)) {
    uint64_t uval64;
    if (!llvm::to_integer(value_str, uval64))
      error.SetErrorStringWithFormat(
          "'%s' is not a valid unsigned integer string value", value_str);
    else if (!UIntValueIsValidForSize(uval64, byte_size))
      error.SetErrorStringWithFormat("value 0x%" PRIx64"l" "x"
                                     " is too large to fit in a %" PRIu64"l" "u"
                                     " byte unsigned integer value",
                                     uval64, (uint64_t)byte_size);
    else {
      m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
      switch (m_type) {
      case e_uint:
        m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
        break;
      case e_ulong:
        m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
        break;
      case e_ulonglong:
        m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
        break;
      default:
        error.SetErrorStringWithFormat(
            "unsupported unsigned integer byte size: %" PRIu64"l" "u" "",
            (uint64_t)byte_size);
        break;
      }
    }
  } else {
    error.SetErrorStringWithFormat(
        "unsupported unsigned integer byte size: %" PRIu64"l" "u" "",
        (uint64_t)byte_size);
    return error;
  }
  break;

case eEncodingSint:
  if (byte_size <= sizeof(int64_t)) {
    int64_t sval64;
    if (!llvm::to_integer(value_str, sval64))
      error.SetErrorStringWithFormat(
          "'%s' is not a valid signed integer string value", value_str);
    else if (!SIntValueIsValidForSize(sval64, byte_size))
      error.SetErrorStringWithFormat("value 0x%" PRIx64"l" "x"
                                     " is too large to fit in a %" PRIu64"l" "u"
                                     " byte signed integer value",
                                     sval64, (uint64_t)byte_size);
    else {
      m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
      switch (m_type) {
      case e_sint:
        m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
        break;
      case e_slong:
        m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
        break;
      case e_slonglong:
        m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
        break;
      default:
        error.SetErrorStringWithFormat(
            "unsupported signed integer byte size: %" PRIu64"l" "u" "",
            (uint64_t)byte_size);
        break;
      }
    }
  } else {
    error.SetErrorStringWithFormat(
        "unsupported signed integer byte size: %" PRIu64"l" "u" "",
        (uint64_t)byte_size);
    return error;
  }
  break;

case eEncodingIEEE754:
  static float f_val;
  static double d_val;
  static long double l_val;
  if (byte_size == sizeof(float)) {
    if (::sscanf(value_str, "%f", &f_val) == 1) {
      m_float = llvm::APFloat(f_val);
      m_type = e_float;
    } else
      error.SetErrorStringWithFormat("'%s' is not a valid float string value",
                                     value_str);
  } else if (byte_size == sizeof(double)) {
    if (::sscanf(value_str, "%lf", &d_val) == 1) {
      m_float = llvm::APFloat(d_val);
      m_type = e_double;
    } else
      error.SetErrorStringWithFormat("'%s' is not a valid float string value",
                                     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_INT128128, NUM_OF_WORDS_INT1282,
                                    ((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"l" "u" "",
                                   (uint64_t)byte_size);
    return error;
  }
  break;

case eEncodingVector:
  error.SetErrorString("vector encoding unsupported.");
  break;
}
if (error.Fail())
  m_type = e_void;

return error;
2342}

2344Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
                              size_t byte_size) {
Status error;

type128 int128;
type256 int256;
switch (encoding) {
case lldb::eEncodingInvalid:
  error.SetErrorString("invalid encoding");
  break;
case lldb::eEncodingVector:
  error.SetErrorString("vector encoding unsupported");
  break;
case lldb::eEncodingUint: {
  lldb::offset_t offset = 0;

  switch (byte_size) {
  case 1:
    operator=((uint8_t)data.GetU8(&offset));
    break;
  case 2:
    operator=((uint16_t)data.GetU16(&offset));
    break;
  case 4:
    operator=((uint32_t)data.GetU32(&offset));
    break;
  case 8:
    operator=((uint64_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);
    } else {
      int128.x[0] = (uint64_t)data.GetU64(&offset);
      int128.x[1] = (uint64_t)data.GetU64(&offset);
    }
    operator=(llvm::APInt(BITWIDTH_INT128128, NUM_OF_WORDS_INT1282, 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);
    } 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);
    }
    operator=(llvm::APInt(BITWIDTH_INT256256, NUM_OF_WORDS_INT2564, int256.x));
    break;
  default:
    error.SetErrorStringWithFormat(
        "unsupported unsigned integer byte size: %" PRIu64"l" "u" "",
        (uint64_t)byte_size);
    break;
  }
} break;
case lldb::eEncodingSint: {
  lldb::offset_t offset = 0;

  switch (byte_size) {
  case 1:
    operator=((int8_t)data.GetU8(&offset));
    break;
  case 2:
    operator=((int16_t)data.GetU16(&offset));
    break;
  case 4:
    operator=((int32_t)data.GetU32(&offset));
    break;
  case 8:
    operator=((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);
    } else {
      int128.x[0] = (uint64_t)data.GetU64(&offset);
      int128.x[1] = (uint64_t)data.GetU64(&offset);
    }
    operator=(llvm::APInt(BITWIDTH_INT128128, NUM_OF_WORDS_INT1282, 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);
    } 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);
    }
    operator=(llvm::APInt(BITWIDTH_INT256256, NUM_OF_WORDS_INT2564, int256.x));
    break;
  default:
    error.SetErrorStringWithFormat(
        "unsupported signed integer byte size: %" PRIu64"l" "u" "",
        (uint64_t)byte_size);
    break;
  }
} break;
case lldb::eEncodingIEEE754: {
  lldb::offset_t offset = 0;

  if (byte_size == sizeof(float))
    operator=((float)data.GetFloat(&offset));
  else if (byte_size == sizeof(double))
    operator=((double)data.GetDouble(&offset));
  else if (byte_size == sizeof(long double))
    operator=((long double)data.GetLongDouble(&offset));
  else
    error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64"l" "u" "",
                                   (uint64_t)byte_size);
} break;
}

return error;
2467}

2469bool Scalar::SignExtend(uint32_t sign_bit_pos) {
const uint32_t max_bit_pos = GetByteSize() * 8;

if (sign_bit_pos < max_bit_pos) {
  switch (m_type) {
  case Scalar::e_void:
  case Scalar::e_float:
  case Scalar::e_double:
  case Scalar::e_long_double:
    return false;

  case Scalar::e_sint:
  case Scalar::e_uint:
  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:
    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);
        m_integer |= mask;
      }
      return true;
    }
    break;
  }
}
return false;
2506}

2508size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
                             lldb::ByteOrder dst_byte_order,
                             Status &error) const {
// Get a data extractor that points to the native scalar data
DataExtractor data;
if (!GetData(data)) {
1
Calling 'Scalar::GetData'→
  error.SetErrorString("invalid scalar value");
  return 0;
}

const size_t src_len = data.GetByteSize();

// Prepare a memory buffer that contains some or all of the register value
const size_t bytes_copied =
    data.CopyByteOrderedData(0,               // src offset
                             src_len,         // src length
                             dst,             // dst buffer
                             dst_len,         // dst length
                             dst_byte_order); // dst byte order
if (bytes_copied == 0)
  error.SetErrorString("failed to copy data");

return bytes_copied;
2531}

2533bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
if (bit_size == 0)
  return true;

switch (m_type) {
case Scalar::e_void:
case Scalar::e_float:
case Scalar::e_double:
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:
  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:
  m_integer = m_integer.lshr(bit_offset)
                  .zextOrTrunc(bit_size)
                  .zextOrSelf(8 * GetByteSize());
  return true;
}
return false;
2565}

2567bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
// If either entry is void then we can just compare the types
if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
  return lhs.m_type == rhs.m_type;

Scalar temp_value;
const Scalar *a;
const Scalar *b;
llvm::APFloat::cmpResult result;
switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
case Scalar::e_void:
  break;
case Scalar::e_sint:
case Scalar::e_uint:
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:
  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;
}
return false;
2598}

2600bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
// If either entry is void then we can just compare the types
if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
  return lhs.m_type != rhs.m_type;

Scalar
    temp_value; // A temp value that might get a copy of either promoted value
const Scalar *a;
const Scalar *b;
llvm::APFloat::cmpResult result;
switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
case Scalar::e_void:
  break;
case Scalar::e_sint:
case Scalar::e_uint:
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:
  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;
}
return true;
2632}

2634bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
  return false;

Scalar temp_value;
const Scalar *a;
const Scalar *b;
llvm::APFloat::cmpResult result;
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:
  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:
case Scalar::e_double:
case Scalar::e_long_double:
  result = a->m_float.compare(b->m_float);
  if (result == llvm::APFloat::cmpLessThan)
    return true;
}
return false;
2665}

2667bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
  return false;

Scalar temp_value;
const Scalar *a;
const Scalar *b;
llvm::APFloat::cmpResult result;
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:
  return a->m_integer.sle(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.ule(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::cmpLessThan ||
      result == llvm::APFloat::cmpEqual)
    return true;
}
return false;
2699}

2701bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
  return false;

Scalar temp_value;
const Scalar *a;
const Scalar *b;
llvm::APFloat::cmpResult result;
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:
  return a->m_integer.sgt(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.ugt(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::cmpGreaterThan)
    return true;
}
return false;
2732}

2734bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
  return false;

Scalar temp_value;
const Scalar *a;
const Scalar *b;
llvm::APFloat::cmpResult result;
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:
  return a->m_integer.sge(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.uge(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::cmpGreaterThan ||
      result == llvm::APFloat::cmpEqual)
    return true;
}
return false;
2766}

2768bool Scalar::ClearBit(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:
  m_integer.clearBit(bit);
  return true;
case e_float:
case e_double:
case e_long_double:
  break;
}
return false;
2790}

2792bool 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:
  m_integer.setBit(bit);
  return true;
case e_float:
case e_double:
case e_long_double:
  break;
}
return false;
2814}