2976 lines
84 KiB
C++
2976 lines
84 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"
|
|
|
|
#include <math.h>
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
|
|
#include "lldb/Interpreter/Args.h"
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Host/Endian.h"
|
|
#include "lldb/Host/StringConvert.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 constructor
|
|
//----------------------------------------------------------------------
|
|
Scalar::Scalar() :
|
|
m_type(e_void),
|
|
m_float((float)0)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Scalar copy constructor
|
|
//----------------------------------------------------------------------
|
|
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();
|
|
static float f_val;
|
|
static double d_val;
|
|
if (byte_size > 0)
|
|
{
|
|
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...
|
|
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:
|
|
data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_float:
|
|
f_val = m_float.convertToFloat();
|
|
data.SetData((uint8_t *)&f_val, limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_double:
|
|
d_val = m_float.convertToDouble();
|
|
data.SetData((uint8_t *)&d_val, limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_long_double:
|
|
static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
data.SetData((const uint8_t *)ldbl_val.getRawData(), limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
}
|
|
}
|
|
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
|
|
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:
|
|
data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_float:
|
|
f_val = m_float.convertToFloat();
|
|
data.SetData((uint8_t *)&f_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_double:
|
|
d_val = m_float.convertToDouble();
|
|
data.SetData((uint8_t *)&d_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_long_double:
|
|
static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
data.SetData((const uint8_t *)ldbl_val.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We want all of the data
|
|
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:
|
|
data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_float:
|
|
f_val = m_float.convertToFloat();
|
|
data.SetData((uint8_t *)&f_val, byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_double:
|
|
d_val = m_float.convertToDouble();
|
|
data.SetData((uint8_t *)&d_val, byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
case e_long_double:
|
|
static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
data.SetData((const uint8_t *)ldbl_val.getRawData(), byte_size, endian::InlHostByteOrder());
|
|
return true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
data.Clear();
|
|
return false;
|
|
}
|
|
|
|
void *
|
|
Scalar::GetBytes() const
|
|
{
|
|
static float_t flt_val;
|
|
static double_t dbl_val;
|
|
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:
|
|
return const_cast<void *>(reinterpret_cast<const void *>(m_integer.getRawData()));
|
|
case e_float:
|
|
flt_val = m_float.convertToFloat();
|
|
return (void *)&flt_val;
|
|
case e_double:
|
|
dbl_val = m_float.convertToDouble();
|
|
return (void *)&dbl_val;
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return const_cast<void *>(reinterpret_cast<const void *>(ldbl_val.getRawData()));
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
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: 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:
|
|
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
|
|
{
|
|
const uint64_t *src;
|
|
if (show_type)
|
|
s->Printf("(%s) ", GetTypeAsCString());
|
|
|
|
switch (m_type)
|
|
{
|
|
case e_void:
|
|
break;
|
|
case e_sint: s->Printf("%i", *(const sint_t *) m_integer.getRawData()); break;
|
|
case e_uint: s->Printf("0x%8.8x", *(const uint_t *) m_integer.getRawData()); break;
|
|
case e_slong: s->Printf("%li", *(const slong_t *) m_integer.getRawData()); break;
|
|
case e_ulong: s->Printf("0x%8.8lx", *(const ulong_t *) m_integer.getRawData()); break;
|
|
case e_slonglong: s->Printf("%lli", *(const slonglong_t *) m_integer.getRawData()); break;
|
|
case e_ulonglong: s->Printf("0x%16.16llx", *(const ulonglong_t *) m_integer.getRawData()); break;
|
|
case e_sint128:
|
|
src = m_integer.getRawData();
|
|
s->Printf("%lli%lli", *(const slonglong_t *)src, *(const slonglong_t *)(src + 1));
|
|
break;
|
|
case e_uint128:
|
|
src = m_integer.getRawData();
|
|
s->Printf("0x%16.16llx%16.16llx", *(const ulonglong_t *)src, *(const ulonglong_t *)(src + 1));
|
|
break;
|
|
case e_float: s->Printf("%f", m_float.convertToFloat()); break;
|
|
case e_double: s->Printf("%g", m_float.convertToDouble()); break;
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
s->Printf("%Lg", *(const long_double_t *)ldbl_val.getRawData());
|
|
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_float: return "float";
|
|
case e_double: return "double";
|
|
case e_long_double: return "long double";
|
|
}
|
|
return "<invalid Scalar type>";
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// Scalar copy constructor
|
|
//----------------------------------------------------------------------
|
|
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;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
Scalar::~Scalar()
|
|
{
|
|
}
|
|
|
|
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 = llvm::APInt(sizeof(uint_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_slong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_ulong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_slonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_ulonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_sint128:
|
|
case e_uint128:
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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 = llvm::APInt(sizeof(slong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_ulong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_slonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_ulonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_sint128:
|
|
case e_uint128:
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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 = llvm::APInt(sizeof(ulong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_slonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_ulonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_sint128:
|
|
case e_uint128:
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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 = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_ulonglong:
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_sint128:
|
|
case e_uint128:
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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 = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
success = true;
|
|
break;
|
|
}
|
|
case e_sint128:
|
|
case e_uint128:
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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 = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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 = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData()));
|
|
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_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: 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_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_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";
|
|
}
|
|
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:
|
|
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_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: 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: 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_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_sint; success = true; break;
|
|
case e_float: success = true; break;
|
|
case e_double: success = true; break;
|
|
case e_long_double: success = true; break;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
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:
|
|
return *(const schar_t *)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getRawData();
|
|
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.getRawData();
|
|
}
|
|
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:
|
|
return *(const uchar_t *)m_integer.getRawData();
|
|
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.getRawData();
|
|
}
|
|
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:
|
|
return *(const sshort_t *)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getRawData();
|
|
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 *(const sshort_t *)ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return *(const ushort_t *)m_integer.getRawData();
|
|
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 *(const ushort_t *)ldbl_val.getRawData();;
|
|
}
|
|
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:
|
|
return *(const sint_t *)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getRawData();
|
|
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 *(const sint_t *)ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return *(const uint_t *)m_integer.getRawData();
|
|
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 *(const uint_t *)ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return *(const slong_t *)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getRawData();
|
|
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 *(const slong_t *)ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return *(const ulong_t *)m_integer.getRawData();
|
|
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 *(const ulong_t *)ldbl_val.getRawData();
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
uint64_t
|
|
Scalar::GetRawBits64(uint64_t 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:
|
|
return *m_integer.getRawData();
|
|
case e_float:
|
|
return (uint64_t)m_float.convertToFloat();
|
|
case e_double:
|
|
return (uint64_t)m_float.convertToDouble();
|
|
case e_long_double:
|
|
llvm::APInt ldbl_val = m_float.bitcastToAPInt();
|
|
return *ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return *(const slonglong_t *)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getRawData();
|
|
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 *(const slonglong_t *)ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return *(const ulonglong_t *)m_integer.getRawData();
|
|
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 *(const ulonglong_t *)ldbl_val.getRawData();
|
|
}
|
|
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:
|
|
return m_integer;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double:
|
|
return m_float.bitcastToAPInt();
|
|
}
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
{
|
|
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:
|
|
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:
|
|
{
|
|
m_integer <<= *rhs.m_integer.getRawData();
|
|
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:
|
|
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:
|
|
m_integer = m_integer.lshr(*(const uint_t *) rhs.m_integer.getRawData()); 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:
|
|
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:
|
|
{
|
|
m_integer = m_integer.ashr(*(const uint_t *)rhs.m_integer.getRawData());
|
|
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:
|
|
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:
|
|
{
|
|
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:
|
|
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_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:
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
{
|
|
if (b->m_integer != 0)
|
|
{
|
|
result.m_integer = *a->m_integer.getRawData() / *b->m_integer.getRawData();
|
|
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:
|
|
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:
|
|
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:
|
|
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_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:
|
|
{
|
|
if (b->m_integer != 0)
|
|
{
|
|
result.m_integer = *a->m_integer.getRawData() % *b->m_integer.getRawData();
|
|
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:
|
|
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;
|
|
}
|
|
|
|
// Return the raw unsigned integer without any casting or conversion
|
|
unsigned int
|
|
Scalar::RawUInt () const
|
|
{
|
|
return *(const uint_t *) m_integer.getRawData();
|
|
}
|
|
|
|
// Return the raw unsigned long without any casting or conversion
|
|
unsigned long
|
|
Scalar::RawULong () const
|
|
{
|
|
return *(const ulong_t *) m_integer.getRawData();
|
|
}
|
|
|
|
// Return the raw unsigned long long without any casting or conversion
|
|
unsigned long long
|
|
Scalar::RawULongLong () const
|
|
{
|
|
return *(const ulonglong_t *) m_integer.getRawData();
|
|
}
|
|
|
|
|
|
Error
|
|
Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
|
|
{
|
|
Error error;
|
|
if (value_str == NULL || 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;
|
|
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 + 1);
|
|
}
|
|
else
|
|
{
|
|
int128.x[0] = (uint64_t)data.GetU64 (&offset);
|
|
int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
|
|
}
|
|
operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.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 + 1);
|
|
}
|
|
else
|
|
{
|
|
int128.x[0] = (uint64_t)data.GetU64 (&offset);
|
|
int128.x[1] = (uint64_t)data.GetU64 (&offset + 1);
|
|
}
|
|
operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.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:
|
|
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;
|
|
|
|
uint32_t msbit = bit_offset + bit_size - 1;
|
|
uint32_t lsbit = bit_offset;
|
|
uint64_t result;
|
|
switch (m_type)
|
|
{
|
|
case Scalar::e_void:
|
|
break;
|
|
|
|
case e_float:
|
|
result = SignedBits ((uint64_t )m_float.convertToFloat(), msbit, lsbit);
|
|
m_float = llvm::APFloat((float_t)result);
|
|
return true;
|
|
case e_double:
|
|
result = SignedBits ((uint64_t )m_float.convertToDouble(), msbit, lsbit);
|
|
m_float = llvm::APFloat((double_t)result);
|
|
return true;
|
|
case e_long_double:
|
|
m_integer = m_float.bitcastToAPInt();
|
|
result = SignedBits (*m_integer.getRawData(), msbit, lsbit);
|
|
if(m_ieee_quad)
|
|
m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
|
|
else
|
|
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&result)->x));
|
|
return true;
|
|
|
|
case Scalar::e_sint:
|
|
case Scalar::e_slong:
|
|
case Scalar::e_slonglong:
|
|
case Scalar::e_sint128:
|
|
m_integer = SignedBits (*m_integer.getRawData(), msbit, lsbit);
|
|
return true;
|
|
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
m_integer = UnsignedBits (*m_integer.getRawData(), msbit, lsbit);
|
|
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:
|
|
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:
|
|
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:
|
|
return a->m_integer.slt(b->m_integer);
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
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:
|
|
return a->m_integer.sle(b->m_integer);
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
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:
|
|
return a->m_integer.sgt(b->m_integer);
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
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:
|
|
return a->m_integer.sge(b->m_integer);
|
|
case Scalar::e_uint:
|
|
case Scalar::e_ulong:
|
|
case Scalar::e_ulonglong:
|
|
case Scalar::e_uint128:
|
|
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: 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: m_integer.setBit(bit); return true;
|
|
case e_float:
|
|
case e_double:
|
|
case e_long_double: break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
Scalar::SetType (const RegisterInfo *reg_info)
|
|
{
|
|
const uint32_t byte_size = reg_info->byte_size;
|
|
switch (reg_info->encoding)
|
|
{
|
|
case eEncodingInvalid:
|
|
break;
|
|
case eEncodingUint:
|
|
if (byte_size == 1 || byte_size == 2 || byte_size == 4)
|
|
{
|
|
m_integer = llvm::APInt(sizeof(uint_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
m_type = e_uint;
|
|
}
|
|
if (byte_size == 8)
|
|
{
|
|
m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), false);
|
|
m_type = e_ulonglong;
|
|
}
|
|
if (byte_size == 16)
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())->x);
|
|
m_type = e_uint128;
|
|
}
|
|
break;
|
|
case eEncodingSint:
|
|
if (byte_size == 1 || byte_size == 2 || byte_size == 4)
|
|
{
|
|
m_integer = llvm::APInt(sizeof(sint_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
m_type = e_sint;
|
|
}
|
|
if (byte_size == 8)
|
|
{
|
|
m_integer = llvm::APInt(sizeof(slonglong_t) * 8, *(const uint64_t *)m_integer.getRawData(), true);
|
|
m_type = e_slonglong;
|
|
}
|
|
if (byte_size == 16)
|
|
{
|
|
m_integer = llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((const type128 *)m_integer.getRawData())->x);
|
|
m_type = e_sint128;
|
|
}
|
|
break;
|
|
case eEncodingIEEE754:
|
|
if (byte_size == sizeof(float))
|
|
{
|
|
bool losesInfo = false;
|
|
m_float.convert(llvm::APFloat::IEEEsingle, llvm::APFloat::rmTowardZero, &losesInfo);
|
|
m_type = e_float;
|
|
}
|
|
else if (byte_size == sizeof(double))
|
|
{
|
|
bool losesInfo = false;
|
|
m_float.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmTowardZero, &losesInfo);
|
|
m_type = e_double;
|
|
}
|
|
else if (byte_size == sizeof(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());
|
|
m_type = e_long_double;
|
|
}
|
|
break;
|
|
case eEncodingVector:
|
|
m_type = e_void;
|
|
break;
|
|
}
|
|
}
|