[Lldb-commits] [lldb] 228ea81 - [lldb/Utility] Simplify more Scalar methods
Pavel Labath via lldb-commits
lldb-commits at lists.llvm.org
Fri Jul 3 07:35:30 PDT 2020
Author: Pavel Labath
Date: 2020-07-03T16:35:14+02:00
New Revision: 228ea815832a863bfd4da0f0fd67675e0a02cb88
URL: https://github.com/llvm/llvm-project/commit/228ea815832a863bfd4da0f0fd67675e0a02cb88
DIFF: https://github.com/llvm/llvm-project/commit/228ea815832a863bfd4da0f0fd67675e0a02cb88.diff
LOG: [lldb/Utility] Simplify more Scalar methods
A lot of the methods handle all integral and all floating point types
the same way. They can be changed to switch on the category of the type,
instead of the actual type, saving a lot of boilerplate.
This patch does that for the methods where I could be reasonably certain
of their expected semantics.
Added:
Modified:
lldb/source/Utility/Scalar.cpp
Removed:
################################################################################
diff --git a/lldb/source/Utility/Scalar.cpp b/lldb/source/Utility/Scalar.cpp
index 7bd42f3b9535..c36ccab21a39 100644
--- a/lldb/source/Utility/Scalar.cpp
+++ b/lldb/source/Utility/Scalar.cpp
@@ -23,6 +23,60 @@
using namespace lldb;
using namespace lldb_private;
+namespace {
+enum class Category { Void, Integral, Float };
+}
+
+static Category GetCategory(Scalar::Type type) {
+ switch (type) {
+ case Scalar::e_void:
+ return Category::Void;
+ case Scalar::e_float:
+ case Scalar::e_double:
+ case Scalar::e_long_double:
+ return Category::Float;
+ case Scalar::e_sint:
+ case Scalar::e_slong:
+ case Scalar::e_slonglong:
+ case Scalar::e_sint128:
+ case Scalar::e_sint256:
+ case Scalar::e_sint512:
+ case Scalar::e_uint:
+ case Scalar::e_ulong:
+ case Scalar::e_ulonglong:
+ case Scalar::e_uint128:
+ case Scalar::e_uint256:
+ case Scalar::e_uint512:
+ return Category::Integral;
+ }
+ llvm_unreachable("Unhandled type!");
+}
+
+static bool IsSigned(Scalar::Type type) {
+ switch (type) {
+ case Scalar::e_void:
+ case Scalar::e_uint:
+ case Scalar::e_ulong:
+ case Scalar::e_ulonglong:
+ case Scalar::e_uint128:
+ case Scalar::e_uint256:
+ case Scalar::e_uint512:
+ return false;
+ case Scalar::e_sint:
+ case Scalar::e_slong:
+ case Scalar::e_slonglong:
+ case Scalar::e_sint128:
+ case Scalar::e_sint256:
+ case Scalar::e_sint512:
+ case Scalar::e_float:
+ case Scalar::e_double:
+ case Scalar::e_long_double:
+ return true;
+ }
+ llvm_unreachable("Unhandled type!");
+}
+
+
// Promote to max type currently follows the ANSI C rule for type promotion in
// expressions.
static Scalar::Type PromoteToMaxType(
@@ -103,40 +157,19 @@ bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
void Scalar::GetBytes(llvm::MutableArrayRef<uint8_t> storage) const {
assert(storage.size() >= GetByteSize());
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- StoreIntToMemory(m_integer, storage.data(),
- (m_integer.getBitWidth() + 7) / 8);
- break;
- case e_float: {
- float val = m_float.convertToFloat();
- memcpy(storage.data(), &val, sizeof(val));
+ const auto &store = [&](const llvm::APInt val) {
+ StoreIntToMemory(val, storage.data(), (val.getBitWidth() + 7) / 8);
+ };
+ switch (GetCategory(m_type)) {
+ case Category::Void:
break;
- }
- case e_double: {
- double val = m_float.convertToDouble();
- memcpy(storage.data(), &val, sizeof(double));
+ case Category::Integral:
+ store(m_integer);
break;
- }
- case e_long_double: {
- llvm::APInt val = m_float.bitcastToAPInt();
- StoreIntToMemory(val, storage.data(), storage.size());
+ case Category::Float:
+ store(m_float.bitcastToAPInt());
break;
}
- }
}
size_t Scalar::GetByteSize() const {
@@ -167,26 +200,12 @@ size_t Scalar::GetByteSize() const {
}
bool Scalar::IsZero() const {
- llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
- switch (m_type) {
- case e_void:
+ switch (GetCategory(m_type)) {
+ case Category::Void:
break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_uint512:
- case e_sint512:
- return llvm::APInt::isSameValue(zero_int, m_integer);
- case e_float:
- case e_double:
- case e_long_double:
+ case Category::Integral:
+ return m_integer.isNullValue();
+ case Category::Float:
return m_float.isZero();
}
return false;
@@ -196,31 +215,16 @@ void Scalar::GetValue(Stream *s, bool show_type) const {
if (show_type)
s->Printf("(%s) ", GetTypeAsCString());
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_slong:
- case e_slonglong:
- case e_sint128:
- case e_sint256:
- case e_sint512:
- s->PutCString(m_integer.toString(10, true));
+ switch (GetCategory(m_type)) {
+ case Category::Void:
break;
- case e_uint:
- case e_ulong:
- case e_ulonglong:
- case e_uint128:
- case e_uint256:
- case e_uint512:
- s->PutCString(m_integer.toString(10, false));
+ case Category::Integral:
+ s->PutCString(m_integer.toString(10, IsSigned(m_type)));
break;
- case e_float:
- case e_double:
- case e_long_double:
+ case Category::Float:
llvm::SmallString<24> string;
m_float.toString(string);
- s->Printf("%s", string.c_str());
+ s->PutCString(string);
break;
}
}
@@ -325,59 +329,6 @@ static size_t GetBitSize(Scalar::Type type) {
llvm_unreachable("Unhandled type!");
}
-static bool IsSigned(Scalar::Type type) {
- switch (type) {
- case Scalar::e_void:
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- case Scalar::e_uint512:
- return false;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- case Scalar::e_sint512:
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- return true;
- }
- llvm_unreachable("Unhandled type!");
-}
-
-namespace {
-enum class Category { Void, Integral, Float };
-}
-
-static Category GetCategory(Scalar::Type type) {
- switch (type) {
- case Scalar::e_void:
- return Category::Void;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- return Category::Float;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- case Scalar::e_sint512:
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- case Scalar::e_uint512:
- return Category::Integral;
- }
- llvm_unreachable("Unhandled type!");
-}
-
static const llvm::fltSemantics &GetFltSemantics(Scalar::Type type) {
switch (type) {
case Scalar::e_void:
@@ -849,27 +800,14 @@ Scalar &Scalar::operator+=(const Scalar &rhs) {
const Scalar *b;
if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
Scalar::e_void) {
- switch (m_type) {
- case e_void:
+ switch (GetCategory(m_type)) {
+ case Category::Void:
break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
+ case Category::Integral:
m_integer = a->m_integer + b->m_integer;
break;
- case e_float:
- case e_double:
- case e_long_double:
+ case Category::Float:
m_float = a->m_float + b->m_float;
break;
}
@@ -878,54 +816,25 @@ Scalar &Scalar::operator+=(const Scalar &rhs) {
}
Scalar &Scalar::operator<<=(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
+ if (GetCategory(m_type) == Category::Integral &&
+ GetCategory(rhs.m_type) == Category::Integral)
+ m_integer <<= rhs.m_integer;
+ else
m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- m_integer = m_integer << rhs.m_integer;
- break;
- }
- break;
- }
return *this;
}
bool Scalar::ShiftRightLogical(const Scalar &rhs) {
+ if (GetCategory(m_type) == Category::Integral &&
+ GetCategory(rhs.m_type) == Category::Integral) {
+ m_integer = m_integer.lshr(rhs.m_integer);
+ return true;
+ }
+ m_type = e_void;
+ return false;
+}
+
+Scalar &Scalar::operator>>=(const Scalar &rhs) {
switch (m_type) {
case e_void:
case e_float:
@@ -965,111 +874,24 @@ bool Scalar::ShiftRightLogical(const Scalar &rhs) {
case e_uint256:
case e_sint512:
case e_uint512:
- m_integer = m_integer.lshr(rhs.m_integer);
+ m_integer = m_integer.ashr(rhs.m_integer);
break;
}
break;
}
- return m_type != e_void;
+ return *this;
}
-Scalar &Scalar::operator>>=(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- m_integer = m_integer.ashr(rhs.m_integer);
- break;
- }
- break;
- }
- return *this;
-}
-
-Scalar &Scalar::operator&=(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
- m_integer &= rhs.m_integer;
- break;
- }
- break;
- }
- return *this;
-}
-
-bool Scalar::AbsoluteValue() {
+Scalar &Scalar::operator&=(const Scalar &rhs) {
+ if (GetCategory(m_type) == Category::Integral &&
+ GetCategory(rhs.m_type) == Category::Integral)
+ m_integer &= rhs.m_integer;
+ else
+ m_type = e_void;
+ return *this;
+}
+
+bool Scalar::AbsoluteValue() {
switch (m_type) {
case e_void:
break;
@@ -1101,26 +923,13 @@ bool Scalar::AbsoluteValue() {
}
bool Scalar::UnaryNegate() {
- switch (m_type) {
- case e_void:
+ switch (GetCategory(m_type)) {
+ case Category::Void:
break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
+ case Category::Integral:
m_integer = -m_integer;
return true;
- case e_float:
- case e_double:
- case e_long_double:
+ case Category::Float:
m_float.changeSign();
return true;
}
@@ -1128,62 +937,17 @@ bool Scalar::UnaryNegate() {
}
bool Scalar::OnesComplement() {
- switch (m_type) {
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_sint512:
- case e_uint512:
+ if (GetCategory(m_type) == Category::Integral) {
m_integer = ~m_integer;
return true;
-
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- break;
}
+
return false;
}
const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- case Scalar::e_sint512:
- case Scalar::e_uint512:
- result.m_integer = a->m_integer + b->m_integer;
- break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result.m_float = a->m_float + b->m_float;
- break;
- }
- }
+ Scalar result = lhs;
+ result += rhs;
return result;
}
@@ -1194,26 +958,13 @@ const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
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:
+ switch (GetCategory(result.m_type)) {
+ case Category::Void:
break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- case Scalar::e_sint512:
- case Scalar::e_uint512:
+ case Category::Integral:
result.m_integer = a->m_integer - b->m_integer;
break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
+ case Category::Float:
result.m_float = a->m_float - b->m_float;
break;
}
@@ -1227,40 +978,20 @@ const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
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:
+ Scalar::e_void &&
+ !b->IsZero()) {
+ switch (GetCategory(result.m_type)) {
+ case Category::Void:
break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- case Scalar::e_sint512:
- if (b->m_integer != 0) {
+ case Category::Integral:
+ if (IsSigned(result.m_type))
result.m_integer = a->m_integer.sdiv(b->m_integer);
- return result;
- }
- break;
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- case Scalar::e_uint512:
- if (b->m_integer != 0) {
+ else
result.m_integer = a->m_integer.udiv(b->m_integer);
- return result;
- }
- break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- if (!b->m_float.isZero()) {
- result.m_float = a->m_float / b->m_float;
- return result;
- }
- break;
+ return result;
+ case Category::Float:
+ result.m_float = a->m_float / b->m_float;
+ return result;
}
}
// For division only, the only way it should make it here is if a promotion
@@ -1276,26 +1007,13 @@ const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
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:
+ switch (GetCategory(result.m_type)) {
+ case Category::Void:
break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- case Scalar::e_sint512:
- case Scalar::e_uint512:
+ case Category::Integral:
result.m_integer = a->m_integer * b->m_integer;
break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
+ case Category::Float:
result.m_float = a->m_float * b->m_float;
break;
}
@@ -1310,29 +1028,10 @@ const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- case Scalar::e_sint512:
- case Scalar::e_uint512:
+ if (GetCategory(result.m_type) == Category::Integral)
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
+ else
result.m_type = Scalar::e_void;
- break;
- }
}
return result;
}
@@ -1344,30 +1043,10 @@ const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- case Scalar::e_sint512:
- case Scalar::e_uint512:
+ if (GetCategory(result.m_type) == Category::Integral)
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
+ else
result.m_type = Scalar::e_void;
- break;
- }
}
return result;
}
@@ -1379,33 +1058,12 @@ const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
Scalar::e_void) {
- switch (result.m_type) {
- default:
- break;
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- case Scalar::e_sint512:
- if (b->m_integer != 0) {
+ if (!b->IsZero() && GetCategory(result.m_type) == Category::Integral) {
+ if (IsSigned(result.m_type))
result.m_integer = a->m_integer.srem(b->m_integer);
- return result;
- }
- break;
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- case Scalar::e_uint512:
- if (b->m_integer != 0) {
+ else
result.m_integer = a->m_integer.urem(b->m_integer);
- return result;
- }
- break;
+ return result;
}
}
result.m_type = Scalar::e_void;
@@ -1419,30 +1077,10 @@ const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
const Scalar *b;
if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- case Scalar::e_sint512:
- case Scalar::e_uint512:
+ if (GetCategory(result.m_type) == Category::Integral)
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
+ else
result.m_type = Scalar::e_void;
- break;
- }
}
return result;
}
More information about the lldb-commits
mailing list