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"
18 // Other libraries and framework includes
19 #include "llvm/ADT/SmallString.h"
22 #include "lldb/Interpreter/Args.h"
23 #include "lldb/Core/Error.h"
24 #include "lldb/Core/Stream.h"
25 #include "lldb/Core/DataExtractor.h"
26 #include "lldb/Host/Endian.h"
27 #include "lldb/Host/StringConvert.h"
29 #include "Plugins/Process/Utility/InstructionUtils.h"
32 using namespace lldb_private;
34 //----------------------------------------------------------------------
35 // Promote to max type currently follows the ANSI C rule for type
36 // promotion in expressions.
37 //----------------------------------------------------------------------
41 const Scalar& lhs, // The const left hand side object
42 const Scalar& rhs, // The const right hand side object
43 Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
44 const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
45 const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
49 // Initialize the promoted values for both the right and left hand side values
50 // to be the objects themselves. If no promotion is needed (both right and left
51 // have the same type), then the temp_value will not get used.
52 promoted_lhs_ptr = &lhs;
53 promoted_rhs_ptr = &rhs;
54 // Extract the types of both the right and left hand side values
55 Scalar::Type lhs_type = lhs.GetType();
56 Scalar::Type rhs_type = rhs.GetType();
58 if (lhs_type > rhs_type)
60 // Right hand side need to be promoted
61 temp_value = rhs; // Copy right hand side into the temp value
62 if (temp_value.Promote(lhs_type)) // Promote it
63 promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
65 else if (lhs_type < rhs_type)
67 // Left hand side need to be promoted
68 temp_value = lhs; // Copy left hand side value into the temp value
69 if (temp_value.Promote(rhs_type)) // Promote it
70 promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
73 // Make sure our type promotion worked as expected
74 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
75 return promoted_lhs_ptr->GetType(); // Return the resulting max type
77 // Return the void type (zero) if we fail to promote either of the values.
78 return Scalar::e_void;
87 Scalar::Scalar(const Scalar& rhs) :
89 m_integer(rhs.m_integer),
94 //Scalar::Scalar(const RegisterValue& reg) :
98 // switch (reg.info.encoding)
100 // case eEncodingUint: // unsigned integer
101 // switch (reg.info.byte_size)
103 // case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
104 // case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
105 // case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
106 // case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
111 // case eEncodingSint: // signed integer
112 // switch (reg.info.byte_size)
114 // case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
115 // case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
116 // case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
117 // case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
122 // case eEncodingIEEE754: // float
123 // switch (reg.info.byte_size)
125 // case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
126 // case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
130 // case eEncodingVector: // vector registers
136 Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
138 size_t byte_size = GetByteSize();
141 const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
143 if (limit_byte_size < byte_size)
145 if (endian::InlHostByteOrder() == eByteOrderLittle)
147 // On little endian systems if we want fewer bytes from the
148 // current type we just specify fewer bytes since the LSByte
150 byte_size = limit_byte_size;
152 else if (endian::InlHostByteOrder() == eByteOrderBig)
154 // On big endian systems if we want fewer bytes from the
155 // current type have to advance our initial byte pointer and
156 // trim down the number of bytes since the MSByte is first
157 bytes += byte_size - limit_byte_size;
158 byte_size = limit_byte_size;
162 data.SetData(bytes, byte_size, endian::InlHostByteOrder());
170 Scalar::GetBytes() const
172 const uint64_t *apint_words;
173 const uint8_t *bytes;
174 static float_t flt_val;
175 static double_t dbl_val;
176 static uint64_t swapped_words[4];
187 bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
188 // getRawData always returns a pointer to an uint64_t. If we have a smaller type,
189 // we need to update the pointer on big-endian systems.
190 if (endian::InlHostByteOrder() == eByteOrderBig)
192 size_t byte_size = m_integer.getBitWidth() / 8;
194 bytes += 8 - byte_size;
199 apint_words = m_integer.getRawData();
200 // getRawData always returns a pointer to an array of two uint64_t values,
201 // where the least-significant word always comes first. On big-endian
202 // systems we need to swap the two words.
203 if (endian::InlHostByteOrder() == eByteOrderBig)
205 swapped_words[0] = apint_words[1];
206 swapped_words[1] = apint_words[0];
207 apint_words = swapped_words;
209 return reinterpret_cast<const void *>(apint_words);
212 apint_words = m_integer.getRawData();
213 // getRawData always returns a pointer to an array of four uint64_t values,
214 // where the least-significant word always comes first. On big-endian
215 // systems we need to swap the four words.
216 if (endian::InlHostByteOrder() == eByteOrderBig)
218 swapped_words[0] = apint_words[3];
219 swapped_words[1] = apint_words[2];
220 swapped_words[2] = apint_words[1];
221 swapped_words[3] = apint_words[0];
222 apint_words = swapped_words;
224 return reinterpret_cast<const void *>(apint_words);
226 flt_val = m_float.convertToFloat();
227 return reinterpret_cast<const void *>(&flt_val);
229 dbl_val = m_float.convertToDouble();
230 return reinterpret_cast<const void *>(&dbl_val);
232 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
233 apint_words = ldbl_val.getRawData();
234 // getRawData always returns a pointer to an array of two uint64_t values,
235 // where the least-significant word always comes first. On big-endian
236 // systems we need to swap the two words.
237 if (endian::InlHostByteOrder() == eByteOrderBig)
239 swapped_words[0] = apint_words[1];
240 swapped_words[1] = apint_words[0];
241 apint_words = swapped_words;
243 return reinterpret_cast<const void *>(apint_words);
249 Scalar::GetByteSize() const
265 return (m_integer.getBitWidth() / 8);
266 case e_float: return sizeof(float_t);
267 case e_double: return sizeof(double_t);
268 case e_long_double: return sizeof(long_double_t);
274 Scalar::IsZero() const
276 llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
291 return llvm::APInt::isSameValue(zero_int, m_integer);
295 return m_float.isZero();
301 Scalar::GetValue (Stream *s, bool show_type) const
304 s->Printf("(%s) ", GetTypeAsCString());
315 s->Printf("%s",m_integer.toString(10,true).c_str());
322 s->Printf("%s",m_integer.toString(16,false).c_str());
327 llvm::SmallString<24> string;
328 m_float.toString(string);
329 s->Printf("%s", string.c_str());
335 Scalar::GetTypeAsCString() const
339 case e_void: return "void";
340 case e_sint: return "int";
341 case e_uint: return "unsigned int";
342 case e_slong: return "long";
343 case e_ulong: return "unsigned long";
344 case e_slonglong: return "long long";
345 case e_ulonglong: return "unsigned long long";
346 case e_sint128: return "int128_t";
347 case e_uint128: return "unsigned int128_t";
348 case e_sint256: return "int256_t";
349 case e_uint256: return "unsigned int256_t";
350 case e_float: return "float";
351 case e_double: return "double";
352 case e_long_double: return "long double";
354 return "<invalid Scalar type>";
358 Scalar::operator=(const Scalar& rhs)
363 m_integer = llvm::APInt(rhs.m_integer);
364 m_float = rhs.m_float;
370 Scalar::operator= (const int v)
373 m_integer = llvm::APInt(sizeof(int) * 8, v, true);
378 Scalar::operator= (unsigned int v)
381 m_integer = llvm::APInt(sizeof(int) * 8, v);
386 Scalar::operator= (long v)
389 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
394 Scalar::operator= (unsigned long v)
397 m_integer = llvm::APInt(sizeof(long) * 8, v);
402 Scalar::operator= (long long v)
404 m_type = e_slonglong;
405 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
410 Scalar::operator= (unsigned long long v)
412 m_type = e_ulonglong;
413 m_integer = llvm::APInt(sizeof(long long) * 8, v);
418 Scalar::operator= (float v)
421 m_float = llvm::APFloat(v);
426 Scalar::operator= (double v)
429 m_float = llvm::APFloat(v);
434 Scalar::operator= (long double v)
436 m_type = e_long_double;
438 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
440 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
445 Scalar::operator= (llvm::APInt rhs)
447 m_integer = llvm::APInt(rhs);
448 switch(m_integer.getBitWidth())
453 if(m_integer.isSignedIntN(sizeof(sint_t) * 8))
459 if(m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
460 m_type = e_slonglong;
462 m_type = e_ulonglong;
465 if(m_integer.isSignedIntN(BITWIDTH_INT128))
471 if(m_integer.isSignedIntN(BITWIDTH_INT256))
480 Scalar::~Scalar() = default;
483 Scalar::Promote(Scalar::Type type)
485 bool success = false;
495 case e_sint: success = true; break;
497 m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
502 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
507 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
512 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
517 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
523 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
529 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
534 m_float = llvm::APFloat(m_integer.bitsToFloat());
539 m_float = llvm::APFloat(m_integer.bitsToDouble());
545 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
547 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
558 case e_uint: success = true; break;
560 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
565 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
570 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
575 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
581 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
587 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
592 m_float = llvm::APFloat(m_integer.bitsToFloat());
597 m_float = llvm::APFloat(m_integer.bitsToDouble());
603 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
605 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
617 case e_slong: success = true; break;
619 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
624 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
629 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
635 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
641 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
646 m_float = llvm::APFloat(m_integer.bitsToFloat());
651 m_float = llvm::APFloat(m_integer.bitsToDouble());
657 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
659 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
672 case e_ulong: success = true; break;
674 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
679 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
685 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
691 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
696 m_float = llvm::APFloat(m_integer.bitsToFloat());
701 m_float = llvm::APFloat(m_integer.bitsToDouble());
707 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
709 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
723 case e_slonglong: success = true; break;
725 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
731 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
737 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
742 m_float = llvm::APFloat(m_integer.bitsToFloat());
747 m_float = llvm::APFloat(m_integer.bitsToDouble());
753 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
755 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
769 case e_slonglong: break;
770 case e_ulonglong: success = true; break;
773 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
779 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
784 m_float = llvm::APFloat(m_integer.bitsToFloat());
789 m_float = llvm::APFloat(m_integer.bitsToDouble());
795 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
797 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
812 case e_ulonglong: break;
813 case e_sint128: success = true; break;
815 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
821 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
826 m_float = llvm::APFloat(m_integer.bitsToFloat());
831 m_float = llvm::APFloat(m_integer.bitsToDouble());
837 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
839 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
855 case e_sint128: break;
856 case e_uint128: success = true; break;
859 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
864 m_float = llvm::APFloat(m_integer.bitsToFloat());
869 m_float = llvm::APFloat(m_integer.bitsToDouble());
875 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
877 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
894 case e_uint128: break;
895 case e_sint256: success = true; break;
897 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
902 m_float = llvm::APFloat(m_integer.bitsToFloat());
907 m_float = llvm::APFloat(m_integer.bitsToDouble());
913 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
915 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
933 case e_sint256: break;
934 case e_uint256: success = true; break;
936 m_float = llvm::APFloat(m_integer.bitsToFloat());
941 m_float = llvm::APFloat(m_integer.bitsToDouble());
947 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
949 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
968 case e_uint256: break;
969 case e_float: success = true; break;
971 m_float = llvm::APFloat((float_t)m_float.convertToFloat());
977 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
979 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
1000 case e_double: success = true; break;
1003 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
1005 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
1026 case e_double: break;
1027 case e_long_double: success = true; break;
1038 Scalar::GetValueTypeAsCString (Scalar::Type type)
1042 case e_void: return "void";
1043 case e_sint: return "int";
1044 case e_uint: return "unsigned int";
1045 case e_slong: return "long";
1046 case e_ulong: return "unsigned long";
1047 case e_slonglong: return "long long";
1048 case e_ulonglong: return "unsigned long long";
1049 case e_float: return "float";
1050 case e_double: return "double";
1051 case e_long_double: return "long double";
1052 case e_sint128: return "int128_t";
1053 case e_uint128: return "uint128_t";
1054 case e_sint256: return "int256_t";
1055 case e_uint256: return "uint256_t";
1061 Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
1063 if (byte_size <= sizeof(sint_t))
1065 if (byte_size <= sizeof(slong_t))
1067 if (byte_size <= sizeof(slonglong_t))
1073 Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
1075 if (byte_size <= sizeof(uint_t))
1077 if (byte_size <= sizeof(ulong_t))
1079 if (byte_size <= sizeof(ulonglong_t))
1085 Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
1087 if (byte_size == sizeof(float_t))
1089 if (byte_size == sizeof(double_t))
1091 if (byte_size == sizeof(long_double_t))
1092 return e_long_double;
1097 Scalar::Cast(Scalar::Type type)
1099 bool success = false;
1119 m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
1124 m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
1129 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
1134 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
1139 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
1144 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
1149 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
1154 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
1159 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
1164 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
1169 m_float = llvm::APFloat(m_integer.bitsToFloat());
1174 m_float = llvm::APFloat(m_integer.bitsToDouble());
1180 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_integer);
1182 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_integer);
1201 case e_uint256: m_integer = m_float.bitcastToAPInt(); success = true; break;
1202 case e_float: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break;
1203 case e_double: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break;
1206 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
1208 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
1227 case e_uint256: m_integer = m_float.bitcastToAPInt(); success = true; break;
1228 case e_float: m_float = llvm::APFloat(m_float.convertToDouble()); success = true; break;
1229 case e_double: m_float = llvm::APFloat(m_float.convertToDouble()); success = true; break;
1232 m_float = llvm::APFloat(llvm::APFloat::IEEEquad, m_float.bitcastToAPInt());
1234 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, m_float.bitcastToAPInt());
1245 m_integer = m_float.bitcastToAPInt();
1246 m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
1251 m_integer = m_float.bitcastToAPInt();
1252 m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
1257 m_integer = m_float.bitcastToAPInt();
1258 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
1263 m_integer = m_float.bitcastToAPInt();
1264 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
1269 m_integer = m_float.bitcastToAPInt();
1270 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
1275 m_integer = m_float.bitcastToAPInt();
1276 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
1281 m_integer = m_float.bitcastToAPInt();
1282 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
1287 m_integer = m_float.bitcastToAPInt();
1288 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
1293 m_integer = m_float.bitcastToAPInt();
1294 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
1299 m_integer = m_float.bitcastToAPInt();
1300 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
1304 case e_float: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break;
1305 case e_double: m_float = llvm::APFloat(m_float.convertToFloat()); success = true; break;
1306 case e_long_double: success = true; break;
1317 Scalar::MakeSigned ()
1319 bool success = false;
1324 case e_sint: success = true; break;
1325 case e_uint: m_type = e_sint; success = true; break;
1326 case e_slong: success = true; break;
1327 case e_ulong: m_type = e_slong; success = true; break;
1328 case e_slonglong: success = true; break;
1329 case e_ulonglong: m_type = e_slonglong; success = true; break;
1330 case e_sint128: success = true; break;
1331 case e_uint128: m_type = e_sint128; success = true; break;
1332 case e_sint256: success = true; break;
1333 case e_uint256: m_type = e_sint256; success = true; break;
1334 case e_float: success = true; break;
1335 case e_double: success = true; break;
1336 case e_long_double: success = true; break;
1343 Scalar::MakeUnsigned ()
1345 bool success = false;
1350 case e_sint: success = true; break;
1351 case e_uint: m_type = e_uint; success = true; break;
1352 case e_slong: success = true; break;
1353 case e_ulong: m_type = e_ulong; success = true; break;
1354 case e_slonglong: success = true; break;
1355 case e_ulonglong: m_type = e_ulonglong; success = true; break;
1356 case e_sint128: success = true; break;
1357 case e_uint128: m_type = e_uint128; success = true; break;
1358 case e_sint256: success = true; break;
1359 case e_uint256: m_type = e_uint256; success = true; break;
1360 case e_float: success = true; break;
1361 case e_double: success = true; break;
1362 case e_long_double: success = true; break;
1369 Scalar::SChar(char fail_value) const
1384 return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
1386 return (schar_t)m_float.convertToFloat();
1388 return (schar_t)m_float.convertToDouble();
1390 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1391 return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
1397 Scalar::UChar(unsigned char fail_value) const
1412 return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
1414 return (uchar_t)m_float.convertToFloat();
1416 return (uchar_t)m_float.convertToDouble();
1418 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1419 return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
1425 Scalar::SShort(short fail_value) const
1440 return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue();
1442 return (sshort_t)m_float.convertToFloat();
1444 return (sshort_t)m_float.convertToDouble();
1446 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1447 return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue();
1453 Scalar::UShort(unsigned short fail_value) const
1468 return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue();
1470 return (ushort_t)m_float.convertToFloat();
1472 return (ushort_t)m_float.convertToDouble();
1474 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1475 return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue();
1481 Scalar::SInt(int fail_value) const
1496 return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
1498 return (sint_t)m_float.convertToFloat();
1500 return (sint_t)m_float.convertToDouble();
1502 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1503 return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
1509 Scalar::UInt(unsigned int fail_value) const
1524 return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
1526 return (uint_t)m_float.convertToFloat();
1528 return (uint_t)m_float.convertToDouble();
1530 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1531 return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
1537 Scalar::SLong(long fail_value) const
1552 return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
1554 return (slong_t)m_float.convertToFloat();
1556 return (slong_t)m_float.convertToDouble();
1558 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1559 return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
1565 Scalar::ULong(unsigned long fail_value) const
1580 return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
1582 return (ulong_t)m_float.convertToFloat();
1584 return (ulong_t)m_float.convertToDouble();
1586 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1587 return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
1593 Scalar::SLongLong(long long fail_value) const
1608 return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue();
1610 return (slonglong_t)m_float.convertToFloat();
1612 return (slonglong_t)m_float.convertToDouble();
1614 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1615 return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue();
1621 Scalar::ULongLong(unsigned long long fail_value) const
1636 return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue();
1638 return (ulonglong_t)m_float.convertToFloat();
1640 return (ulonglong_t)m_float.convertToDouble();
1642 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1643 return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue();
1649 Scalar::SInt128(llvm::APInt& fail_value) const
1668 return m_float.bitcastToAPInt();
1674 Scalar::UInt128(const llvm::APInt& fail_value) const
1693 return m_float.bitcastToAPInt();
1699 Scalar::SInt256(llvm::APInt& fail_value) const
1718 return m_float.bitcastToAPInt();
1724 Scalar::UInt256(const llvm::APInt& fail_value) const
1743 return m_float.bitcastToAPInt();
1749 Scalar::Float(float fail_value) const
1764 return m_integer.bitsToFloat();
1766 return m_float.convertToFloat();
1768 return (float_t)m_float.convertToDouble();
1770 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1771 return ldbl_val.bitsToFloat();
1777 Scalar::Double(double fail_value) const
1792 return m_integer.bitsToDouble();
1794 return (double_t)m_float.convertToFloat();
1796 return m_float.convertToDouble();
1798 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1799 return ldbl_val.bitsToFloat();
1805 Scalar::LongDouble(long double fail_value) const
1820 return (long_double_t)m_integer.bitsToDouble();
1822 return (long_double_t)m_float.convertToFloat();
1824 return (long_double_t)m_float.convertToDouble();
1826 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1827 return (long_double_t)ldbl_val.bitsToDouble();
1833 Scalar::operator+= (const Scalar& rhs)
1838 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
1853 m_integer = a->m_integer + b->m_integer;
1859 m_float = a->m_float + b->m_float;
1867 Scalar::operator<<= (const Scalar& rhs)
1906 m_integer = m_integer << rhs.m_integer;
1915 Scalar::ShiftRightLogical(const Scalar& rhs)
1954 m_integer = m_integer.lshr(rhs.m_integer);
1959 return m_type != e_void;
1963 Scalar::operator>>= (const Scalar& rhs)
2002 m_integer = m_integer.ashr(rhs.m_integer);
2011 Scalar::operator&= (const Scalar& rhs)
2050 m_integer &= rhs.m_integer;
2059 Scalar::AbsoluteValue()
2071 if (m_integer.isNegative())
2072 m_integer = -m_integer;
2077 case e_ulonglong: return true;
2083 m_float.clearSign();
2090 Scalar::UnaryNegate()
2105 m_integer = -m_integer; return true;
2109 m_float.changeSign(); return true;
2115 Scalar::OnesComplement()
2129 m_integer = ~m_integer; return true;
2141 lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
2147 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2149 switch (result.m_type)
2151 case Scalar::e_void: break;
2152 case Scalar::e_sint:
2153 case Scalar::e_uint:
2154 case Scalar::e_slong:
2155 case Scalar::e_ulong:
2156 case Scalar::e_slonglong:
2157 case Scalar::e_ulonglong:
2158 case Scalar::e_sint128:
2159 case Scalar::e_uint128:
2160 case Scalar::e_sint256:
2161 case Scalar::e_uint256:
2162 result.m_integer = a->m_integer + b->m_integer; break;
2163 case Scalar::e_float:
2164 case Scalar::e_double:
2165 case Scalar::e_long_double:
2166 result.m_float = a->m_float + b->m_float; break;
2173 lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
2179 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2181 switch (result.m_type)
2183 case Scalar::e_void: break;
2184 case Scalar::e_sint:
2185 case Scalar::e_uint:
2186 case Scalar::e_slong:
2187 case Scalar::e_ulong:
2188 case Scalar::e_slonglong:
2189 case Scalar::e_ulonglong:
2190 case Scalar::e_sint128:
2191 case Scalar::e_uint128:
2192 case Scalar::e_sint256:
2193 case Scalar::e_uint256:
2194 result.m_integer = a->m_integer - b->m_integer; break;
2195 case Scalar::e_float:
2196 case Scalar::e_double:
2197 case Scalar::e_long_double:
2198 result.m_float = a->m_float - b->m_float; break;
2205 lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
2211 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2213 switch (result.m_type)
2215 case Scalar::e_void: break;
2216 case Scalar::e_sint:
2217 case Scalar::e_slong:
2218 case Scalar::e_slonglong:
2219 case Scalar::e_sint128:
2220 case Scalar::e_sint256:
2221 if (b->m_integer != 0)
2223 result.m_integer = a->m_integer.sdiv(b->m_integer);
2227 case Scalar::e_uint:
2228 case Scalar::e_ulong:
2229 case Scalar::e_ulonglong:
2230 case Scalar::e_uint128:
2231 case Scalar::e_uint256:
2232 if (b->m_integer != 0)
2234 result.m_integer = a->m_integer.udiv(b->m_integer);
2238 case Scalar::e_float:
2239 case Scalar::e_double:
2240 case Scalar::e_long_double:
2241 if (b->m_float.isZero())
2243 result.m_float = a->m_float / b->m_float;
2249 // For division only, the only way it should make it here is if a promotion failed,
2250 // or if we are trying to do a divide by zero.
2251 result.m_type = Scalar::e_void;
2256 lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
2262 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2264 switch (result.m_type)
2266 case Scalar::e_void: break;
2267 case Scalar::e_sint:
2268 case Scalar::e_uint:
2269 case Scalar::e_slong:
2270 case Scalar::e_ulong:
2271 case Scalar::e_slonglong:
2272 case Scalar::e_ulonglong:
2273 case Scalar::e_sint128:
2274 case Scalar::e_uint128:
2275 case Scalar::e_sint256:
2276 case Scalar::e_uint256:
2277 result.m_integer = a->m_integer * b->m_integer; break;
2278 case Scalar::e_float:
2279 case Scalar::e_double:
2280 case Scalar::e_long_double:
2281 result.m_float = a->m_float * b->m_float; break;
2288 lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
2294 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2296 switch (result.m_type)
2298 case Scalar::e_sint:
2299 case Scalar::e_uint:
2300 case Scalar::e_slong:
2301 case Scalar::e_ulong:
2302 case Scalar::e_slonglong:
2303 case Scalar::e_ulonglong:
2304 case Scalar::e_sint128:
2305 case Scalar::e_uint128:
2306 case Scalar::e_sint256:
2307 case Scalar::e_uint256:
2308 result.m_integer = a->m_integer & b->m_integer; break;
2309 case Scalar::e_void:
2310 case Scalar::e_float:
2311 case Scalar::e_double:
2312 case Scalar::e_long_double:
2313 // No bitwise AND on floats, doubles of long doubles
2314 result.m_type = Scalar::e_void;
2322 lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
2328 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2330 switch (result.m_type)
2332 case Scalar::e_sint:
2333 case Scalar::e_uint:
2334 case Scalar::e_slong:
2335 case Scalar::e_ulong:
2336 case Scalar::e_slonglong:
2337 case Scalar::e_ulonglong:
2338 case Scalar::e_sint128:
2339 case Scalar::e_uint128:
2340 case Scalar::e_sint256:
2341 case Scalar::e_uint256:
2342 result.m_integer = a->m_integer | b->m_integer; break;
2344 case Scalar::e_void:
2345 case Scalar::e_float:
2346 case Scalar::e_double:
2347 case Scalar::e_long_double:
2348 // No bitwise AND on floats, doubles of long doubles
2349 result.m_type = Scalar::e_void;
2357 lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
2363 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2365 switch (result.m_type)
2368 case Scalar::e_void: break;
2369 case Scalar::e_sint:
2370 case Scalar::e_slong:
2371 case Scalar::e_slonglong:
2372 case Scalar::e_sint128:
2373 case Scalar::e_sint256:
2374 if (b->m_integer != 0)
2376 result.m_integer = a->m_integer.srem(b->m_integer);
2380 case Scalar::e_uint:
2381 case Scalar::e_ulong:
2382 case Scalar::e_ulonglong:
2383 case Scalar::e_uint128:
2384 case Scalar::e_uint256:
2385 if (b->m_integer != 0)
2387 result.m_integer = a->m_integer.urem(b->m_integer);
2393 result.m_type = Scalar::e_void;
2398 lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
2404 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
2406 switch (result.m_type)
2408 case Scalar::e_sint:
2409 case Scalar::e_uint:
2410 case Scalar::e_slong:
2411 case Scalar::e_ulong:
2412 case Scalar::e_slonglong:
2413 case Scalar::e_ulonglong:
2414 case Scalar::e_sint128:
2415 case Scalar::e_uint128:
2416 case Scalar::e_sint256:
2417 case Scalar::e_uint256:
2418 result.m_integer = a->m_integer ^ b->m_integer; break;
2420 case Scalar::e_void:
2421 case Scalar::e_float:
2422 case Scalar::e_double:
2423 case Scalar::e_long_double:
2424 // No bitwise AND on floats, doubles of long doubles
2425 result.m_type = Scalar::e_void;
2433 lldb_private::operator<< (const Scalar& lhs, const Scalar &rhs)
2435 Scalar result = lhs;
2441 lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
2443 Scalar result = lhs;
2449 Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
2452 if (value_str == nullptr || value_str[0] == '\0')
2454 error.SetErrorString ("Invalid c-string value string.");
2457 bool success = false;
2460 case eEncodingInvalid:
2461 error.SetErrorString ("Invalid encoding.");
2465 if (byte_size <= sizeof (unsigned long long))
2467 uint64_t uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 0, &success);
2469 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
2470 else if (!UIntValueIsValidForSize (uval64, byte_size))
2471 error.SetErrorStringWithFormat("value 0x%" PRIx64 " is too large to fit in a %" PRIu64 " byte unsigned integer value", uval64, (uint64_t)byte_size);
2474 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
2477 case e_uint: m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false); break;
2478 case e_ulong: m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false); break;
2479 case e_ulonglong: m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false); break;
2481 error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
2488 error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
2494 if (byte_size <= sizeof (long long))
2496 uint64_t sval64 = StringConvert::ToSInt64(value_str, INT64_MAX, 0, &success);
2498 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
2499 else if (!SIntValueIsValidForSize (sval64, byte_size))
2500 error.SetErrorStringWithFormat("value 0x%" PRIx64 " is too large to fit in a %" PRIu64 " byte signed integer value", sval64, (uint64_t)byte_size);
2503 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
2506 case e_sint: m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true); break;
2507 case e_slong: m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true); break;
2508 case e_slonglong: m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true); break;
2510 error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
2517 error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
2522 case eEncodingIEEE754:
2524 static double d_val;
2525 static long double l_val;
2526 if (byte_size == sizeof (float))
2528 if (::sscanf (value_str, "%f", &f_val) == 1)
2530 m_float = llvm::APFloat(f_val);
2534 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
2536 else if (byte_size == sizeof (double))
2538 if (::sscanf (value_str, "%lf", &d_val) == 1)
2540 m_float = llvm::APFloat(d_val);
2544 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
2546 else if (byte_size == sizeof (long double))
2548 if (::sscanf (value_str, "%Lf", &l_val) == 1)
2550 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended, llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&l_val)->x));
2551 m_type = e_long_double;
2554 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
2558 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "", (uint64_t)byte_size);
2563 case eEncodingVector:
2564 error.SetErrorString ("vector encoding unsupported.");
2574 Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size)
2582 case lldb::eEncodingInvalid:
2583 error.SetErrorString ("invalid encoding");
2585 case lldb::eEncodingVector:
2586 error.SetErrorString ("vector encoding unsupported");
2588 case lldb::eEncodingUint:
2590 lldb::offset_t offset = 0;
2594 case 1: operator=((uint8_t)data.GetU8(&offset)); break;
2595 case 2: operator=((uint16_t)data.GetU16(&offset)); break;
2596 case 4: operator=((uint32_t)data.GetU32(&offset)); break;
2597 case 8: operator=((uint64_t)data.GetU64(&offset)); break;
2599 if (data.GetByteOrder() == eByteOrderBig)
2601 int128.x[1] = (uint64_t)data.GetU64 (&offset);
2602 int128.x[0] = (uint64_t)data.GetU64 (&offset);
2606 int128.x[0] = (uint64_t)data.GetU64 (&offset);
2607 int128.x[1] = (uint64_t)data.GetU64 (&offset);
2609 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2612 if (data.GetByteOrder() == eByteOrderBig)
2614 int256.x[3] = (uint64_t)data.GetU64 (&offset);
2615 int256.x[2] = (uint64_t)data.GetU64 (&offset);
2616 int256.x[1] = (uint64_t)data.GetU64 (&offset);
2617 int256.x[0] = (uint64_t)data.GetU64 (&offset);
2621 int256.x[0] = (uint64_t)data.GetU64 (&offset);
2622 int256.x[1] = (uint64_t)data.GetU64 (&offset);
2623 int256.x[2] = (uint64_t)data.GetU64 (&offset);
2624 int256.x[3] = (uint64_t)data.GetU64 (&offset);
2626 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2629 error.SetErrorStringWithFormat("unsupported unsigned integer byte size: %" PRIu64 "", (uint64_t)byte_size);
2634 case lldb::eEncodingSint:
2636 lldb::offset_t offset = 0;
2640 case 1: operator=((int8_t)data.GetU8(&offset)); break;
2641 case 2: operator=((int16_t)data.GetU16(&offset)); break;
2642 case 4: operator=((int32_t)data.GetU32(&offset)); break;
2643 case 8: operator=((int64_t)data.GetU64(&offset)); break;
2645 if (data.GetByteOrder() == eByteOrderBig)
2647 int128.x[1] = (uint64_t)data.GetU64 (&offset);
2648 int128.x[0] = (uint64_t)data.GetU64 (&offset);
2652 int128.x[0] = (uint64_t)data.GetU64 (&offset);
2653 int128.x[1] = (uint64_t)data.GetU64 (&offset);
2655 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2658 if (data.GetByteOrder() == eByteOrderBig)
2660 int256.x[3] = (uint64_t)data.GetU64 (&offset);
2661 int256.x[2] = (uint64_t)data.GetU64 (&offset);
2662 int256.x[1] = (uint64_t)data.GetU64 (&offset);
2663 int256.x[0] = (uint64_t)data.GetU64 (&offset);
2667 int256.x[0] = (uint64_t)data.GetU64 (&offset);
2668 int256.x[1] = (uint64_t)data.GetU64 (&offset);
2669 int256.x[2] = (uint64_t)data.GetU64 (&offset);
2670 int256.x[3] = (uint64_t)data.GetU64 (&offset);
2672 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2675 error.SetErrorStringWithFormat("unsupported signed integer byte size: %" PRIu64 "", (uint64_t)byte_size);
2680 case lldb::eEncodingIEEE754:
2682 lldb::offset_t offset = 0;
2684 if (byte_size == sizeof (float))
2685 operator=((float)data.GetFloat(&offset));
2686 else if (byte_size == sizeof (double))
2687 operator=((double)data.GetDouble(&offset));
2688 else if (byte_size == sizeof (long double))
2689 operator=((long double)data.GetLongDouble(&offset));
2691 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "", (uint64_t)byte_size);
2700 Scalar::SignExtend (uint32_t sign_bit_pos)
2702 const uint32_t max_bit_pos = GetByteSize() * 8;
2704 if (sign_bit_pos < max_bit_pos)
2708 case Scalar::e_void:
2709 case Scalar::e_float:
2710 case Scalar::e_double:
2711 case Scalar::e_long_double:
2714 case Scalar::e_sint:
2715 case Scalar::e_uint:
2716 case Scalar::e_slong:
2717 case Scalar::e_ulong:
2718 case Scalar::e_slonglong:
2719 case Scalar::e_ulonglong:
2720 case Scalar::e_sint128:
2721 case Scalar::e_uint128:
2722 case Scalar::e_sint256:
2723 case Scalar::e_uint256:
2724 if (max_bit_pos == sign_bit_pos)
2726 else if (sign_bit_pos < (max_bit_pos-1))
2728 llvm::APInt sign_bit = llvm::APInt::getSignBit(sign_bit_pos + 1);
2729 llvm::APInt bitwize_and = m_integer & sign_bit;
2730 if (bitwize_and.getBoolValue())
2732 const llvm::APInt mask = ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
2744 Scalar::GetAsMemoryData (void *dst,
2746 lldb::ByteOrder dst_byte_order,
2749 // Get a data extractor that points to the native scalar data
2753 error.SetErrorString ("invalid scalar value");
2757 const size_t src_len = data.GetByteSize();
2759 // Prepare a memory buffer that contains some or all of the register value
2760 const size_t bytes_copied = data.CopyByteOrderedData (0, // src offset
2761 src_len, // src length
2763 dst_len, // dst length
2764 dst_byte_order); // dst byte order
2765 if (bytes_copied == 0)
2766 error.SetErrorString ("failed to copy data");
2768 return bytes_copied;
2772 Scalar::ExtractBitfield (uint32_t bit_size,
2773 uint32_t bit_offset)
2780 case Scalar::e_void:
2781 case Scalar::e_float:
2782 case Scalar::e_double:
2783 case Scalar::e_long_double:
2786 case Scalar::e_sint:
2787 case Scalar::e_slong:
2788 case Scalar::e_slonglong:
2789 case Scalar::e_sint128:
2790 case Scalar::e_sint256:
2791 m_integer = m_integer.ashr(bit_offset).sextOrTrunc(bit_size).sextOrSelf(8 * GetByteSize());
2794 case Scalar::e_uint:
2795 case Scalar::e_ulong:
2796 case Scalar::e_ulonglong:
2797 case Scalar::e_uint128:
2798 case Scalar::e_uint256:
2799 m_integer = m_integer.lshr(bit_offset).zextOrTrunc(bit_size).zextOrSelf(8 * GetByteSize());
2806 lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
2808 // If either entry is void then we can just compare the types
2809 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2810 return lhs.m_type == rhs.m_type;
2815 llvm::APFloat::cmpResult result;
2816 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2818 case Scalar::e_void: break;
2819 case Scalar::e_sint:
2820 case Scalar::e_uint:
2821 case Scalar::e_slong:
2822 case Scalar::e_ulong:
2823 case Scalar::e_slonglong:
2824 case Scalar::e_ulonglong:
2825 case Scalar::e_sint128:
2826 case Scalar::e_uint128:
2827 case Scalar::e_sint256:
2828 case Scalar::e_uint256:
2829 return a->m_integer == b->m_integer;
2830 case Scalar::e_float:
2831 case Scalar::e_double:
2832 case Scalar::e_long_double:
2833 result = a->m_float.compare(b->m_float);
2834 if(result == llvm::APFloat::cmpEqual)
2841 lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
2843 // If either entry is void then we can just compare the types
2844 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2845 return lhs.m_type != rhs.m_type;
2847 Scalar temp_value; // A temp value that might get a copy of either promoted value
2850 llvm::APFloat::cmpResult result;
2851 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2853 case Scalar::e_void: break;
2854 case Scalar::e_sint:
2855 case Scalar::e_uint:
2856 case Scalar::e_slong:
2857 case Scalar::e_ulong:
2858 case Scalar::e_slonglong:
2859 case Scalar::e_ulonglong:
2860 case Scalar::e_sint128:
2861 case Scalar::e_uint128:
2862 case Scalar::e_sint256:
2863 case Scalar::e_uint256:
2864 return a->m_integer != b->m_integer;
2865 case Scalar::e_float:
2866 case Scalar::e_double:
2867 case Scalar::e_long_double:
2868 result = a->m_float.compare(b->m_float);
2869 if(result != llvm::APFloat::cmpEqual)
2876 lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
2878 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2884 llvm::APFloat::cmpResult result;
2885 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2887 case Scalar::e_void: break;
2888 case Scalar::e_sint:
2889 case Scalar::e_slong:
2890 case Scalar::e_slonglong:
2891 case Scalar::e_sint128:
2892 case Scalar::e_sint256:
2893 return a->m_integer.slt(b->m_integer);
2894 case Scalar::e_uint:
2895 case Scalar::e_ulong:
2896 case Scalar::e_ulonglong:
2897 case Scalar::e_uint128:
2898 case Scalar::e_uint256:
2899 return a->m_integer.ult(b->m_integer);
2900 case Scalar::e_float:
2901 case Scalar::e_double:
2902 case Scalar::e_long_double:
2903 result = a->m_float.compare(b->m_float);
2904 if(result == llvm::APFloat::cmpLessThan)
2911 lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
2913 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2919 llvm::APFloat::cmpResult result;
2920 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2922 case Scalar::e_void: break;
2923 case Scalar::e_sint:
2924 case Scalar::e_slong:
2925 case Scalar::e_slonglong:
2926 case Scalar::e_sint128:
2927 case Scalar::e_sint256:
2928 return a->m_integer.sle(b->m_integer);
2929 case Scalar::e_uint:
2930 case Scalar::e_ulong:
2931 case Scalar::e_ulonglong:
2932 case Scalar::e_uint128:
2933 case Scalar::e_uint256:
2934 return a->m_integer.ule(b->m_integer);
2935 case Scalar::e_float:
2936 case Scalar::e_double:
2937 case Scalar::e_long_double:
2938 result = a->m_float.compare(b->m_float);
2939 if(result == llvm::APFloat::cmpLessThan || result == llvm::APFloat::cmpEqual)
2946 lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
2948 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2954 llvm::APFloat::cmpResult result;
2955 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2957 case Scalar::e_void: break;
2958 case Scalar::e_sint:
2959 case Scalar::e_slong:
2960 case Scalar::e_slonglong:
2961 case Scalar::e_sint128:
2962 case Scalar::e_sint256:
2963 return a->m_integer.sgt(b->m_integer);
2964 case Scalar::e_uint:
2965 case Scalar::e_ulong:
2966 case Scalar::e_ulonglong:
2967 case Scalar::e_uint128:
2968 case Scalar::e_uint256:
2969 return a->m_integer.ugt(b->m_integer);
2970 case Scalar::e_float:
2971 case Scalar::e_double:
2972 case Scalar::e_long_double:
2973 result = a->m_float.compare(b->m_float);
2974 if(result == llvm::APFloat::cmpGreaterThan)
2981 lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
2983 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2989 llvm::APFloat::cmpResult result;
2990 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2992 case Scalar::e_void: break;
2993 case Scalar::e_sint:
2994 case Scalar::e_slong:
2995 case Scalar::e_slonglong:
2996 case Scalar::e_sint128:
2997 case Scalar::e_sint256:
2998 return a->m_integer.sge(b->m_integer);
2999 case Scalar::e_uint:
3000 case Scalar::e_ulong:
3001 case Scalar::e_ulonglong:
3002 case Scalar::e_uint128:
3003 case Scalar::e_uint256:
3004 return a->m_integer.uge(b->m_integer);
3005 case Scalar::e_float:
3006 case Scalar::e_double:
3007 case Scalar::e_long_double:
3008 result = a->m_float.compare(b->m_float);
3009 if(result == llvm::APFloat::cmpGreaterThan || result == llvm::APFloat::cmpEqual)
3016 Scalar::ClearBit (uint32_t bit)
3031 case e_uint256: m_integer.clearBit(bit); return true;
3034 case e_long_double: break;
3040 Scalar::SetBit (uint32_t bit)
3055 case e_uint256: m_integer.setBit(bit); return true;
3058 case e_long_double: break;