1 //===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Scalar.h"
12 #include "lldb/Host/StringConvert.h"
13 #include "lldb/Utility/DataExtractor.h"
14 #include "lldb/Utility/Endian.h"
15 #include "lldb/Utility/Status.h"
16 #include "lldb/Utility/Stream.h"
17 #include "lldb/lldb-types.h" // for offset_t
19 #include "llvm/ADT/SmallString.h"
25 using namespace lldb_private;
27 //----------------------------------------------------------------------
28 // Promote to max type currently follows the ANSI C rule for type
29 // promotion in expressions.
30 //----------------------------------------------------------------------
31 static Scalar::Type PromoteToMaxType(
32 const Scalar &lhs, // The const left hand side object
33 const Scalar &rhs, // The const right hand side object
34 Scalar &temp_value, // A modifiable temp value than can be used to hold
35 // either the promoted lhs or rhs object
36 const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
37 // promoted value of lhs (at most one of
38 // lhs/rhs will get promoted)
39 const Scalar *&promoted_rhs_ptr // Pointer to the resulting possibly
40 // promoted value of rhs (at most one of
41 // lhs/rhs will get promoted)
44 // Initialize the promoted values for both the right and left hand side values
45 // to be the objects themselves. If no promotion is needed (both right and
47 // have the same type), then the temp_value will not get used.
48 promoted_lhs_ptr = &lhs;
49 promoted_rhs_ptr = &rhs;
50 // Extract the types of both the right and left hand side values
51 Scalar::Type lhs_type = lhs.GetType();
52 Scalar::Type rhs_type = rhs.GetType();
54 if (lhs_type > rhs_type) {
55 // Right hand side need to be promoted
56 temp_value = rhs; // Copy right hand side into the temp value
57 if (temp_value.Promote(lhs_type)) // Promote it
59 &temp_value; // Update the pointer for the promoted right hand side
60 } else if (lhs_type < rhs_type) {
61 // Left hand side need to be promoted
62 temp_value = lhs; // Copy left hand side value into the temp value
63 if (temp_value.Promote(rhs_type)) // Promote it
65 &temp_value; // Update the pointer for the promoted left hand side
68 // Make sure our type promotion worked as expected
69 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
70 return promoted_lhs_ptr->GetType(); // Return the resulting max type
72 // Return the void type (zero) if we fail to promote either of the values.
73 return Scalar::e_void;
76 Scalar::Scalar() : m_type(e_void), m_float((float)0) {}
78 Scalar::Scalar(const Scalar &rhs)
79 : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
81 // Scalar::Scalar(const RegisterValue& reg) :
85 // switch (reg.info.encoding)
87 // case eEncodingUint: // unsigned integer
88 // switch (reg.info.byte_size)
90 // case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
91 // case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
92 // case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
93 // case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64;
99 // case eEncodingSint: // signed integer
100 // switch (reg.info.byte_size)
102 // case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
103 // case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
104 // case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
105 // case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64;
111 // case eEncodingIEEE754: // float
112 // switch (reg.info.byte_size)
114 // case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
115 // case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
119 // case eEncodingVector: // vector registers
124 bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
125 size_t byte_size = GetByteSize();
127 const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
129 if (limit_byte_size < byte_size) {
130 if (endian::InlHostByteOrder() == eByteOrderLittle) {
131 // On little endian systems if we want fewer bytes from the
132 // current type we just specify fewer bytes since the LSByte
134 byte_size = limit_byte_size;
135 } else if (endian::InlHostByteOrder() == eByteOrderBig) {
136 // On big endian systems if we want fewer bytes from the
137 // current type have to advance our initial byte pointer and
138 // trim down the number of bytes since the MSByte is first
139 bytes += byte_size - limit_byte_size;
140 byte_size = limit_byte_size;
144 data.SetData(bytes, byte_size, endian::InlHostByteOrder());
151 const void *Scalar::GetBytes() const {
152 const uint64_t *apint_words;
153 const uint8_t *bytes;
154 static float_t flt_val;
155 static double_t dbl_val;
156 static uint64_t swapped_words[4];
166 bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
167 // getRawData always returns a pointer to an uint64_t. If we have a smaller
169 // we need to update the pointer on big-endian systems.
170 if (endian::InlHostByteOrder() == eByteOrderBig) {
171 size_t byte_size = m_integer.getBitWidth() / 8;
173 bytes += 8 - byte_size;
178 apint_words = m_integer.getRawData();
179 // getRawData always returns a pointer to an array of two uint64_t values,
180 // where the least-significant word always comes first. On big-endian
181 // systems we need to swap the two words.
182 if (endian::InlHostByteOrder() == eByteOrderBig) {
183 swapped_words[0] = apint_words[1];
184 swapped_words[1] = apint_words[0];
185 apint_words = swapped_words;
187 return reinterpret_cast<const void *>(apint_words);
190 apint_words = m_integer.getRawData();
191 // getRawData always returns a pointer to an array of four uint64_t values,
192 // where the least-significant word always comes first. On big-endian
193 // systems we need to swap the four words.
194 if (endian::InlHostByteOrder() == eByteOrderBig) {
195 swapped_words[0] = apint_words[3];
196 swapped_words[1] = apint_words[2];
197 swapped_words[2] = apint_words[1];
198 swapped_words[3] = apint_words[0];
199 apint_words = swapped_words;
201 return reinterpret_cast<const void *>(apint_words);
203 flt_val = m_float.convertToFloat();
204 return reinterpret_cast<const void *>(&flt_val);
206 dbl_val = m_float.convertToDouble();
207 return reinterpret_cast<const void *>(&dbl_val);
209 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
210 apint_words = ldbl_val.getRawData();
211 // getRawData always returns a pointer to an array of two uint64_t values,
212 // where the least-significant word always comes first. On big-endian
213 // systems we need to swap the two words.
214 if (endian::InlHostByteOrder() == eByteOrderBig) {
215 swapped_words[0] = apint_words[1];
216 swapped_words[1] = apint_words[0];
217 apint_words = swapped_words;
219 return reinterpret_cast<const void *>(apint_words);
224 size_t Scalar::GetByteSize() const {
238 return (m_integer.getBitWidth() / 8);
240 return sizeof(float_t);
242 return sizeof(double_t);
244 return sizeof(long_double_t);
249 bool Scalar::IsZero() const {
250 llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
264 return llvm::APInt::isSameValue(zero_int, m_integer);
268 return m_float.isZero();
273 void Scalar::GetValue(Stream *s, bool show_type) const {
275 s->Printf("(%s) ", GetTypeAsCString());
285 s->PutCString(m_integer.toString(10, true));
292 s->PutCString(m_integer.toString(10, false));
297 llvm::SmallString<24> string;
298 m_float.toString(string);
299 s->Printf("%s", string.c_str());
304 const char *Scalar::GetTypeAsCString() const {
311 return "unsigned int";
315 return "unsigned long";
319 return "unsigned long long";
323 return "unsigned int128_t";
327 return "unsigned int256_t";
333 return "long double";
335 return "<invalid Scalar type>";
338 Scalar &Scalar::operator=(const Scalar &rhs) {
341 m_integer = llvm::APInt(rhs.m_integer);
342 m_float = rhs.m_float;
347 Scalar &Scalar::operator=(const int v) {
349 m_integer = llvm::APInt(sizeof(int) * 8, v, true);
353 Scalar &Scalar::operator=(unsigned int v) {
355 m_integer = llvm::APInt(sizeof(int) * 8, v);
359 Scalar &Scalar::operator=(long v) {
361 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
365 Scalar &Scalar::operator=(unsigned long v) {
367 m_integer = llvm::APInt(sizeof(long) * 8, v);
371 Scalar &Scalar::operator=(long long v) {
372 m_type = e_slonglong;
373 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
377 Scalar &Scalar::operator=(unsigned long long v) {
378 m_type = e_ulonglong;
379 m_integer = llvm::APInt(sizeof(long long) * 8, v);
383 Scalar &Scalar::operator=(float v) {
385 m_float = llvm::APFloat(v);
389 Scalar &Scalar::operator=(double v) {
391 m_float = llvm::APFloat(v);
395 Scalar &Scalar::operator=(long double v) {
396 m_type = e_long_double;
398 m_float = llvm::APFloat(
399 llvm::APFloat::IEEEquad(),
400 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
402 m_float = llvm::APFloat(
403 llvm::APFloat::x87DoubleExtended(),
404 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
408 Scalar &Scalar::operator=(llvm::APInt rhs) {
409 m_integer = llvm::APInt(rhs);
410 switch (m_integer.getBitWidth()) {
414 if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
420 if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
421 m_type = e_slonglong;
423 m_type = e_ulonglong;
426 if (m_integer.isSignedIntN(BITWIDTH_INT128))
432 if (m_integer.isSignedIntN(BITWIDTH_INT256))
441 Scalar::~Scalar() = default;
443 bool Scalar::Promote(Scalar::Type type) {
444 bool success = false;
457 m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
462 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
467 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
472 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
477 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
483 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
489 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
494 m_float = llvm::APFloat(m_integer.bitsToFloat());
499 m_float = llvm::APFloat(m_integer.bitsToDouble());
505 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
507 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
522 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
527 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
532 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
537 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
543 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
549 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
554 m_float = llvm::APFloat(m_integer.bitsToFloat());
559 m_float = llvm::APFloat(m_integer.bitsToDouble());
565 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
567 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
583 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
588 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
593 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
599 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
605 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
610 m_float = llvm::APFloat(m_integer.bitsToFloat());
615 m_float = llvm::APFloat(m_integer.bitsToDouble());
621 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
623 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
640 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
645 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
651 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
657 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
662 m_float = llvm::APFloat(m_integer.bitsToFloat());
667 m_float = llvm::APFloat(m_integer.bitsToDouble());
673 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
675 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
693 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
699 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
705 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
710 m_float = llvm::APFloat(m_integer.bitsToFloat());
715 m_float = llvm::APFloat(m_integer.bitsToDouble());
721 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
723 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
743 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
749 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
754 m_float = llvm::APFloat(m_integer.bitsToFloat());
759 m_float = llvm::APFloat(m_integer.bitsToDouble());
765 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
767 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
787 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
793 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
798 m_float = llvm::APFloat(m_integer.bitsToFloat());
803 m_float = llvm::APFloat(m_integer.bitsToDouble());
809 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
811 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
833 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
838 m_float = llvm::APFloat(m_integer.bitsToFloat());
843 m_float = llvm::APFloat(m_integer.bitsToDouble());
849 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
851 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
873 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
878 m_float = llvm::APFloat(m_integer.bitsToFloat());
883 m_float = llvm::APFloat(m_integer.bitsToDouble());
889 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
891 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
914 m_float = llvm::APFloat(m_integer.bitsToFloat());
919 m_float = llvm::APFloat(m_integer.bitsToDouble());
925 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
927 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
951 m_float = llvm::APFloat((float_t)m_float.convertToFloat());
958 llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
960 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
961 m_float.bitcastToAPInt());
988 llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
990 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
991 m_float.bitcastToAPInt());
1025 const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
1032 return "unsigned int";
1036 return "unsigned long";
1040 return "unsigned long long";
1046 return "long double";
1060 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
1061 if (byte_size <= sizeof(sint_t))
1063 if (byte_size <= sizeof(slong_t))
1065 if (byte_size <= sizeof(slonglong_t))
1071 Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
1072 if (byte_size <= sizeof(uint_t))
1074 if (byte_size <= sizeof(ulong_t))
1076 if (byte_size <= sizeof(ulonglong_t))
1081 Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
1082 if (byte_size == sizeof(float_t))
1084 if (byte_size == sizeof(double_t))
1086 if (byte_size == sizeof(long_double_t))
1087 return e_long_double;
1091 bool Scalar::Cast(Scalar::Type type) {
1092 bool success = false;
1111 m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
1116 m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
1121 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
1126 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
1131 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
1136 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
1141 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
1146 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
1151 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
1156 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
1161 m_float = llvm::APFloat(m_integer.bitsToFloat());
1166 m_float = llvm::APFloat(m_integer.bitsToDouble());
1172 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
1174 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
1194 m_integer = m_float.bitcastToAPInt();
1198 m_float = llvm::APFloat(m_float.convertToFloat());
1202 m_float = llvm::APFloat(m_float.convertToFloat());
1208 llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
1210 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
1211 m_float.bitcastToAPInt());
1231 m_integer = m_float.bitcastToAPInt();
1235 m_float = llvm::APFloat(m_float.convertToDouble());
1239 m_float = llvm::APFloat(m_float.convertToDouble());
1245 llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
1247 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
1248 m_float.bitcastToAPInt());
1259 m_integer = m_float.bitcastToAPInt();
1260 m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
1265 m_integer = m_float.bitcastToAPInt();
1266 m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
1271 m_integer = m_float.bitcastToAPInt();
1272 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
1277 m_integer = m_float.bitcastToAPInt();
1278 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
1283 m_integer = m_float.bitcastToAPInt();
1284 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
1289 m_integer = m_float.bitcastToAPInt();
1290 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
1295 m_integer = m_float.bitcastToAPInt();
1296 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
1301 m_integer = m_float.bitcastToAPInt();
1302 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
1307 m_integer = m_float.bitcastToAPInt();
1308 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
1313 m_integer = m_float.bitcastToAPInt();
1314 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
1319 m_float = llvm::APFloat(m_float.convertToFloat());
1323 m_float = llvm::APFloat(m_float.convertToFloat());
1338 bool Scalar::MakeSigned() {
1339 bool success = false;
1362 m_type = e_slonglong;
1393 bool Scalar::MakeUnsigned() {
1394 bool success = false;
1417 m_type = e_ulonglong;
1448 signed char Scalar::SChar(char fail_value) const {
1462 return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
1464 return (schar_t)m_float.convertToFloat();
1466 return (schar_t)m_float.convertToDouble();
1468 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1469 return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
1474 unsigned char Scalar::UChar(unsigned char fail_value) const {
1488 return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
1490 return (uchar_t)m_float.convertToFloat();
1492 return (uchar_t)m_float.convertToDouble();
1494 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1495 return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
1500 short Scalar::SShort(short fail_value) const {
1514 return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
1517 return (sshort_t)m_float.convertToFloat();
1519 return (sshort_t)m_float.convertToDouble();
1521 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1522 return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
1528 unsigned short Scalar::UShort(unsigned short fail_value) const {
1542 return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
1545 return (ushort_t)m_float.convertToFloat();
1547 return (ushort_t)m_float.convertToDouble();
1549 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1550 return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
1556 int Scalar::SInt(int fail_value) const {
1570 return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
1572 return (sint_t)m_float.convertToFloat();
1574 return (sint_t)m_float.convertToDouble();
1576 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1577 return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
1582 unsigned int Scalar::UInt(unsigned int fail_value) const {
1596 return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
1598 return (uint_t)m_float.convertToFloat();
1600 return (uint_t)m_float.convertToDouble();
1602 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1603 return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
1608 long Scalar::SLong(long fail_value) const {
1622 return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
1624 return (slong_t)m_float.convertToFloat();
1626 return (slong_t)m_float.convertToDouble();
1628 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1629 return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
1634 unsigned long Scalar::ULong(unsigned long fail_value) const {
1648 return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
1650 return (ulong_t)m_float.convertToFloat();
1652 return (ulong_t)m_float.convertToDouble();
1654 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1655 return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
1660 long long Scalar::SLongLong(long long fail_value) const {
1674 return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
1677 return (slonglong_t)m_float.convertToFloat();
1679 return (slonglong_t)m_float.convertToDouble();
1681 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1682 return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
1688 unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
1702 return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
1705 return (ulonglong_t)m_float.convertToFloat();
1707 return (ulonglong_t)m_float.convertToDouble();
1709 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1710 return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8))
1716 llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
1734 return m_float.bitcastToAPInt();
1739 llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
1757 return m_float.bitcastToAPInt();
1762 llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
1780 return m_float.bitcastToAPInt();
1785 llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
1803 return m_float.bitcastToAPInt();
1808 float Scalar::Float(float fail_value) const {
1822 return m_integer.bitsToFloat();
1824 return m_float.convertToFloat();
1826 return (float_t)m_float.convertToDouble();
1828 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1829 return ldbl_val.bitsToFloat();
1834 double Scalar::Double(double fail_value) const {
1848 return m_integer.bitsToDouble();
1850 return (double_t)m_float.convertToFloat();
1852 return m_float.convertToDouble();
1854 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1855 return ldbl_val.bitsToFloat();
1860 long double Scalar::LongDouble(long double fail_value) const {
1874 return (long_double_t)m_integer.bitsToDouble();
1876 return (long_double_t)m_float.convertToFloat();
1878 return (long_double_t)m_float.convertToDouble();
1880 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1881 return (long_double_t)ldbl_val.bitsToDouble();
1886 Scalar &Scalar::operator+=(const Scalar &rhs) {
1890 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
1905 m_integer = a->m_integer + b->m_integer;
1911 m_float = a->m_float + b->m_float;
1918 Scalar &Scalar::operator<<=(const Scalar &rhs) {
1937 switch (rhs.m_type) {
1954 m_integer = m_integer << rhs.m_integer;
1962 bool Scalar::ShiftRightLogical(const Scalar &rhs) {
1981 switch (rhs.m_type) {
1998 m_integer = m_integer.lshr(rhs.m_integer);
2003 return m_type != e_void;
2006 Scalar &Scalar::operator>>=(const Scalar &rhs) {
2025 switch (rhs.m_type) {
2042 m_integer = m_integer.ashr(rhs.m_integer);
2050 Scalar &Scalar::operator&=(const Scalar &rhs) {
2069 switch (rhs.m_type) {
2086 m_integer &= rhs.m_integer;
2094 bool Scalar::AbsoluteValue() {
2104 if (m_integer.isNegative())
2105 m_integer = -m_integer;
2117 m_float.clearSign();
2123 bool Scalar::UnaryNegate() {
2137 m_integer = -m_integer;
2142 m_float.changeSign();
2148 bool Scalar::OnesComplement() {
2160 m_integer = ~m_integer;
2172 const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
2177 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2179 switch (result.m_type) {
2180 case Scalar::e_void:
2182 case Scalar::e_sint:
2183 case Scalar::e_uint:
2184 case Scalar::e_slong:
2185 case Scalar::e_ulong:
2186 case Scalar::e_slonglong:
2187 case Scalar::e_ulonglong:
2188 case Scalar::e_sint128:
2189 case Scalar::e_uint128:
2190 case Scalar::e_sint256:
2191 case Scalar::e_uint256:
2192 result.m_integer = a->m_integer + b->m_integer;
2194 case Scalar::e_float:
2195 case Scalar::e_double:
2196 case Scalar::e_long_double:
2197 result.m_float = a->m_float + b->m_float;
2204 const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
2209 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2211 switch (result.m_type) {
2212 case Scalar::e_void:
2214 case Scalar::e_sint:
2215 case Scalar::e_uint:
2216 case Scalar::e_slong:
2217 case Scalar::e_ulong:
2218 case Scalar::e_slonglong:
2219 case Scalar::e_ulonglong:
2220 case Scalar::e_sint128:
2221 case Scalar::e_uint128:
2222 case Scalar::e_sint256:
2223 case Scalar::e_uint256:
2224 result.m_integer = a->m_integer - b->m_integer;
2226 case Scalar::e_float:
2227 case Scalar::e_double:
2228 case Scalar::e_long_double:
2229 result.m_float = a->m_float - b->m_float;
2236 const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
2241 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2243 switch (result.m_type) {
2244 case Scalar::e_void:
2246 case Scalar::e_sint:
2247 case Scalar::e_slong:
2248 case Scalar::e_slonglong:
2249 case Scalar::e_sint128:
2250 case Scalar::e_sint256:
2251 if (b->m_integer != 0) {
2252 result.m_integer = a->m_integer.sdiv(b->m_integer);
2256 case Scalar::e_uint:
2257 case Scalar::e_ulong:
2258 case Scalar::e_ulonglong:
2259 case Scalar::e_uint128:
2260 case Scalar::e_uint256:
2261 if (b->m_integer != 0) {
2262 result.m_integer = a->m_integer.udiv(b->m_integer);
2266 case Scalar::e_float:
2267 case Scalar::e_double:
2268 case Scalar::e_long_double:
2269 if (b->m_float.isZero()) {
2270 result.m_float = a->m_float / b->m_float;
2276 // For division only, the only way it should make it here is if a promotion
2278 // or if we are trying to do a divide by zero.
2279 result.m_type = Scalar::e_void;
2283 const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
2288 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2290 switch (result.m_type) {
2291 case Scalar::e_void:
2293 case Scalar::e_sint:
2294 case Scalar::e_uint:
2295 case Scalar::e_slong:
2296 case Scalar::e_ulong:
2297 case Scalar::e_slonglong:
2298 case Scalar::e_ulonglong:
2299 case Scalar::e_sint128:
2300 case Scalar::e_uint128:
2301 case Scalar::e_sint256:
2302 case Scalar::e_uint256:
2303 result.m_integer = a->m_integer * b->m_integer;
2305 case Scalar::e_float:
2306 case Scalar::e_double:
2307 case Scalar::e_long_double:
2308 result.m_float = a->m_float * b->m_float;
2315 const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
2320 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2322 switch (result.m_type) {
2323 case Scalar::e_sint:
2324 case Scalar::e_uint:
2325 case Scalar::e_slong:
2326 case Scalar::e_ulong:
2327 case Scalar::e_slonglong:
2328 case Scalar::e_ulonglong:
2329 case Scalar::e_sint128:
2330 case Scalar::e_uint128:
2331 case Scalar::e_sint256:
2332 case Scalar::e_uint256:
2333 result.m_integer = a->m_integer & b->m_integer;
2335 case Scalar::e_void:
2336 case Scalar::e_float:
2337 case Scalar::e_double:
2338 case Scalar::e_long_double:
2339 // No bitwise AND on floats, doubles of long doubles
2340 result.m_type = Scalar::e_void;
2347 const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
2352 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2354 switch (result.m_type) {
2355 case Scalar::e_sint:
2356 case Scalar::e_uint:
2357 case Scalar::e_slong:
2358 case Scalar::e_ulong:
2359 case Scalar::e_slonglong:
2360 case Scalar::e_ulonglong:
2361 case Scalar::e_sint128:
2362 case Scalar::e_uint128:
2363 case Scalar::e_sint256:
2364 case Scalar::e_uint256:
2365 result.m_integer = a->m_integer | b->m_integer;
2368 case Scalar::e_void:
2369 case Scalar::e_float:
2370 case Scalar::e_double:
2371 case Scalar::e_long_double:
2372 // No bitwise AND on floats, doubles of long doubles
2373 result.m_type = Scalar::e_void;
2380 const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
2385 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2387 switch (result.m_type) {
2390 case Scalar::e_void:
2392 case Scalar::e_sint:
2393 case Scalar::e_slong:
2394 case Scalar::e_slonglong:
2395 case Scalar::e_sint128:
2396 case Scalar::e_sint256:
2397 if (b->m_integer != 0) {
2398 result.m_integer = a->m_integer.srem(b->m_integer);
2402 case Scalar::e_uint:
2403 case Scalar::e_ulong:
2404 case Scalar::e_ulonglong:
2405 case Scalar::e_uint128:
2406 case Scalar::e_uint256:
2407 if (b->m_integer != 0) {
2408 result.m_integer = a->m_integer.urem(b->m_integer);
2414 result.m_type = Scalar::e_void;
2418 const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
2423 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2425 switch (result.m_type) {
2426 case Scalar::e_sint:
2427 case Scalar::e_uint:
2428 case Scalar::e_slong:
2429 case Scalar::e_ulong:
2430 case Scalar::e_slonglong:
2431 case Scalar::e_ulonglong:
2432 case Scalar::e_sint128:
2433 case Scalar::e_uint128:
2434 case Scalar::e_sint256:
2435 case Scalar::e_uint256:
2436 result.m_integer = a->m_integer ^ b->m_integer;
2439 case Scalar::e_void:
2440 case Scalar::e_float:
2441 case Scalar::e_double:
2442 case Scalar::e_long_double:
2443 // No bitwise AND on floats, doubles of long doubles
2444 result.m_type = Scalar::e_void;
2451 const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
2452 Scalar result = lhs;
2457 const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
2458 Scalar result = lhs;
2463 Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
2466 if (value_str == nullptr || value_str[0] == '\0') {
2467 error.SetErrorString("Invalid c-string value string.");
2470 bool success = false;
2472 case eEncodingInvalid:
2473 error.SetErrorString("Invalid encoding.");
2477 if (byte_size <= sizeof(unsigned long long)) {
2479 StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
2481 error.SetErrorStringWithFormat(
2482 "'%s' is not a valid unsigned integer string value", value_str);
2483 else if (!UIntValueIsValidForSize(uval64, byte_size))
2484 error.SetErrorStringWithFormat("value 0x%" PRIx64
2485 " is too large to fit in a %" PRIu64
2486 " byte unsigned integer value",
2487 uval64, (uint64_t)byte_size);
2489 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
2492 m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
2495 m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
2498 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
2501 error.SetErrorStringWithFormat(
2502 "unsupported unsigned integer byte size: %" PRIu64 "",
2503 (uint64_t)byte_size);
2508 error.SetErrorStringWithFormat(
2509 "unsupported unsigned integer byte size: %" PRIu64 "",
2510 (uint64_t)byte_size);
2516 if (byte_size <= sizeof(long long)) {
2518 StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
2520 error.SetErrorStringWithFormat(
2521 "'%s' is not a valid signed integer string value", value_str);
2522 else if (!SIntValueIsValidForSize(sval64, byte_size))
2523 error.SetErrorStringWithFormat("value 0x%" PRIx64
2524 " is too large to fit in a %" PRIu64
2525 " byte signed integer value",
2526 sval64, (uint64_t)byte_size);
2528 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
2531 m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
2534 m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
2537 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
2540 error.SetErrorStringWithFormat(
2541 "unsupported signed integer byte size: %" PRIu64 "",
2542 (uint64_t)byte_size);
2547 error.SetErrorStringWithFormat(
2548 "unsupported signed integer byte size: %" PRIu64 "",
2549 (uint64_t)byte_size);
2554 case eEncodingIEEE754:
2556 static double d_val;
2557 static long double l_val;
2558 if (byte_size == sizeof(float)) {
2559 if (::sscanf(value_str, "%f", &f_val) == 1) {
2560 m_float = llvm::APFloat(f_val);
2563 error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2565 } else if (byte_size == sizeof(double)) {
2566 if (::sscanf(value_str, "%lf", &d_val) == 1) {
2567 m_float = llvm::APFloat(d_val);
2570 error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2572 } else if (byte_size == sizeof(long double)) {
2573 if (::sscanf(value_str, "%Lf", &l_val) == 1) {
2575 llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
2576 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
2577 ((type128 *)&l_val)->x));
2578 m_type = e_long_double;
2580 error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2583 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
2584 (uint64_t)byte_size);
2589 case eEncodingVector:
2590 error.SetErrorString("vector encoding unsupported.");
2599 Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
2606 case lldb::eEncodingInvalid:
2607 error.SetErrorString("invalid encoding");
2609 case lldb::eEncodingVector:
2610 error.SetErrorString("vector encoding unsupported");
2612 case lldb::eEncodingUint: {
2613 lldb::offset_t offset = 0;
2615 switch (byte_size) {
2617 operator=((uint8_t)data.GetU8(&offset));
2620 operator=((uint16_t)data.GetU16(&offset));
2623 operator=((uint32_t)data.GetU32(&offset));
2626 operator=((uint64_t)data.GetU64(&offset));
2629 if (data.GetByteOrder() == eByteOrderBig) {
2630 int128.x[1] = (uint64_t)data.GetU64(&offset);
2631 int128.x[0] = (uint64_t)data.GetU64(&offset);
2633 int128.x[0] = (uint64_t)data.GetU64(&offset);
2634 int128.x[1] = (uint64_t)data.GetU64(&offset);
2636 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2639 if (data.GetByteOrder() == eByteOrderBig) {
2640 int256.x[3] = (uint64_t)data.GetU64(&offset);
2641 int256.x[2] = (uint64_t)data.GetU64(&offset);
2642 int256.x[1] = (uint64_t)data.GetU64(&offset);
2643 int256.x[0] = (uint64_t)data.GetU64(&offset);
2645 int256.x[0] = (uint64_t)data.GetU64(&offset);
2646 int256.x[1] = (uint64_t)data.GetU64(&offset);
2647 int256.x[2] = (uint64_t)data.GetU64(&offset);
2648 int256.x[3] = (uint64_t)data.GetU64(&offset);
2650 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2653 error.SetErrorStringWithFormat(
2654 "unsupported unsigned integer byte size: %" PRIu64 "",
2655 (uint64_t)byte_size);
2659 case lldb::eEncodingSint: {
2660 lldb::offset_t offset = 0;
2662 switch (byte_size) {
2664 operator=((int8_t)data.GetU8(&offset));
2667 operator=((int16_t)data.GetU16(&offset));
2670 operator=((int32_t)data.GetU32(&offset));
2673 operator=((int64_t)data.GetU64(&offset));
2676 if (data.GetByteOrder() == eByteOrderBig) {
2677 int128.x[1] = (uint64_t)data.GetU64(&offset);
2678 int128.x[0] = (uint64_t)data.GetU64(&offset);
2680 int128.x[0] = (uint64_t)data.GetU64(&offset);
2681 int128.x[1] = (uint64_t)data.GetU64(&offset);
2683 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2686 if (data.GetByteOrder() == eByteOrderBig) {
2687 int256.x[3] = (uint64_t)data.GetU64(&offset);
2688 int256.x[2] = (uint64_t)data.GetU64(&offset);
2689 int256.x[1] = (uint64_t)data.GetU64(&offset);
2690 int256.x[0] = (uint64_t)data.GetU64(&offset);
2692 int256.x[0] = (uint64_t)data.GetU64(&offset);
2693 int256.x[1] = (uint64_t)data.GetU64(&offset);
2694 int256.x[2] = (uint64_t)data.GetU64(&offset);
2695 int256.x[3] = (uint64_t)data.GetU64(&offset);
2697 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2700 error.SetErrorStringWithFormat(
2701 "unsupported signed integer byte size: %" PRIu64 "",
2702 (uint64_t)byte_size);
2706 case lldb::eEncodingIEEE754: {
2707 lldb::offset_t offset = 0;
2709 if (byte_size == sizeof(float))
2710 operator=((float)data.GetFloat(&offset));
2711 else if (byte_size == sizeof(double))
2712 operator=((double)data.GetDouble(&offset));
2713 else if (byte_size == sizeof(long double))
2714 operator=((long double)data.GetLongDouble(&offset));
2716 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
2717 (uint64_t)byte_size);
2724 bool Scalar::SignExtend(uint32_t sign_bit_pos) {
2725 const uint32_t max_bit_pos = GetByteSize() * 8;
2727 if (sign_bit_pos < max_bit_pos) {
2729 case Scalar::e_void:
2730 case Scalar::e_float:
2731 case Scalar::e_double:
2732 case Scalar::e_long_double:
2735 case Scalar::e_sint:
2736 case Scalar::e_uint:
2737 case Scalar::e_slong:
2738 case Scalar::e_ulong:
2739 case Scalar::e_slonglong:
2740 case Scalar::e_ulonglong:
2741 case Scalar::e_sint128:
2742 case Scalar::e_uint128:
2743 case Scalar::e_sint256:
2744 case Scalar::e_uint256:
2745 if (max_bit_pos == sign_bit_pos)
2747 else if (sign_bit_pos < (max_bit_pos - 1)) {
2748 llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
2749 llvm::APInt bitwize_and = m_integer & sign_bit;
2750 if (bitwize_and.getBoolValue()) {
2751 const llvm::APInt mask =
2752 ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
2763 size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
2764 lldb::ByteOrder dst_byte_order,
2765 Status &error) const {
2766 // Get a data extractor that points to the native scalar data
2768 if (!GetData(data)) {
2769 error.SetErrorString("invalid scalar value");
2773 const size_t src_len = data.GetByteSize();
2775 // Prepare a memory buffer that contains some or all of the register value
2776 const size_t bytes_copied =
2777 data.CopyByteOrderedData(0, // src offset
2778 src_len, // src length
2780 dst_len, // dst length
2781 dst_byte_order); // dst byte order
2782 if (bytes_copied == 0)
2783 error.SetErrorString("failed to copy data");
2785 return bytes_copied;
2788 bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
2793 case Scalar::e_void:
2794 case Scalar::e_float:
2795 case Scalar::e_double:
2796 case Scalar::e_long_double:
2799 case Scalar::e_sint:
2800 case Scalar::e_slong:
2801 case Scalar::e_slonglong:
2802 case Scalar::e_sint128:
2803 case Scalar::e_sint256:
2804 m_integer = m_integer.ashr(bit_offset)
2805 .sextOrTrunc(bit_size)
2806 .sextOrSelf(8 * GetByteSize());
2809 case Scalar::e_uint:
2810 case Scalar::e_ulong:
2811 case Scalar::e_ulonglong:
2812 case Scalar::e_uint128:
2813 case Scalar::e_uint256:
2814 m_integer = m_integer.lshr(bit_offset)
2815 .zextOrTrunc(bit_size)
2816 .zextOrSelf(8 * GetByteSize());
2822 bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
2823 // If either entry is void then we can just compare the types
2824 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2825 return lhs.m_type == rhs.m_type;
2830 llvm::APFloat::cmpResult result;
2831 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2832 case Scalar::e_void:
2834 case Scalar::e_sint:
2835 case Scalar::e_uint:
2836 case Scalar::e_slong:
2837 case Scalar::e_ulong:
2838 case Scalar::e_slonglong:
2839 case Scalar::e_ulonglong:
2840 case Scalar::e_sint128:
2841 case Scalar::e_uint128:
2842 case Scalar::e_sint256:
2843 case Scalar::e_uint256:
2844 return a->m_integer == b->m_integer;
2845 case Scalar::e_float:
2846 case Scalar::e_double:
2847 case Scalar::e_long_double:
2848 result = a->m_float.compare(b->m_float);
2849 if (result == llvm::APFloat::cmpEqual)
2855 bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
2856 // If either entry is void then we can just compare the types
2857 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2858 return lhs.m_type != rhs.m_type;
2861 temp_value; // A temp value that might get a copy of either promoted value
2864 llvm::APFloat::cmpResult result;
2865 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2866 case Scalar::e_void:
2868 case Scalar::e_sint:
2869 case Scalar::e_uint:
2870 case Scalar::e_slong:
2871 case Scalar::e_ulong:
2872 case Scalar::e_slonglong:
2873 case Scalar::e_ulonglong:
2874 case Scalar::e_sint128:
2875 case Scalar::e_uint128:
2876 case Scalar::e_sint256:
2877 case Scalar::e_uint256:
2878 return a->m_integer != b->m_integer;
2879 case Scalar::e_float:
2880 case Scalar::e_double:
2881 case Scalar::e_long_double:
2882 result = a->m_float.compare(b->m_float);
2883 if (result != llvm::APFloat::cmpEqual)
2889 bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
2890 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2896 llvm::APFloat::cmpResult result;
2897 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2898 case Scalar::e_void:
2900 case Scalar::e_sint:
2901 case Scalar::e_slong:
2902 case Scalar::e_slonglong:
2903 case Scalar::e_sint128:
2904 case Scalar::e_sint256:
2905 return a->m_integer.slt(b->m_integer);
2906 case Scalar::e_uint:
2907 case Scalar::e_ulong:
2908 case Scalar::e_ulonglong:
2909 case Scalar::e_uint128:
2910 case Scalar::e_uint256:
2911 return a->m_integer.ult(b->m_integer);
2912 case Scalar::e_float:
2913 case Scalar::e_double:
2914 case Scalar::e_long_double:
2915 result = a->m_float.compare(b->m_float);
2916 if (result == llvm::APFloat::cmpLessThan)
2922 bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
2923 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2929 llvm::APFloat::cmpResult result;
2930 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2931 case Scalar::e_void:
2933 case Scalar::e_sint:
2934 case Scalar::e_slong:
2935 case Scalar::e_slonglong:
2936 case Scalar::e_sint128:
2937 case Scalar::e_sint256:
2938 return a->m_integer.sle(b->m_integer);
2939 case Scalar::e_uint:
2940 case Scalar::e_ulong:
2941 case Scalar::e_ulonglong:
2942 case Scalar::e_uint128:
2943 case Scalar::e_uint256:
2944 return a->m_integer.ule(b->m_integer);
2945 case Scalar::e_float:
2946 case Scalar::e_double:
2947 case Scalar::e_long_double:
2948 result = a->m_float.compare(b->m_float);
2949 if (result == llvm::APFloat::cmpLessThan ||
2950 result == llvm::APFloat::cmpEqual)
2956 bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
2957 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2963 llvm::APFloat::cmpResult result;
2964 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2965 case Scalar::e_void:
2967 case Scalar::e_sint:
2968 case Scalar::e_slong:
2969 case Scalar::e_slonglong:
2970 case Scalar::e_sint128:
2971 case Scalar::e_sint256:
2972 return a->m_integer.sgt(b->m_integer);
2973 case Scalar::e_uint:
2974 case Scalar::e_ulong:
2975 case Scalar::e_ulonglong:
2976 case Scalar::e_uint128:
2977 case Scalar::e_uint256:
2978 return a->m_integer.ugt(b->m_integer);
2979 case Scalar::e_float:
2980 case Scalar::e_double:
2981 case Scalar::e_long_double:
2982 result = a->m_float.compare(b->m_float);
2983 if (result == llvm::APFloat::cmpGreaterThan)
2989 bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
2990 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2996 llvm::APFloat::cmpResult result;
2997 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2998 case Scalar::e_void:
3000 case Scalar::e_sint:
3001 case Scalar::e_slong:
3002 case Scalar::e_slonglong:
3003 case Scalar::e_sint128:
3004 case Scalar::e_sint256:
3005 return a->m_integer.sge(b->m_integer);
3006 case Scalar::e_uint:
3007 case Scalar::e_ulong:
3008 case Scalar::e_ulonglong:
3009 case Scalar::e_uint128:
3010 case Scalar::e_uint256:
3011 return a->m_integer.uge(b->m_integer);
3012 case Scalar::e_float:
3013 case Scalar::e_double:
3014 case Scalar::e_long_double:
3015 result = a->m_float.compare(b->m_float);
3016 if (result == llvm::APFloat::cmpGreaterThan ||
3017 result == llvm::APFloat::cmpEqual)
3023 bool Scalar::ClearBit(uint32_t bit) {
3037 m_integer.clearBit(bit);
3047 bool Scalar::SetBit(uint32_t bit) {
3061 m_integer.setBit(bit);