mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-05-15 18:36:27 +00:00
b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
3077 lines
74 KiB
C++
3077 lines
74 KiB
C++
//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Core/Scalar.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <cinttypes>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
|
|
// Other libraries and framework includes
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
// Project includes
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Host/Endian.h"
|
|
#include "lldb/Host/StringConvert.h"
|
|
#include "lldb/Interpreter/Args.h"
|
|
|
|
#include "Plugins/Process/Utility/InstructionUtils.h"
|
|
|
|
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((float)0) {}
|
|
|
|
Scalar::Scalar(const Scalar &rhs)
|
|
: m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
|
|
|
|
// Scalar::Scalar(const RegisterValue& reg) :
|
|
// m_type(e_void),
|
|
// m_data()
|
|
//{
|
|
// switch (reg.info.encoding)
|
|
// {
|
|
// case eEncodingUint: // unsigned integer
|
|
// switch (reg.info.byte_size)
|
|
// {
|
|
// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
|
|
// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
|
|
// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
|
|
// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64;
|
|
// break;
|
|
// break;
|
|
// }
|
|
// break;
|
|
//
|
|
// case eEncodingSint: // signed integer
|
|
// switch (reg.info.byte_size)
|
|
// {
|
|
// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
|
|
// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
|
|
// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
|
|
// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64;
|
|
// break;
|
|
// break;
|
|
// }
|
|
// break;
|
|
//
|
|
// case eEncodingIEEE754: // float
|
|
// switch (reg.info.byte_size)
|
|
// {
|
|
// case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
|
|
// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
|
|
// break;
|
|
// }
|
|
// break;
|
|
// case eEncodingVector: // vector registers
|
|
// break;
|
|
// }
|
|
//}
|
|
|
|
bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
|
|
size_t byte_size = GetByteSize();
|
|
if (byte_size > 0) {
|
|
const uint8_t *bytes = reinterpret_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[4];
|
|
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;
|
|
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) {
|
|
swapped_words[0] = apint_words[1];
|
|
swapped_words[1] = apint_words[0];
|
|
apint_words = swapped_words;
|
|
}
|
|
return reinterpret_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:
|
|
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:
|
|
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:
|
|
s->PutCString(m_integer.toString(10, true).c_str());
|
|
break;
|
|
case e_uint:
|
|
case e_ulong:
|
|
case e_ulonglong:
|
|
case e_uint128:
|
|
case e_uint256:
|
|
s->PutCString(m_integer.toString(10, false).c_str());
|
|
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_float:
|
|
return "float";
|
|
case e_double:
|
|
return "double";
|
|
case e_long_double:
|
|
return "long double";
|
|
}
|
|
return "<invalid Scalar type>";
|
|
}
|
|
|
|
Scalar &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;
|
|
}
|
|
|
|
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, ((type128 *)&v)->x));
|
|
else
|
|
m_float = llvm::APFloat(
|
|
llvm::APFloat::x87DoubleExtended,
|
|
llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((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;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Scalar::~Scalar() = default;
|
|
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
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((float_t)m_float.convertToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float =
|
|
llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended,
|
|
m_float.bitcastToAPInt());
|
|
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:
|
|
if (m_ieee_quad)
|
|
m_float =
|
|
llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended,
|
|
m_float.bitcastToAPInt());
|
|
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;
|
|
}
|
|
|
|
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";
|
|
}
|
|
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::Cast(Scalar::Type type) {
|
|
bool success = false;
|
|
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:
|
|
switch (type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_uint:
|
|
m_integer = m_integer.zextOrTrunc(sizeof(sint_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.zextOrTrunc(sizeof(slong_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.zextOrTrunc(sizeof(slonglong_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint128:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_uint128:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_uint256:
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(m_integer.bitsToFloat());
|
|
success = true;
|
|
break;
|
|
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_integer.bitsToDouble());
|
|
success = true;
|
|
break;
|
|
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
|
|
success = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case e_float:
|
|
switch (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_float.bitcastToAPInt();
|
|
success = true;
|
|
break;
|
|
case e_float:
|
|
m_float = llvm::APFloat(m_float.convertToFloat());
|
|
success = true;
|
|
break;
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_float.convertToFloat());
|
|
success = true;
|
|
break;
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float =
|
|
llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended,
|
|
m_float.bitcastToAPInt());
|
|
success = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case e_double:
|
|
switch (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_float.bitcastToAPInt();
|
|
success = true;
|
|
break;
|
|
case e_float:
|
|
m_float = llvm::APFloat(m_float.convertToDouble());
|
|
success = true;
|
|
break;
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_float.convertToDouble());
|
|
success = true;
|
|
break;
|
|
case e_long_double:
|
|
if (m_ieee_quad)
|
|
m_float =
|
|
llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended,
|
|
m_float.bitcastToAPInt());
|
|
success = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case e_long_double:
|
|
switch (type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_uint:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_slong:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_ulong:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_slonglong:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_ulonglong:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint128:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_uint128:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
|
|
success = true;
|
|
break;
|
|
|
|
case e_sint256:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_uint256:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
|
|
success = true;
|
|
break;
|
|
|
|
case e_float:
|
|
m_float = llvm::APFloat(m_float.convertToFloat());
|
|
success = true;
|
|
break;
|
|
case e_double:
|
|
m_float = llvm::APFloat(m_float.convertToFloat());
|
|
success = true;
|
|
break;
|
|
case e_long_double:
|
|
success = true;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (success)
|
|
m_type = type;
|
|
return success;
|
|
}
|
|
|
|
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_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:
|
|
success = true;
|
|
break;
|
|
case e_uint:
|
|
m_type = e_uint;
|
|
success = true;
|
|
break;
|
|
case e_slong:
|
|
success = true;
|
|
break;
|
|
case e_ulong:
|
|
m_type = e_ulong;
|
|
success = true;
|
|
break;
|
|
case e_slonglong:
|
|
success = true;
|
|
break;
|
|
case e_ulonglong:
|
|
m_type = e_ulonglong;
|
|
success = true;
|
|
break;
|
|
case e_sint128:
|
|
success = true;
|
|
break;
|
|
case e_uint128:
|
|
m_type = e_uint128;
|
|
success = true;
|
|
break;
|
|
case e_sint256:
|
|
success = true;
|
|
break;
|
|
case e_uint256:
|
|
m_type = 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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
|
|
.getZExtValue();
|
|
case e_float:
|
|
return (ulonglong_t)m_float.convertToFloat();
|
|
case e_double:
|
|
return (ulonglong_t)m_float.convertToDouble();
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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:
|
|
return m_integer;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
return m_float.bitcastToAPInt();
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
return m_integer;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
return m_float.bitcastToAPInt();
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
|
|
switch (m_type) {
|
|
case e_void:
|
|
break;
|
|
case e_sint:
|
|
case e_uint:
|
|
case e_slong:
|
|
case e_ulong:
|
|
case e_slonglong:
|
|
case e_ulonglong:
|
|
case e_sint128:
|
|
case e_uint128:
|
|
case e_sint256:
|
|
case e_uint256:
|
|
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:
|
|
return m_integer.bitsToFloat();
|
|
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;
|
|
}
|
|
|
|
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:
|
|
return m_integer.bitsToDouble();
|
|
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;
|
|
}
|
|
|
|
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:
|
|
return (long_double_t)m_integer.bitsToDouble();
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
Error Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
|
|
size_t byte_size) {
|
|
Error error;
|
|
if (value_str == nullptr || value_str[0] == '\0') {
|
|
error.SetErrorString("Invalid c-string value string.");
|
|
return error;
|
|
}
|
|
bool success = false;
|
|
switch (encoding) {
|
|
case eEncodingInvalid:
|
|
error.SetErrorString("Invalid encoding.");
|
|
break;
|
|
|
|
case eEncodingUint:
|
|
if (byte_size <= sizeof(unsigned long long)) {
|
|
uint64_t uval64 =
|
|
StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
|
|
if (!success)
|
|
error.SetErrorStringWithFormat(
|
|
"'%s' is not a valid unsigned integer string value", value_str);
|
|
else if (!UIntValueIsValidForSize(uval64, byte_size))
|
|
error.SetErrorStringWithFormat("value 0x%" PRIx64
|
|
" is too large to fit in a %" PRIu64
|
|
" byte unsigned integer value",
|
|
uval64, (uint64_t)byte_size);
|
|
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 "",
|
|
(uint64_t)byte_size);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"unsupported unsigned integer byte size: %" PRIu64 "",
|
|
(uint64_t)byte_size);
|
|
return error;
|
|
}
|
|
break;
|
|
|
|
case eEncodingSint:
|
|
if (byte_size <= sizeof(long long)) {
|
|
uint64_t sval64 =
|
|
StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
|
|
if (!success)
|
|
error.SetErrorStringWithFormat(
|
|
"'%s' is not a valid signed integer string value", value_str);
|
|
else if (!SIntValueIsValidForSize(sval64, byte_size))
|
|
error.SetErrorStringWithFormat("value 0x%" PRIx64
|
|
" is too large to fit in a %" PRIu64
|
|
" byte signed integer value",
|
|
sval64, (uint64_t)byte_size);
|
|
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 "",
|
|
(uint64_t)byte_size);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"unsupported signed integer byte size: %" PRIu64 "",
|
|
(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,
|
|
((type128 *)&l_val)->x));
|
|
m_type = e_long_double;
|
|
} else
|
|
error.SetErrorStringWithFormat("'%s' is not a valid float string value",
|
|
value_str);
|
|
} else {
|
|
error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
|
|
(uint64_t)byte_size);
|
|
return error;
|
|
}
|
|
break;
|
|
|
|
case eEncodingVector:
|
|
error.SetErrorString("vector encoding unsupported.");
|
|
break;
|
|
}
|
|
if (error.Fail())
|
|
m_type = e_void;
|
|
|
|
return error;
|
|
}
|
|
|
|
Error Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
|
|
size_t byte_size) {
|
|
Error 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_INT128, NUM_OF_WORDS_INT128, int128.x));
|
|
break;
|
|
case 32:
|
|
if (data.GetByteOrder() == eByteOrderBig) {
|
|
int256.x[3] = (uint64_t)data.GetU64(&offset);
|
|
int256.x[2] = (uint64_t)data.GetU64(&offset);
|
|
int256.x[1] = (uint64_t)data.GetU64(&offset);
|
|
int256.x[0] = (uint64_t)data.GetU64(&offset);
|
|
} 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_INT256, NUM_OF_WORDS_INT256, int256.x));
|
|
break;
|
|
default:
|
|
error.SetErrorStringWithFormat(
|
|
"unsupported unsigned integer byte size: %" PRIu64 "",
|
|
(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_INT128, NUM_OF_WORDS_INT128, int128.x));
|
|
break;
|
|
case 32:
|
|
if (data.GetByteOrder() == eByteOrderBig) {
|
|
int256.x[3] = (uint64_t)data.GetU64(&offset);
|
|
int256.x[2] = (uint64_t)data.GetU64(&offset);
|
|
int256.x[1] = (uint64_t)data.GetU64(&offset);
|
|
int256.x[0] = (uint64_t)data.GetU64(&offset);
|
|
} 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_INT256, NUM_OF_WORDS_INT256, int256.x));
|
|
break;
|
|
default:
|
|
error.SetErrorStringWithFormat(
|
|
"unsupported signed integer byte size: %" PRIu64 "",
|
|
(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 "",
|
|
(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:
|
|
if (max_bit_pos == sign_bit_pos)
|
|
return true;
|
|
else if (sign_bit_pos < (max_bit_pos - 1)) {
|
|
llvm::APInt sign_bit = llvm::APInt::getSignBit(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,
|
|
Error &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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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) {
|
|
// 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;
|
|
}
|
|
|
|
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:
|
|
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) {
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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;
|
|
}
|
|
|
|
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:
|
|
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:
|
|
m_integer.setBit(bit);
|
|
return true;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|