From 9b50546b0b4087ec2ee8479d68e70b89c7956aaa Mon Sep 17 00:00:00 2001 From: Pavel Labath Date: Mon, 24 Aug 2020 14:20:09 +0200 Subject: [PATCH] [lldb/Utility] Polish the Scalar class This patch is mostly about removing the "Category" enum, which was very useful when the Type enum contained a large number of types, but now the two are completely identical. It also removes some other artifacts like unused typedefs and macros. --- lldb/include/lldb/Utility/Scalar.h | 29 +----- lldb/source/Utility/Scalar.cpp | 177 +++++++++++++++++-------------------- 2 files changed, 82 insertions(+), 124 deletions(-) diff --git a/lldb/include/lldb/Utility/Scalar.h b/lldb/include/lldb/Utility/Scalar.h index 332bb00..7403fd1 100644 --- a/lldb/include/lldb/Utility/Scalar.h +++ b/lldb/include/lldb/Utility/Scalar.h @@ -20,18 +20,12 @@ #include namespace lldb_private { + class DataExtractor; class Stream; -} // namespace lldb_private #define NUM_OF_WORDS_INT128 2 #define BITWIDTH_INT128 128 -#define NUM_OF_WORDS_INT256 4 -#define BITWIDTH_INT256 256 -#define NUM_OF_WORDS_INT512 8 -#define BITWIDTH_INT512 512 - -namespace lldb_private { // A class designed to hold onto values and their corresponding types. // Operators are defined and Scalar objects will correctly promote their types @@ -48,7 +42,6 @@ class Scalar { } public: - // FIXME: These are host types which seems to be an odd choice. enum Type { e_void = 0, e_int, @@ -219,21 +212,6 @@ public: } protected: - typedef char schar_t; - typedef unsigned char uchar_t; - typedef short sshort_t; - typedef unsigned short ushort_t; - typedef int sint_t; - typedef unsigned int uint_t; - typedef long slong_t; - typedef unsigned long ulong_t; - typedef long long slonglong_t; - typedef unsigned long long ulonglong_t; - typedef float float_t; - typedef double double_t; - typedef long double long_double_t; - - // Classes that inherit from Scalar can see and modify these Scalar::Type m_type; llvm::APSInt m_integer; llvm::APFloat m_float; @@ -242,10 +220,7 @@ protected: static Type PromoteToMaxType(Scalar &lhs, Scalar &rhs); - enum class Category { Void, Integral, Float }; - static Category GetCategory(Scalar::Type type); - - using PromotionKey = std::tuple; + using PromotionKey = std::tuple; PromotionKey GetPromoKey() const; static PromotionKey GetFloatPromoKey(const llvm::fltSemantics &semantics); diff --git a/lldb/source/Utility/Scalar.cpp b/lldb/source/Utility/Scalar.cpp index 3dd2813..9bf633d 100644 --- a/lldb/source/Utility/Scalar.cpp +++ b/lldb/source/Utility/Scalar.cpp @@ -27,26 +27,13 @@ using llvm::APFloat; using llvm::APInt; using llvm::APSInt; -Scalar::Category Scalar::GetCategory(Scalar::Type type) { - switch (type) { - case Scalar::e_void: - return Category::Void; - case Scalar::e_float: - return Category::Float; - case Scalar::e_int: - return Category::Integral; - } - llvm_unreachable("Unhandled type!"); -} - Scalar::PromotionKey Scalar::GetPromoKey() const { - Category cat = GetCategory(m_type); - switch (cat) { - case Category::Void: - return PromotionKey{cat, 0, false}; - case Category::Integral: - return PromotionKey{cat, m_integer.getBitWidth(), m_integer.isUnsigned()}; - case Category::Float: + switch (m_type) { + case e_void: + return PromotionKey{e_void, 0, false}; + case e_int: + return PromotionKey{e_int, m_integer.getBitWidth(), m_integer.isUnsigned()}; + case e_float: return GetFloatPromoKey(m_float.getSemantics()); } llvm_unreachable("Unhandled category!"); @@ -58,7 +45,7 @@ Scalar::PromotionKey Scalar::GetFloatPromoKey(const llvm::fltSemantics &sem) { &APFloat::x87DoubleExtended()}; for (const auto &entry : llvm::enumerate(order)) { if (entry.value() == &sem) - return PromotionKey{Category::Float, entry.index(), false}; + return PromotionKey{e_float, entry.index(), false}; } llvm_unreachable("Unsupported semantics!"); } @@ -67,13 +54,13 @@ Scalar::PromotionKey Scalar::GetFloatPromoKey(const llvm::fltSemantics &sem) { // expressions. Scalar::Type Scalar::PromoteToMaxType(Scalar &lhs, Scalar &rhs) { const auto &Promote = [](Scalar &a, const Scalar &b) { - switch (GetCategory(b.GetType())) { - case Category::Void: + switch (b.GetType()) { + case e_void: break; - case Category::Integral: + case e_int: a.IntegralPromote(b.m_integer.getBitWidth(), b.m_integer.isSigned()); break; - case Category::Float: + case e_float: a.FloatPromote(b.m_float.getSemantics()); } }; @@ -129,13 +116,13 @@ void Scalar::GetBytes(llvm::MutableArrayRef storage) const { const auto &store = [&](const llvm::APInt &val) { StoreIntToMemory(val, storage.data(), (val.getBitWidth() + 7) / 8); }; - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: store(m_integer); break; - case Category::Float: + case e_float: store(m_float.bitcastToAPInt()); break; } @@ -154,12 +141,12 @@ size_t Scalar::GetByteSize() const { } bool Scalar::IsZero() const { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: return m_integer.isNullValue(); - case Category::Float: + case e_float: return m_float.isZero(); } return false; @@ -169,13 +156,13 @@ void Scalar::GetValue(Stream *s, bool show_type) const { if (show_type) s->Printf("(%s) ", GetTypeAsCString()); - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: s->PutCString(m_integer.toString(10)); break; - case Category::Float: + case e_float: llvm::SmallString<24> string; m_float.toString(string); s->PutCString(string); @@ -189,12 +176,12 @@ void Scalar::TruncOrExtendTo(uint16_t bits, bool sign) { } bool Scalar::IntegralPromote(uint16_t bits, bool sign) { - switch (GetCategory(m_type)) { - case Category::Void: - case Category::Float: + switch (m_type) { + case e_void: + case e_float: break; - case Category::Integral: - if (GetPromoKey() > PromotionKey(Category::Integral, bits, !sign)) + case e_int: + if (GetPromoKey() > PromotionKey(e_int, bits, !sign)) break; m_integer = m_integer.extOrTrunc(bits); m_integer.setIsSigned(sign); @@ -205,16 +192,16 @@ bool Scalar::IntegralPromote(uint16_t bits, bool sign) { bool Scalar::FloatPromote(const llvm::fltSemantics &semantics) { bool success = false; - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: m_float = llvm::APFloat(semantics); m_float.convertFromAPInt(m_integer, m_integer.isSigned(), llvm::APFloat::rmNearestTiesToEven); success = true; break; - case Category::Float: + case e_float: if (GetFloatPromoKey(semantics) < GetFloatPromoKey(m_float.getSemantics())) break; bool ignore; @@ -296,16 +283,16 @@ static llvm::APInt ToAPInt(const llvm::APFloat &f, unsigned bits, } template T Scalar::GetAs(T fail_value) const { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: { + case e_int: { APSInt ext = m_integer.extOrTrunc(sizeof(T) * 8); if (ext.isSigned()) return ext.getSExtValue(); return ext.getZExtValue(); } - case Category::Float: + case e_float: return ToAPInt(m_float, sizeof(T) * 8, std::is_unsigned::value) .getSExtValue(); } @@ -349,39 +336,39 @@ unsigned long long Scalar::ULongLong(unsigned long long fail_value) const { } llvm::APInt Scalar::SInt128(const llvm::APInt &fail_value) const { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: return m_integer; - case Category::Float: + case e_float: return ToAPInt(m_float, 128, /*is_unsigned=*/false); } return fail_value; } llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: return m_integer; - case Category::Float: + case e_float: return ToAPInt(m_float, 128, /*is_unsigned=*/true); } return fail_value; } float Scalar::Float(float fail_value) const { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: if (m_integer.isSigned()) return llvm::APIntOps::RoundSignedAPIntToFloat(m_integer); return llvm::APIntOps::RoundAPIntToFloat(m_integer); - case Category::Float: { + case e_float: { APFloat result = m_float; bool losesInfo; result.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, @@ -393,15 +380,15 @@ float Scalar::Float(float fail_value) const { } double Scalar::Double(double fail_value) const { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: if (m_integer.isSigned()) return llvm::APIntOps::RoundSignedAPIntToDouble(m_integer); return llvm::APIntOps::RoundAPIntToDouble(m_integer); - case Category::Float: { + case e_float: { APFloat result = m_float; bool losesInfo; result.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, @@ -420,14 +407,14 @@ long double Scalar::LongDouble(long double fail_value) const { Scalar &Scalar::operator+=(Scalar rhs) { Scalar copy = *this; if ((m_type = PromoteToMaxType(copy, rhs)) != Scalar::e_void) { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: m_integer = copy.m_integer + rhs.m_integer; break; - case Category::Float: + case e_float: m_float = copy.m_float + rhs.m_float; break; } @@ -436,8 +423,7 @@ Scalar &Scalar::operator+=(Scalar rhs) { } Scalar &Scalar::operator<<=(const Scalar &rhs) { - if (GetCategory(m_type) == Category::Integral && - GetCategory(rhs.m_type) == Category::Integral) + if (m_type == e_int && rhs.m_type == e_int) static_cast(m_integer) <<= rhs.m_integer; else m_type = e_void; @@ -445,8 +431,7 @@ Scalar &Scalar::operator<<=(const Scalar &rhs) { } bool Scalar::ShiftRightLogical(const Scalar &rhs) { - if (GetCategory(m_type) == Category::Integral && - GetCategory(rhs.m_type) == Category::Integral) { + if (m_type == e_int && rhs.m_type == e_int) { m_integer = m_integer.lshr(rhs.m_integer); return true; } @@ -477,8 +462,7 @@ Scalar &Scalar::operator>>=(const Scalar &rhs) { } Scalar &Scalar::operator&=(const Scalar &rhs) { - if (GetCategory(m_type) == Category::Integral && - GetCategory(rhs.m_type) == Category::Integral) + if (m_type == e_int && rhs.m_type == e_int) m_integer &= rhs.m_integer; else m_type = e_void; @@ -503,13 +487,13 @@ bool Scalar::AbsoluteValue() { } bool Scalar::UnaryNegate() { - switch (GetCategory(m_type)) { - case Category::Void: + switch (m_type) { + case e_void: break; - case Category::Integral: + case e_int: m_integer = -m_integer; return true; - case Category::Float: + case e_float: m_float.changeSign(); return true; } @@ -517,7 +501,7 @@ bool Scalar::UnaryNegate() { } bool Scalar::OnesComplement() { - if (GetCategory(m_type) == Category::Integral) { + if (m_type == e_int) { m_integer = ~m_integer; return true; } @@ -534,13 +518,13 @@ const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) { const Scalar lldb_private::operator-(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) { - switch (Scalar::GetCategory(result.m_type)) { - case Scalar::Category::Void: + switch (result.m_type) { + case Scalar::e_void: break; - case Scalar::Category::Integral: + case Scalar::e_int: result.m_integer = lhs.m_integer - rhs.m_integer; break; - case Scalar::Category::Float: + case Scalar::e_float: result.m_float = lhs.m_float - rhs.m_float; break; } @@ -552,13 +536,13 @@ const Scalar lldb_private::operator/(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void && !rhs.IsZero()) { - switch (Scalar::GetCategory(result.m_type)) { - case Scalar::Category::Void: + switch (result.m_type) { + case Scalar::e_void: break; - case Scalar::Category::Integral: + case Scalar::e_int: result.m_integer = lhs.m_integer / rhs.m_integer; return result; - case Scalar::Category::Float: + case Scalar::e_float: result.m_float = lhs.m_float / rhs.m_float; return result; } @@ -572,13 +556,13 @@ const Scalar lldb_private::operator/(Scalar lhs, Scalar rhs) { const Scalar lldb_private::operator*(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) { - switch (Scalar::GetCategory(result.m_type)) { - case Scalar::Category::Void: + switch (result.m_type) { + case Scalar::e_void: break; - case Scalar::Category::Integral: + case Scalar::e_int: result.m_integer = lhs.m_integer * rhs.m_integer; break; - case Scalar::Category::Float: + case Scalar::e_float: result.m_float = lhs.m_float * rhs.m_float; break; } @@ -589,7 +573,7 @@ const Scalar lldb_private::operator*(Scalar lhs, Scalar rhs) { const Scalar lldb_private::operator&(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) { - if (Scalar::GetCategory(result.m_type) == Scalar::Category::Integral) + if (result.m_type == Scalar::e_int) result.m_integer = lhs.m_integer & rhs.m_integer; else result.m_type = Scalar::e_void; @@ -600,7 +584,7 @@ const Scalar lldb_private::operator&(Scalar lhs, Scalar rhs) { const Scalar lldb_private::operator|(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) { - if (Scalar::GetCategory(result.m_type) == Scalar::Category::Integral) + if (result.m_type == Scalar::e_int) result.m_integer = lhs.m_integer | rhs.m_integer; else result.m_type = Scalar::e_void; @@ -611,8 +595,7 @@ const Scalar lldb_private::operator|(Scalar lhs, Scalar rhs) { const Scalar lldb_private::operator%(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) { - if (!rhs.IsZero() && - Scalar::GetCategory(result.m_type) == Scalar::Category::Integral) { + if (!rhs.IsZero() && result.m_type == Scalar::e_int) { result.m_integer = lhs.m_integer % rhs.m_integer; return result; } @@ -624,7 +607,7 @@ const Scalar lldb_private::operator%(Scalar lhs, Scalar rhs) { const Scalar lldb_private::operator^(Scalar lhs, Scalar rhs) { Scalar result; if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) { - if (Scalar::GetCategory(result.m_type) == Scalar::Category::Integral) + if (result.m_type == Scalar::e_int) result.m_integer = lhs.m_integer ^ rhs.m_integer; else result.m_type = Scalar::e_void; -- 2.7.4