This is an archive of the discontinued LLVM Phabricator instance.

Differential D44907

Remove Scalar::Cast
ClosedPublic

Authored by tromey on Mar 26 2018, 1:09 PM.

Details

Reviewers
clayborg
Commits
rG49d802862d5e: [Core] Grab-bag of improvements for Scalar.
rLLDB328985: [Core] Grab-bag of improvements for Scalar.
rL328985: [Core] Grab-bag of improvements for Scalar.
Summary

It was noted on the list that this method is unused. So, this patch
removes it.

Fix Scalar::Promote for most integer types

This fixes promotion of most integer types (128- and 256-bit types are
handled in a subsequent patch) to floating-point types. Previously
promotion was done bitwise, where value preservation is correct.

Fix Scalar::Promote for 128- and 256-bit integer types

This patch fixes the behavior of Scalar::Promote when trying to
perform a binary operation involving a 128- or 256-bit integer type
and a floating-point type. Now, the integer is cast to the floating
point type for the operation.

Diff Detail

Repository
rL LLVM

Event Timeline

tromey created this revision.Mar 26 2018, 1:09 PM
tromey added a subscriber: lldb-commits.Mar 26 2018, 1:09 PM
Harbormaster completed remote builds in B16443: Diff 139844.Mar 26 2018, 1:10 PM
tromey added a reviewer: clayborg.Mar 29 2018, 9:12 AM
clayborg accepted this revision.Mar 29 2018, 9:19 AM

Very nice. Thanks for doing this. Someone a while back had converted Scalar to use APInt and APFloat and never got around to all of these details.

This revision is now accepted and ready to land.Mar 29 2018, 9:19 AM
davide added a subscriber: davide.Mar 29 2018, 9:24 AM

@tromey thanks! do you need somebody to commit this for you?

tromey added a comment.Mar 29 2018, 10:15 AM
In D44907#1051931, @davide wrote:

@tromey thanks! do you need somebody to commit this for you?

Yes. I do not have commit access.

davide added a comment.Mar 29 2018, 10:17 AM

OK, I'll commit it for you later today.

Closed by commit rL328985: [Core] Grab-bag of improvements for Scalar. (authored by davide). · Explain WhyApr 2 2018, 9:53 AM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptApr 2 2018, 9:53 AM

Revision Contents

PathSize
lldb/
trunk/
include/
lldb/
Core/
12 lines
source/
Core/
441 lines
unittests/
Core/
45 lines

Diff 140642

lldb/trunk/include/lldb/Core/Scalar.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linespublic:
enum Type { enum Type {
e_void = 0, e_void = 0,
e_sint, e_sint,
e_uint, e_uint,
e_slong, e_slong,
e_ulong, e_ulong,
e_slonglong, e_slonglong,
e_ulonglong, e_ulonglong,
e_float,
e_double,
e_long_double,
e_uint128,
e_sint128, e_sint128,
e_uint128,
e_sint256,
e_uint256, e_uint256,
e_sint256 e_float,
e_double,
e_long_double
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
// Constructors and Destructors // Constructors and Destructors
//------------------------------------------------------------------ //------------------------------------------------------------------
Scalar(); Scalar();
Scalar(int v) : m_type(e_sint), m_float((float)0) { Scalar(int v) : m_type(e_sint), m_float((float)0) {
m_integer = llvm::APInt(sizeof(int) * 8, v, true); m_integer = llvm::APInt(sizeof(int) * 8, v, true);
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Linespublic:
void GetValue(Stream *s, bool show_type) const; void GetValue(Stream *s, bool show_type) const;
bool IsValid() const { bool IsValid() const {
return (m_type >= e_sint) && (m_type <= e_long_double); return (m_type >= e_sint) && (m_type <= e_long_double);
} }
bool Promote(Scalar::Type type); bool Promote(Scalar::Type type);
bool Cast(Scalar::Type type);
bool MakeSigned(); bool MakeSigned();
bool MakeUnsigned(); bool MakeUnsigned();
static const char *GetValueTypeAsCString(Scalar::Type value_type); static const char *GetValueTypeAsCString(Scalar::Type value_type);
static Scalar::Type static Scalar::Type
GetValueTypeForSignedIntegerWithByteSize(size_t byte_size); GetValueTypeForSignedIntegerWithByteSize(size_t byte_size);
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Scalar.cpp

Show First 20 Lines • Show All 485 Lines • ▼ Show 20 Lines case e_sint:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, true,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_uint: case e_uint:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 30 Lines case e_uint:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, false,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_slong: case e_slong:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 26 Lines case e_slong:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, true,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_ulong: case e_ulong:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 22 Lines case e_ulong:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, false,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_slonglong: case e_slonglong:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 18 Lines case e_slonglong:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, true,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_ulonglong: case e_ulonglong:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 14 Lines case e_ulonglong:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, false,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_sint128: case e_sint128:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 14 Lines case e_sint128:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, true,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_uint128: case e_uint128:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 10 Lines case e_uint128:
break; break;
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, false,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_sint256: case e_sint256:
switch (type) { switch (type) {
case e_void: case e_void:
Show All 10 Lines case e_sint256:
success = true; success = true;
break; break;
case e_uint256: case e_uint256:
m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, true,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, true,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_uint256: case e_uint256:
switch (type) { switch (type) {
case e_void: case e_void:
case e_sint: case e_sint:
case e_uint: case e_uint:
case e_slong: case e_slong:
case e_ulong: case e_ulong:
case e_slonglong: case e_slonglong:
case e_ulonglong: case e_ulonglong:
case e_sint128: case e_sint128:
case e_uint128: case e_uint128:
case e_sint256: case e_sint256:
break; break;
case e_uint256: case e_uint256:
success = true; success = true;
break; break;
case e_float: case e_float:
m_float = llvm::APFloat(m_integer.bitsToFloat()); m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat(m_integer.bitsToDouble()); m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
m_float.convertFromAPInt(m_integer, false,
llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
case e_long_double: case e_long_double:
if (m_ieee_quad) m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer); : llvm::APFloat::x87DoubleExtended());
else m_float.convertFromAPInt(m_integer, false,
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer); llvm::APFloat::rmNearestTiesToEven);
success = true; success = true;
break; break;
} }
break; break;
case e_float: case e_float:
switch (type) { switch (type) {
case e_void: case e_void:
case e_sint: case e_sint:
case e_uint: case e_uint:
case e_slong: case e_slong:
case e_ulong: case e_ulong:
case e_slonglong: case e_slonglong:
case e_ulonglong: case e_ulonglong:
case e_sint128: case e_sint128:
case e_uint128: case e_uint128:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
break; break;
case e_float: case e_float:
success = true; success = true;
break; break;
case e_double: case e_double:
m_float = llvm::APFloat((float_t)m_float.convertToFloat()); m_float = llvm::APFloat((double_t)m_float.convertToFloat());
success = true; success = true;
break; break;
case e_long_double: case e_long_double: {
if (m_ieee_quad) bool ignore;
m_float = m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt()); : llvm::APFloat::x87DoubleExtended(),
else llvm::APFloat::rmNearestTiesToEven, &ignore);
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
m_float.bitcastToAPInt());
success = true; success = true;
break; break;
} }
}
break; break;
case e_double: case e_double:
switch (type) { switch (type) {
case e_void: case e_void:
case e_sint: case e_sint:
case e_uint: case e_uint:
case e_slong: case e_slong:
case e_ulong: case e_ulong:
case e_slonglong: case e_slonglong:
case e_ulonglong: case e_ulonglong:
case e_sint128: case e_sint128:
case e_uint128: case e_uint128:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
case e_float: case e_float:
break; break;
case e_double: case e_double:
success = true; success = true;
break; break;
case e_long_double: case e_long_double: {
if (m_ieee_quad) bool ignore;
m_float = m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt()); : llvm::APFloat::x87DoubleExtended(),
else llvm::APFloat::rmNearestTiesToEven, &ignore);
m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
m_float.bitcastToAPInt());
success = true; success = true;
break; break;
} }
}
break; break;
case e_long_double: case e_long_double:
switch (type) { switch (type) {
case e_void: case e_void:
case e_sint: case e_sint:
case e_uint: case e_uint:
case e_slong: case e_slong:
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines if (byte_size == sizeof(float_t))
return e_float; return e_float;
if (byte_size == sizeof(double_t)) if (byte_size == sizeof(double_t))
return e_double; return e_double;
if (byte_size == sizeof(long_double_t)) if (byte_size == sizeof(long_double_t))
return e_long_double; return e_long_double;
return e_void; 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 Scalar::MakeSigned() {
bool success = false; bool success = false;
switch (m_type) { switch (m_type) {
case e_void: case e_void:
break; break;
case e_sint: case e_sint:
success = true; success = true;
▲ Show 20 Lines • Show All 468 Lines • ▼ Show 20 Linesfloat Scalar::Float(float fail_value) const {
case e_slong: case e_slong:
case e_ulong: case e_ulong:
case e_slonglong: case e_slonglong:
case e_ulonglong: case e_ulonglong:
case e_sint128: case e_sint128:
case e_uint128: case e_uint128:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
return m_integer.bitsToFloat(); return llvm::APIntOps::RoundAPIntToFloat(m_integer);
case e_float: case e_float:
return m_float.convertToFloat(); return m_float.convertToFloat();
case e_double: case e_double:
return (float_t)m_float.convertToDouble(); return (float_t)m_float.convertToDouble();
case e_long_double: case e_long_double:
llvm::APInt ldbl_val = m_float.bitcastToAPInt(); llvm::APInt ldbl_val = m_float.bitcastToAPInt();
return ldbl_val.bitsToFloat(); return ldbl_val.bitsToFloat();
} }
Show All 9 Linesdouble Scalar::Double(double fail_value) const {
case e_slong: case e_slong:
case e_ulong: case e_ulong:
case e_slonglong: case e_slonglong:
case e_ulonglong: case e_ulonglong:
case e_sint128: case e_sint128:
case e_uint128: case e_uint128:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
return m_integer.bitsToDouble(); return llvm::APIntOps::RoundAPIntToDouble(m_integer);
case e_float: case e_float:
return (double_t)m_float.convertToFloat(); return (double_t)m_float.convertToFloat();
case e_double: case e_double:
return m_float.convertToDouble(); return m_float.convertToDouble();
case e_long_double: case e_long_double:
llvm::APInt ldbl_val = m_float.bitcastToAPInt(); llvm::APInt ldbl_val = m_float.bitcastToAPInt();
return ldbl_val.bitsToFloat(); return ldbl_val.bitsToFloat();
} }
Show All 9 Lineslong double Scalar::LongDouble(long double fail_value) const {
case e_slong: case e_slong:
case e_ulong: case e_ulong:
case e_slonglong: case e_slonglong:
case e_ulonglong: case e_ulonglong:
case e_sint128: case e_sint128:
case e_uint128: case e_uint128:
case e_sint256: case e_sint256:
case e_uint256: case e_uint256:
return (long_double_t)m_integer.bitsToDouble(); return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
case e_float: case e_float:
return (long_double_t)m_float.convertToFloat(); return (long_double_t)m_float.convertToFloat();
case e_double: case e_double:
return (long_double_t)m_float.convertToDouble(); return (long_double_t)m_float.convertToDouble();
case e_long_double: case e_long_double:
llvm::APInt ldbl_val = m_float.bitcastToAPInt(); llvm::APInt ldbl_val = m_float.bitcastToAPInt();
return (long_double_t)ldbl_val.bitsToDouble(); return (long_double_t)ldbl_val.bitsToDouble();
} }
▲ Show 20 Lines • Show All 1,187 Lines • Show Last 20 Lines

lldb/trunk/unittests/Core/ScalarTest.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 LinesTEST(ScalarTest, CastOperations) {
ASSERT_EQ((signed short)a, a_scalar.SShort()); ASSERT_EQ((signed short)a, a_scalar.SShort());
ASSERT_EQ((unsigned short)a, a_scalar.UShort()); ASSERT_EQ((unsigned short)a, a_scalar.UShort());
ASSERT_EQ((signed int)a, a_scalar.SInt()); ASSERT_EQ((signed int)a, a_scalar.SInt());
ASSERT_EQ((unsigned int)a, a_scalar.UInt()); ASSERT_EQ((unsigned int)a, a_scalar.UInt());
ASSERT_EQ((signed long)a, a_scalar.SLong()); ASSERT_EQ((signed long)a, a_scalar.SLong());
ASSERT_EQ((unsigned long)a, a_scalar.ULong()); ASSERT_EQ((unsigned long)a, a_scalar.ULong());
ASSERT_EQ((signed long long)a, a_scalar.SLongLong()); ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong()); ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
int a2 = 23;
Scalar a2_scalar(a2);
ASSERT_EQ((float)a2, a2_scalar.Float());
ASSERT_EQ((double)a2, a2_scalar.Double());
ASSERT_EQ((long double)a2, a2_scalar.LongDouble());
} }
TEST(ScalarTest, ExtractBitfield) { TEST(ScalarTest, ExtractBitfield) {
uint32_t len = sizeof(long long) * 8; uint32_t len = sizeof(long long) * 8;
long long a1 = 0xf1f2f3f4f5f6f7f8LL; long long a1 = 0xf1f2f3f4f5f6f7f8LL;
long long b1 = 0xff1f2f3f4f5f6f7fLL; long long b1 = 0xff1f2f3f4f5f6f7fLL;
Scalar s_scalar(a1); Scalar s_scalar(a1);
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
TEST(ScalarTest, Division) { TEST(ScalarTest, Division) {
Scalar lhs(5.0); Scalar lhs(5.0);
Scalar rhs(2.0); Scalar rhs(2.0);
Scalar r = lhs / rhs; Scalar r = lhs / rhs;
EXPECT_TRUE(r.IsValid()); EXPECT_TRUE(r.IsValid());
EXPECT_EQ(r, Scalar(2.5)); EXPECT_EQ(r, Scalar(2.5));
} }
TEST(ScalarTest, Promotion) {
static Scalar::Type int_types[] = {
Scalar::e_sint, Scalar::e_uint, Scalar::e_slong,
Scalar::e_ulong, Scalar::e_slonglong, Scalar::e_ulonglong,
Scalar::e_sint128, Scalar::e_uint128, Scalar::e_sint256,
Scalar::e_uint256,
Scalar::e_void // sentinel
};
static Scalar::Type float_types[] = {
Scalar::e_float, Scalar::e_double, Scalar::e_long_double,
Scalar::e_void // sentinel
};
for (int i = 0; int_types[i] != Scalar::e_void; ++i) {
for (int j = 0; float_types[j] != Scalar::e_void; ++j) {
Scalar lhs(2);
EXPECT_TRUE(lhs.Promote(int_types[i])) << "int promotion #" << i;
Scalar rhs(0.5f);
EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
Scalar x(2.5f);
EXPECT_TRUE(x.Promote(float_types[j]));
EXPECT_EQ(lhs + rhs, x);
}
}
for (int i = 0; float_types[i] != Scalar::e_void; ++i) {
for (int j = 0; float_types[j] != Scalar::e_void; ++j) {
Scalar lhs(2);
EXPECT_TRUE(lhs.Promote(float_types[i])) << "float promotion #" << i;
Scalar rhs(0.5f);
EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
Scalar x(2.5f);
EXPECT_TRUE(x.Promote(float_types[j]));
EXPECT_EQ(lhs + rhs, x);
}
}
}