forked from OSchip/llvm-project
2900 lines
72 KiB
C++
2900 lines
72 KiB
C++
//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Utility/Scalar.h"
|
|
|
|
#include "lldb/Utility/DataExtractor.h"
|
|
#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"
|
|
|
|
#include <cinttypes>
|
|
#include <cstdio>
|
|
|
|
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
|
|
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)
|
|
) {
|
|
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;
|
|
}
|
|
|
|
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();
|
|
if (byte_size > 0) {
|
|
const uint8_t *bytes = static_cast<const uint8_t *>(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;
|
|
}
|
|
|
|
const void *Scalar::GetBytes() const {
|
|
const uint64_t *apint_words;
|
|
const uint8_t *bytes;
|
|
static float_t flt_val;
|
|
static double_t dbl_val;
|
|
static uint64_t swapped_words[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:
|
|
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;
|
|
// 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();
|
|
if (endian::InlHostByteOrder() == eByteOrderBig) {
|
|
swapped_words[0] = apint_words[1];
|
|
swapped_words[1] = apint_words[0];
|
|
apint_words = swapped_words;
|
|
}
|
|
return static_cast<const void *>(apint_words);
|
|
case e_sint256:
|
|
case e_uint256:
|
|
apint_words = m_integer.getRawData();
|
|
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 static_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 static_cast<const void *>(apint_words);
|
|
case e_float:
|
|
flt_val = m_float.convertToFloat();
|
|
return static_cast<const void *>(&flt_val);
|
|
case e_double:
|
|
dbl_val = m_float.convertToDouble();
|
|
return static_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) {
|
|
swapped_words[0] = apint_words[1];
|
|
swapped_words[1] = apint_words[0];
|
|
apint_words = swapped_words;
|
|
}
|
|
return static_cast<const void *>(apint_words);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
size_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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return (m_integer.getBitWidth() / 8);
|
|
case e_float:
|
|
return sizeof(float_t);
|
|
case e_double:
|
|
return sizeof(double_t);
|
|
case e_long_double:
|
|
return sizeof(long_double_t);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool 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:
|
|
case e_uint512:
|
|
case e_sint512:
|
|
return llvm::APInt::isSameValue(zero_int, m_integer);
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
return m_float.isZero();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Scalar::GetValue(Stream *s, bool show_type) const {
|
|
if (show_type)
|
|
s->Printf("(%s) ", GetTypeAsCString());
|
|
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_slong:
|
|
case e_slonglong:
|
|
case e_sint128:
|
|
case e_sint256:
|
|
case e_sint512:
|
|
s->PutCString(m_integer.toString(10, true));
|
|
break;
|
|
case e_uint:
|
|
case e_ulong:
|
|
case e_ulonglong:
|
|
case e_uint128:
|
|
case e_uint256:
|
|
case e_uint512:
|
|
s->PutCString(m_integer.toString(10, false));
|
|
break;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
llvm::SmallString<24> string;
|
|
m_float.toString(string);
|
|
s->Printf("%s", string.c_str());
|
|
break;
|
|
}
|
|
}
|
|
|
|
const 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_sint512:
|
|
return "int512_t";
|
|
case e_uint512:
|
|
return "unsigned int512_t";
|
|
case e_float:
|
|
return "float";
|
|
case e_double:
|
|
return "double";
|
|
case e_long_double:
|
|
return "long double";
|
|
}
|
|
return "<invalid Scalar type>";
|
|
}
|
|
|
|
Scalar &Scalar::operator=(const int v) {
|
|
m_type = e_sint;
|
|
m_integer = llvm::APInt(sizeof(int) * 8, v, true);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(unsigned int v) {
|
|
m_type = e_uint;
|
|
m_integer = llvm::APInt(sizeof(int) * 8, v);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(long v) {
|
|
m_type = e_slong;
|
|
m_integer = llvm::APInt(sizeof(long) * 8, v, true);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(unsigned long v) {
|
|
m_type = e_ulong;
|
|
m_integer = llvm::APInt(sizeof(long) * 8, v);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(long long v) {
|
|
m_type = e_slonglong;
|
|
m_integer = llvm::APInt(sizeof(long) * 8, v, true);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(unsigned long long v) {
|
|
m_type = e_ulonglong;
|
|
m_integer = llvm::APInt(sizeof(long long) * 8, v);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(float v) {
|
|
m_type = e_float;
|
|
m_float = llvm::APFloat(v);
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator=(double v) {
|
|
m_type = e_double;
|
|
m_float = llvm::APFloat(v);
|
|
return *this;
|
|
}
|
|
|
|
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,
|
|
(reinterpret_cast<type128 *>(&v))->x));
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
|
|
llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
|
|
(reinterpret_cast<type128 *>(&v))->x));
|
|
return *this;
|
|
}
|
|
|
|
Scalar &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_INT128))
|
|
m_type = e_sint128;
|
|
else
|
|
m_type = e_uint128;
|
|
break;
|
|
case 256:
|
|
if (m_integer.isSignedIntN(BITWIDTH_INT256))
|
|
m_type = e_sint256;
|
|
else
|
|
m_type = e_uint256;
|
|
break;
|
|
case 512:
|
|
if (m_integer.isSignedIntN(BITWIDTH_INT512))
|
|
m_type = e_sint512;
|
|
else
|
|
m_type = e_uint512;
|
|
break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Scalar::~Scalar() = default;
|
|
|
|
Scalar::Type Scalar::GetBestTypeForBitSize(size_t bit_size, bool sign) {
|
|
// Scalar types are always host types, hence the sizeof().
|
|
if (sign) {
|
|
if (bit_size <= sizeof(int)*8) return Scalar::e_sint;
|
|
if (bit_size <= sizeof(long)*8) return Scalar::e_slong;
|
|
if (bit_size <= sizeof(long long)*8) return Scalar::e_slonglong;
|
|
if (bit_size <= 128) return Scalar::e_sint128;
|
|
if (bit_size <= 256) return Scalar::e_sint256;
|
|
if (bit_size <= 512) return Scalar::e_sint512;
|
|
} else {
|
|
if (bit_size <= sizeof(unsigned int)*8) return Scalar::e_uint;
|
|
if (bit_size <= sizeof(unsigned long)*8) return Scalar::e_ulong;
|
|
if (bit_size <= sizeof(unsigned long long)*8) return Scalar::e_ulonglong;
|
|
if (bit_size <= 128) return Scalar::e_uint128;
|
|
if (bit_size <= 256) return Scalar::e_uint256;
|
|
if (bit_size <= 512) return Scalar::e_uint512;
|
|
}
|
|
return Scalar::e_void;
|
|
}
|
|
|
|
void Scalar::TruncOrExtendTo(Scalar::Type type, uint16_t bits) {
|
|
switch (type) {
|
|
case e_sint:
|
|
case e_slong:
|
|
case e_slonglong:
|
|
case e_sint128:
|
|
case e_sint256:
|
|
case e_sint512:
|
|
m_integer = m_integer.sextOrTrunc(bits);
|
|
break;
|
|
case e_uint:
|
|
case e_ulong:
|
|
case e_ulonglong:
|
|
case e_uint128:
|
|
case e_uint256:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(bits);
|
|
break;
|
|
default:
|
|
llvm_unreachable("Promoting a Scalar to a specific number of bits is only "
|
|
"supported for integer types.");
|
|
}
|
|
m_type = type;
|
|
}
|
|
|
|
bool 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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, true,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, true,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, true,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
case e_uint256:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, true,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, true,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
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_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
|
|
: llvm::APFloat::x87DoubleExtended());
|
|
m_float.convertFromAPInt(m_integer, false,
|
|
llvm::APFloat::rmNearestTiesToEven);
|
|
success = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case e_sint512:
|
|
case e_uint512:
|
|
lldbassert(false && "unimplemented");
|
|
break;
|
|
|
|
case e_float:
|
|
switch (type) {
|
|
case e_void:
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_uint512:
|
|
case e_sint512:
|
|
break;
|
|
case e_float:
|
|
success = true;
|
|
break;
|
|
case e_double:
|
|
m_float = llvm::APFloat(static_cast<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_sint512:
|
|
case e_uint512:
|
|
case e_float:
|
|
break;
|
|
case e_double:
|
|
success = true;
|
|
break;
|
|
case e_long_double: {
|
|
bool ignore;
|
|
m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
|
|
: 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_sint512:
|
|
case e_uint512:
|
|
case e_float:
|
|
case e_double:
|
|
break;
|
|
case e_long_double:
|
|
success = true;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (success)
|
|
m_type = type;
|
|
return success;
|
|
}
|
|
|
|
const 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";
|
|
case e_sint512:
|
|
return "int512_t";
|
|
case e_uint512:
|
|
return "uint512_t";
|
|
}
|
|
return "???";
|
|
}
|
|
|
|
Scalar::Type
|
|
Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
|
|
if (byte_size <= sizeof(sint_t))
|
|
return e_sint;
|
|
if (byte_size <= sizeof(slong_t))
|
|
return e_slong;
|
|
if (byte_size <= sizeof(slonglong_t))
|
|
return e_slonglong;
|
|
return e_void;
|
|
}
|
|
|
|
Scalar::Type
|
|
Scalar::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;
|
|
}
|
|
|
|
Scalar::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;
|
|
}
|
|
|
|
bool 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_sint512:
|
|
success = true;
|
|
break;
|
|
case e_uint512:
|
|
m_type = e_sint512;
|
|
success = true;
|
|
break;
|
|
case e_float:
|
|
success = true;
|
|
break;
|
|
case e_double:
|
|
success = true;
|
|
break;
|
|
case e_long_double:
|
|
success = true;
|
|
break;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
bool 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_sint512:
|
|
m_type = e_uint512;
|
|
success = true;
|
|
break;
|
|
case e_uint512:
|
|
success = true;
|
|
break;
|
|
case e_float:
|
|
success = true;
|
|
break;
|
|
case e_double:
|
|
success = true;
|
|
break;
|
|
case e_long_double:
|
|
success = true;
|
|
break;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
signed 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<schar_t>(
|
|
(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
|
|
case e_float:
|
|
return static_cast<schar_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<schar_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<schar_t>(
|
|
(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
unsigned 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<uchar_t>(
|
|
(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
|
|
case e_float:
|
|
return static_cast<uchar_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<uchar_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<uchar_t>(
|
|
(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
short 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<sshort_t>(
|
|
(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
|
|
case e_float:
|
|
return static_cast<sshort_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<sshort_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<sshort_t>(
|
|
(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
unsigned 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<ushort_t>(
|
|
(m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
|
|
case e_float:
|
|
return static_cast<ushort_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<ushort_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<ushort_t>(
|
|
(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
int 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<sint_t>(
|
|
(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
|
|
case e_float:
|
|
return static_cast<sint_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<sint_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<sint_t>(
|
|
(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
unsigned 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<uint_t>(
|
|
(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
|
|
case e_float:
|
|
return static_cast<uint_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<uint_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<uint_t>(
|
|
(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
long 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<slong_t>(
|
|
(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
|
|
case e_float:
|
|
return static_cast<slong_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<slong_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<slong_t>(
|
|
(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
unsigned 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<ulong_t>(
|
|
(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
|
|
case e_float:
|
|
return static_cast<ulong_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<ulong_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<ulong_t>(
|
|
(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
long 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<slonglong_t>(
|
|
(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
|
|
case e_float:
|
|
return static_cast<slonglong_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<slonglong_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<slonglong_t>(
|
|
(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
unsigned 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<ulonglong_t>(
|
|
(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
|
|
case e_float:
|
|
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 static_cast<ulonglong_t>(
|
|
(rounded_double.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
|
|
}
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<ulonglong_t>(
|
|
(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
llvm::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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return m_integer;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
return m_float.bitcastToAPInt();
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return m_integer;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
return m_float.bitcastToAPInt();
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
float Scalar::Float(float fail_value) const {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return llvm::APIntOps::RoundAPIntToFloat(m_integer);
|
|
case e_float:
|
|
return m_float.convertToFloat();
|
|
case e_double:
|
|
return static_cast<float_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return ldbl_val.bitsToFloat();
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
double 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return llvm::APIntOps::RoundAPIntToDouble(m_integer);
|
|
case e_float:
|
|
return static_cast<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;
|
|
}
|
|
|
|
long 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
return static_cast<long_double_t>(
|
|
llvm::APIntOps::RoundAPIntToDouble(m_integer));
|
|
case e_float:
|
|
return static_cast<long_double_t>(m_float.convertToFloat());
|
|
case e_double:
|
|
return static_cast<long_double_t>(m_float.convertToDouble());
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return static_cast<long_double_t>(ldbl_val.bitsToDouble());
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
Scalar &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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = a->m_integer + b->m_integer;
|
|
break;
|
|
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_float = a->m_float + b->m_float;
|
|
break;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Scalar &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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
switch (rhs.m_type) {
|
|
case e_void:
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_type = e_void;
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer << rhs.m_integer;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool Scalar::ShiftRightLogical(const Scalar &rhs) {
|
|
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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
switch (rhs.m_type) {
|
|
case e_void:
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_type = e_void;
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.lshr(rhs.m_integer);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return m_type != e_void;
|
|
}
|
|
|
|
Scalar &Scalar::operator>>=(const Scalar &rhs) {
|
|
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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
switch (rhs.m_type) {
|
|
case e_void:
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_type = e_void;
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = m_integer.ashr(rhs.m_integer);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Scalar &Scalar::operator&=(const Scalar &rhs) {
|
|
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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
switch (rhs.m_type) {
|
|
case e_void:
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_type = e_void;
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer &= rhs.m_integer;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool Scalar::AbsoluteValue() {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
|
|
case e_sint:
|
|
case e_slong:
|
|
case e_slonglong:
|
|
case e_sint128:
|
|
case e_sint256:
|
|
case e_sint512:
|
|
if (m_integer.isNegative())
|
|
m_integer = -m_integer;
|
|
return true;
|
|
|
|
case e_uint:
|
|
case e_ulong:
|
|
case e_ulonglong:
|
|
return true;
|
|
case e_uint128:
|
|
case e_uint256:
|
|
case e_uint512:
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_float.clearSign();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Scalar::UnaryNegate() {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = -m_integer;
|
|
return true;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
m_float.changeSign();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Scalar::OnesComplement() {
|
|
switch (m_type) {
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer = ~m_integer;
|
|
return true;
|
|
|
|
case e_void:
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
result.m_integer = a->m_integer + b->m_integer;
|
|
break;
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
result.m_float = a->m_float + b->m_float;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
result.m_integer = a->m_integer - b->m_integer;
|
|
break;
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
result.m_float = a->m_float - b->m_float;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
if (b->m_integer != 0) {
|
|
result.m_integer = a->m_integer.sdiv(b->m_integer);
|
|
return result;
|
|
}
|
|
break;
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
case Scalar::e_uint256:
|
|
case Scalar::e_uint512:
|
|
if (b->m_integer != 0) {
|
|
result.m_integer = a->m_integer.udiv(b->m_integer);
|
|
return result;
|
|
}
|
|
break;
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
if (!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;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
result.m_integer = a->m_integer * b->m_integer;
|
|
break;
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
result.m_float = a->m_float * b->m_float;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
result.m_integer = a->m_integer & b->m_integer;
|
|
break;
|
|
case Scalar::e_void:
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
// No bitwise AND on floats, doubles of long doubles
|
|
result.m_type = Scalar::e_void;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
result.m_integer = a->m_integer | b->m_integer;
|
|
break;
|
|
|
|
case Scalar::e_void:
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
// No bitwise AND on floats, doubles of long doubles
|
|
result.m_type = Scalar::e_void;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
if (b->m_integer != 0) {
|
|
result.m_integer = a->m_integer.srem(b->m_integer);
|
|
return result;
|
|
}
|
|
break;
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
case Scalar::e_uint256:
|
|
case Scalar::e_uint512:
|
|
if (b->m_integer != 0) {
|
|
result.m_integer = a->m_integer.urem(b->m_integer);
|
|
return result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
result.m_type = Scalar::e_void;
|
|
return result;
|
|
}
|
|
|
|
const 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
result.m_integer = a->m_integer ^ b->m_integer;
|
|
break;
|
|
|
|
case Scalar::e_void:
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
// No bitwise AND on floats, doubles of long doubles
|
|
result.m_type = Scalar::e_void;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
|
|
Scalar result = lhs;
|
|
result <<= rhs;
|
|
return result;
|
|
}
|
|
|
|
const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
|
|
Scalar result = lhs;
|
|
result >>= rhs;
|
|
return result;
|
|
}
|
|
|
|
Status 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 " 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) {
|
|
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 "",
|
|
static_cast<uint64_t>(byte_size));
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"unsupported unsigned integer byte size: %" PRIu64 "",
|
|
static_cast<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 " 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) {
|
|
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 "",
|
|
static_cast<uint64_t>(byte_size));
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"unsupported signed integer byte size: %" PRIu64 "",
|
|
static_cast<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_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 "",
|
|
static_cast<uint64_t>(byte_size));
|
|
return error;
|
|
}
|
|
break;
|
|
|
|
case eEncodingVector:
|
|
error.SetErrorString("vector encoding unsupported.");
|
|
break;
|
|
}
|
|
if (error.Fail())
|
|
m_type = e_void;
|
|
|
|
return error;
|
|
}
|
|
|
|
Status 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=(data.GetU8(&offset));
|
|
break;
|
|
case 2:
|
|
operator=(data.GetU16(&offset));
|
|
break;
|
|
case 4:
|
|
operator=(data.GetU32(&offset));
|
|
break;
|
|
case 8:
|
|
operator=(data.GetU64(&offset));
|
|
break;
|
|
case 16:
|
|
if (data.GetByteOrder() == eByteOrderBig) {
|
|
int128.x[1] = data.GetU64(&offset);
|
|
int128.x[0] = data.GetU64(&offset);
|
|
} else {
|
|
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] = 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] = 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 "",
|
|
static_cast<uint64_t>(byte_size));
|
|
break;
|
|
}
|
|
} break;
|
|
case lldb::eEncodingSint: {
|
|
lldb::offset_t offset = 0;
|
|
|
|
switch (byte_size) {
|
|
case 1:
|
|
operator=(static_cast<int8_t>(data.GetU8(&offset)));
|
|
break;
|
|
case 2:
|
|
operator=(static_cast<int16_t>(data.GetU16(&offset)));
|
|
break;
|
|
case 4:
|
|
operator=(static_cast<int32_t>(data.GetU32(&offset)));
|
|
break;
|
|
case 8:
|
|
operator=(static_cast<int64_t>(data.GetU64(&offset)));
|
|
break;
|
|
case 16:
|
|
if (data.GetByteOrder() == eByteOrderBig) {
|
|
int128.x[1] = data.GetU64(&offset);
|
|
int128.x[0] = data.GetU64(&offset);
|
|
} else {
|
|
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] = 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] = 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 "",
|
|
static_cast<uint64_t>(byte_size));
|
|
break;
|
|
}
|
|
} break;
|
|
case lldb::eEncodingIEEE754: {
|
|
lldb::offset_t offset = 0;
|
|
|
|
if (byte_size == sizeof(float))
|
|
operator=(data.GetFloat(&offset));
|
|
else if (byte_size == sizeof(double))
|
|
operator=(data.GetDouble(&offset));
|
|
else if (byte_size == sizeof(long double))
|
|
operator=(data.GetLongDouble(&offset));
|
|
else
|
|
error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
|
|
static_cast<uint64_t>(byte_size));
|
|
} break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
bool 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
if (max_bit_pos == sign_bit_pos)
|
|
return true;
|
|
else if (sign_bit_pos < (max_bit_pos - 1)) {
|
|
llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
|
|
llvm::APInt bitwize_and = m_integer & sign_bit;
|
|
if (bitwize_and.getBoolValue()) {
|
|
const llvm::APInt mask =
|
|
~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
|
|
m_integer |= mask;
|
|
}
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_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)) {
|
|
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;
|
|
}
|
|
|
|
bool 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:
|
|
case Scalar::e_sint512:
|
|
m_integer = m_integer.ashr(bit_offset)
|
|
.sextOrTrunc(bit_size)
|
|
.sextOrSelf(8 * GetByteSize());
|
|
return true;
|
|
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
case Scalar::e_uint256:
|
|
case Scalar::e_uint512:
|
|
m_integer = m_integer.lshr(bit_offset)
|
|
.zextOrTrunc(bit_size)
|
|
.zextOrSelf(8 * GetByteSize());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
|
|
// 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
return a->m_integer == b->m_integer;
|
|
case Scalar::e_float:
|
|
case Scalar::e_double:
|
|
case Scalar::e_long_double:
|
|
result = a->m_float.compare(b->m_float);
|
|
if (result == llvm::APFloat::cmpEqual)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
bool 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:
|
|
case Scalar::e_sint512:
|
|
case Scalar::e_uint512:
|
|
return a->m_integer.slt(b->m_integer);
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
case Scalar::e_uint256:
|
|
return a->m_integer.ult(b->m_integer);
|
|
case Scalar::e_float:
|
|
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;
|
|
}
|
|
|
|
bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
|
|
return !(rhs < lhs);
|
|
}
|
|
|
|
bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
|
|
return rhs < lhs;
|
|
}
|
|
|
|
bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
|
|
return !(lhs < rhs);
|
|
}
|
|
|
|
bool 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:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer.clearBit(bit);
|
|
return true;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Scalar::SetBit(uint32_t bit) {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
case e_sint512:
|
|
case e_uint512:
|
|
m_integer.setBit(bit);
|
|
return true;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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();
|
|
}
|