blob: 3393af921ddac3d3fc9b14a6fa73a7f2d2ca1f04 [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Chris Lattner30fdc8d2010-06-08 16:52:24 +00006//
7//===----------------------------------------------------------------------===//
8
Pavel Labathd821c992018-08-07 11:07:21 +00009#include "lldb/Utility/Scalar.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000010
Zachary Turner666cc0b2017-03-04 01:30:05 +000011#include "lldb/Utility/DataExtractor.h"
Zachary Turner01c32432017-02-14 19:06:07 +000012#include "lldb/Utility/Endian.h"
Zachary Turner97206d52017-05-12 04:51:55 +000013#include "lldb/Utility/Status.h"
Zachary Turnerbf9a7732017-02-02 21:39:50 +000014#include "lldb/Utility/Stream.h"
Pavel Labathb07a7992019-04-29 10:55:22 +000015#include "lldb/Utility/StreamString.h"
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000016#include "lldb/lldb-types.h"
Zachary Turner2f3df612017-04-06 21:28:29 +000017
18#include "llvm/ADT/SmallString.h"
19
20#include <cinttypes>
21#include <cstdio>
Chris Lattner30fdc8d2010-06-08 16:52:24 +000022
23using namespace lldb;
24using namespace lldb_private;
25
Adrian Prantl05097242018-04-30 16:49:04 +000026// Promote to max type currently follows the ANSI C rule for type promotion in
27// expressions.
Kate Stoneb9c1b512016-09-06 20:57:50 +000028static Scalar::Type PromoteToMaxType(
29 const Scalar &lhs, // The const left hand side object
30 const Scalar &rhs, // The const right hand side object
31 Scalar &temp_value, // A modifiable temp value than can be used to hold
32 // either the promoted lhs or rhs object
33 const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
34 // promoted value of lhs (at most one of
35 // lhs/rhs will get promoted)
36 const Scalar *&promoted_rhs_ptr // Pointer to the resulting possibly
37 // promoted value of rhs (at most one of
38 // lhs/rhs will get promoted)
Pavel Labathd821c992018-08-07 11:07:21 +000039) {
Kate Stoneb9c1b512016-09-06 20:57:50 +000040 Scalar result;
Adrian Prantl05097242018-04-30 16:49:04 +000041 // Initialize the promoted values for both the right and left hand side
42 // values to be the objects themselves. If no promotion is needed (both right
43 // and left have the same type), then the temp_value will not get used.
Kate Stoneb9c1b512016-09-06 20:57:50 +000044 promoted_lhs_ptr = &lhs;
45 promoted_rhs_ptr = &rhs;
46 // Extract the types of both the right and left hand side values
47 Scalar::Type lhs_type = lhs.GetType();
48 Scalar::Type rhs_type = rhs.GetType();
Chris Lattner30fdc8d2010-06-08 16:52:24 +000049
Kate Stoneb9c1b512016-09-06 20:57:50 +000050 if (lhs_type > rhs_type) {
51 // Right hand side need to be promoted
52 temp_value = rhs; // Copy right hand side into the temp value
53 if (temp_value.Promote(lhs_type)) // Promote it
54 promoted_rhs_ptr =
55 &temp_value; // Update the pointer for the promoted right hand side
56 } else if (lhs_type < rhs_type) {
57 // Left hand side need to be promoted
58 temp_value = lhs; // Copy left hand side value into the temp value
59 if (temp_value.Promote(rhs_type)) // Promote it
60 promoted_lhs_ptr =
61 &temp_value; // Update the pointer for the promoted left hand side
62 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +000063
Kate Stoneb9c1b512016-09-06 20:57:50 +000064 // Make sure our type promotion worked as expected
65 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
66 return promoted_lhs_ptr->GetType(); // Return the resulting max type
Chris Lattner30fdc8d2010-06-08 16:52:24 +000067
Kate Stoneb9c1b512016-09-06 20:57:50 +000068 // Return the void type (zero) if we fail to promote either of the values.
69 return Scalar::e_void;
Chris Lattner30fdc8d2010-06-08 16:52:24 +000070}
71
Jonas Devlieghere24374ae2019-05-23 05:12:11 +000072Scalar::Scalar() : m_type(e_void), m_float(static_cast<float>(0)) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +000073
Kate Stoneb9c1b512016-09-06 20:57:50 +000074bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
75 size_t byte_size = GetByteSize();
76 if (byte_size > 0) {
77 const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
Ulrich Weigand9521ad22016-04-15 09:55:52 +000078
Kate Stoneb9c1b512016-09-06 20:57:50 +000079 if (limit_byte_size < byte_size) {
80 if (endian::InlHostByteOrder() == eByteOrderLittle) {
Adrian Prantl05097242018-04-30 16:49:04 +000081 // On little endian systems if we want fewer bytes from the current
82 // type we just specify fewer bytes since the LSByte is first...
Kate Stoneb9c1b512016-09-06 20:57:50 +000083 byte_size = limit_byte_size;
84 } else if (endian::InlHostByteOrder() == eByteOrderBig) {
Adrian Prantl05097242018-04-30 16:49:04 +000085 // On big endian systems if we want fewer bytes from the current type
86 // have to advance our initial byte pointer and trim down the number of
87 // bytes since the MSByte is first
Kate Stoneb9c1b512016-09-06 20:57:50 +000088 bytes += byte_size - limit_byte_size;
89 byte_size = limit_byte_size;
90 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +000091 }
Kate Stoneb9c1b512016-09-06 20:57:50 +000092
93 data.SetData(bytes, byte_size, endian::InlHostByteOrder());
94 return true;
95 }
96 data.Clear();
97 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +000098}
99
Kate Stoneb9c1b512016-09-06 20:57:50 +0000100const void *Scalar::GetBytes() const {
101 const uint64_t *apint_words;
102 const uint8_t *bytes;
103 static float_t flt_val;
104 static double_t dbl_val;
Davide Italiano51d46bd2019-01-30 18:05:36 +0000105 static uint64_t swapped_words[8];
Kate Stoneb9c1b512016-09-06 20:57:50 +0000106 switch (m_type) {
107 case e_void:
108 break;
109 case e_sint:
110 case e_uint:
111 case e_slong:
112 case e_ulong:
113 case e_slonglong:
114 case e_ulonglong:
115 bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
Adrian Prantl05097242018-04-30 16:49:04 +0000116 // getRawData always returns a pointer to an uint64_t. If we have a
117 // smaller type, we need to update the pointer on big-endian systems.
Kate Stoneb9c1b512016-09-06 20:57:50 +0000118 if (endian::InlHostByteOrder() == eByteOrderBig) {
119 size_t byte_size = m_integer.getBitWidth() / 8;
120 if (byte_size < 8)
121 bytes += 8 - byte_size;
Sagar Thakur8536fd12015-08-20 09:12:46 +0000122 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000123 return bytes;
Davide Italiano92a470e2019-01-30 18:24:16 +0000124 // getRawData always returns a pointer to an array of uint64_t values,
125 // where the least-significant word always comes first. On big-endian
126 // systems we need to swap the words.
Kate Stoneb9c1b512016-09-06 20:57:50 +0000127 case e_sint128:
128 case e_uint128:
129 apint_words = m_integer.getRawData();
Kate Stoneb9c1b512016-09-06 20:57:50 +0000130 if (endian::InlHostByteOrder() == eByteOrderBig) {
131 swapped_words[0] = apint_words[1];
132 swapped_words[1] = apint_words[0];
133 apint_words = swapped_words;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000134 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000135 return reinterpret_cast<const void *>(apint_words);
136 case e_sint256:
137 case e_uint256:
138 apint_words = m_integer.getRawData();
Kate Stoneb9c1b512016-09-06 20:57:50 +0000139 if (endian::InlHostByteOrder() == eByteOrderBig) {
140 swapped_words[0] = apint_words[3];
141 swapped_words[1] = apint_words[2];
142 swapped_words[2] = apint_words[1];
143 swapped_words[3] = apint_words[0];
144 apint_words = swapped_words;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000145 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000146 return reinterpret_cast<const void *>(apint_words);
Davide Italiano51d46bd2019-01-30 18:05:36 +0000147 case e_sint512:
148 case e_uint512:
149 apint_words = m_integer.getRawData();
Davide Italiano51d46bd2019-01-30 18:05:36 +0000150 if (endian::InlHostByteOrder() == eByteOrderBig) {
151 swapped_words[0] = apint_words[7];
152 swapped_words[1] = apint_words[6];
153 swapped_words[2] = apint_words[5];
154 swapped_words[3] = apint_words[4];
155 swapped_words[4] = apint_words[3];
156 swapped_words[5] = apint_words[2];
157 swapped_words[6] = apint_words[1];
158 swapped_words[7] = apint_words[0];
159 apint_words = swapped_words;
160 }
161 return reinterpret_cast<const void *>(apint_words);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000162 case e_float:
163 flt_val = m_float.convertToFloat();
164 return reinterpret_cast<const void *>(&flt_val);
165 case e_double:
166 dbl_val = m_float.convertToDouble();
167 return reinterpret_cast<const void *>(&dbl_val);
168 case e_long_double:
169 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
170 apint_words = ldbl_val.getRawData();
171 // getRawData always returns a pointer to an array of two uint64_t values,
172 // where the least-significant word always comes first. On big-endian
173 // systems we need to swap the two words.
174 if (endian::InlHostByteOrder() == eByteOrderBig) {
175 swapped_words[0] = apint_words[1];
176 swapped_words[1] = apint_words[0];
177 apint_words = swapped_words;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000178 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000179 return reinterpret_cast<const void *>(apint_words);
180 }
181 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000182}
183
Kate Stoneb9c1b512016-09-06 20:57:50 +0000184size_t Scalar::GetByteSize() const {
185 switch (m_type) {
186 case e_void:
187 break;
188 case e_sint:
189 case e_uint:
190 case e_slong:
191 case e_ulong:
192 case e_slonglong:
193 case e_ulonglong:
194 case e_sint128:
195 case e_uint128:
196 case e_sint256:
197 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +0000198 case e_sint512:
199 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000200 return (m_integer.getBitWidth() / 8);
201 case e_float:
202 return sizeof(float_t);
203 case e_double:
204 return sizeof(double_t);
205 case e_long_double:
206 return sizeof(long_double_t);
207 }
208 return 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000209}
210
Kate Stoneb9c1b512016-09-06 20:57:50 +0000211bool Scalar::IsZero() const {
212 llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
213 switch (m_type) {
214 case e_void:
215 break;
216 case e_sint:
217 case e_uint:
218 case e_slong:
219 case e_ulong:
220 case e_slonglong:
221 case e_ulonglong:
222 case e_sint128:
223 case e_uint128:
224 case e_sint256:
225 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +0000226 case e_uint512:
227 case e_sint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000228 return llvm::APInt::isSameValue(zero_int, m_integer);
229 case e_float:
230 case e_double:
231 case e_long_double:
232 return m_float.isZero();
233 }
234 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000235}
236
Kate Stoneb9c1b512016-09-06 20:57:50 +0000237void Scalar::GetValue(Stream *s, bool show_type) const {
238 if (show_type)
239 s->Printf("(%s) ", GetTypeAsCString());
240
241 switch (m_type) {
242 case e_void:
243 break;
244 case e_sint:
245 case e_slong:
246 case e_slonglong:
247 case e_sint128:
248 case e_sint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +0000249 case e_sint512:
Malcolm Parsons771ef6d2016-11-02 20:34:10 +0000250 s->PutCString(m_integer.toString(10, true));
Kate Stoneb9c1b512016-09-06 20:57:50 +0000251 break;
252 case e_uint:
253 case e_ulong:
254 case e_ulonglong:
255 case e_uint128:
256 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +0000257 case e_uint512:
Malcolm Parsons771ef6d2016-11-02 20:34:10 +0000258 s->PutCString(m_integer.toString(10, false));
Kate Stoneb9c1b512016-09-06 20:57:50 +0000259 break;
260 case e_float:
261 case e_double:
262 case e_long_double:
263 llvm::SmallString<24> string;
264 m_float.toString(string);
265 s->Printf("%s", string.c_str());
266 break;
267 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000268}
269
Kate Stoneb9c1b512016-09-06 20:57:50 +0000270const char *Scalar::GetTypeAsCString() const {
271 switch (m_type) {
272 case e_void:
273 return "void";
274 case e_sint:
275 return "int";
276 case e_uint:
277 return "unsigned int";
278 case e_slong:
279 return "long";
280 case e_ulong:
281 return "unsigned long";
282 case e_slonglong:
283 return "long long";
284 case e_ulonglong:
285 return "unsigned long long";
286 case e_sint128:
287 return "int128_t";
288 case e_uint128:
289 return "unsigned int128_t";
290 case e_sint256:
291 return "int256_t";
292 case e_uint256:
293 return "unsigned int256_t";
Davide Italiano51d46bd2019-01-30 18:05:36 +0000294 case e_sint512:
295 return "int512_t";
296 case e_uint512:
297 return "unsigned int512_t";
Kate Stoneb9c1b512016-09-06 20:57:50 +0000298 case e_float:
299 return "float";
300 case e_double:
301 return "double";
302 case e_long_double:
303 return "long double";
304 }
305 return "<invalid Scalar type>";
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000306}
307
Kate Stoneb9c1b512016-09-06 20:57:50 +0000308Scalar &Scalar::operator=(const Scalar &rhs) {
309 if (this != &rhs) {
310 m_type = rhs.m_type;
311 m_integer = llvm::APInt(rhs.m_integer);
312 m_float = rhs.m_float;
313 }
314 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000315}
316
Kate Stoneb9c1b512016-09-06 20:57:50 +0000317Scalar &Scalar::operator=(const int v) {
318 m_type = e_sint;
319 m_integer = llvm::APInt(sizeof(int) * 8, v, true);
320 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000321}
322
Kate Stoneb9c1b512016-09-06 20:57:50 +0000323Scalar &Scalar::operator=(unsigned int v) {
324 m_type = e_uint;
325 m_integer = llvm::APInt(sizeof(int) * 8, v);
326 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000327}
328
Kate Stoneb9c1b512016-09-06 20:57:50 +0000329Scalar &Scalar::operator=(long v) {
330 m_type = e_slong;
331 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
332 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000333}
334
Kate Stoneb9c1b512016-09-06 20:57:50 +0000335Scalar &Scalar::operator=(unsigned long v) {
336 m_type = e_ulong;
337 m_integer = llvm::APInt(sizeof(long) * 8, v);
338 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000339}
340
Kate Stoneb9c1b512016-09-06 20:57:50 +0000341Scalar &Scalar::operator=(long long v) {
342 m_type = e_slonglong;
343 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
344 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000345}
346
Kate Stoneb9c1b512016-09-06 20:57:50 +0000347Scalar &Scalar::operator=(unsigned long long v) {
348 m_type = e_ulonglong;
349 m_integer = llvm::APInt(sizeof(long long) * 8, v);
350 return *this;
351}
352
353Scalar &Scalar::operator=(float v) {
354 m_type = e_float;
355 m_float = llvm::APFloat(v);
356 return *this;
357}
358
359Scalar &Scalar::operator=(double v) {
360 m_type = e_double;
361 m_float = llvm::APFloat(v);
362 return *this;
363}
364
365Scalar &Scalar::operator=(long double v) {
366 m_type = e_long_double;
367 if (m_ieee_quad)
Jonas Devlieghere24374ae2019-05-23 05:12:11 +0000368 m_float = llvm::APFloat(llvm::APFloat::IEEEquad(),
369 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
370 (reinterpret_cast<type128 *>(&v))->x));
Kate Stoneb9c1b512016-09-06 20:57:50 +0000371 else
Jonas Devlieghere24374ae2019-05-23 05:12:11 +0000372 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
373 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
374 (reinterpret_cast<type128 *>(&v))->x));
Kate Stoneb9c1b512016-09-06 20:57:50 +0000375 return *this;
376}
377
378Scalar &Scalar::operator=(llvm::APInt rhs) {
379 m_integer = llvm::APInt(rhs);
380 switch (m_integer.getBitWidth()) {
381 case 8:
382 case 16:
383 case 32:
384 if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
385 m_type = e_sint;
Sagar Thakur8536fd12015-08-20 09:12:46 +0000386 else
Kate Stoneb9c1b512016-09-06 20:57:50 +0000387 m_type = e_uint;
388 break;
389 case 64:
390 if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
391 m_type = e_slonglong;
392 else
393 m_type = e_ulonglong;
394 break;
395 case 128:
396 if (m_integer.isSignedIntN(BITWIDTH_INT128))
397 m_type = e_sint128;
398 else
399 m_type = e_uint128;
400 break;
401 case 256:
402 if (m_integer.isSignedIntN(BITWIDTH_INT256))
403 m_type = e_sint256;
404 else
405 m_type = e_uint256;
406 break;
Davide Italiano51d46bd2019-01-30 18:05:36 +0000407 case 512:
408 if (m_integer.isSignedIntN(BITWIDTH_INT512))
409 m_type = e_sint512;
410 else
411 m_type = e_uint512;
412 break;
Kate Stoneb9c1b512016-09-06 20:57:50 +0000413 }
414 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000415}
416
Eugene Zelenko0e28a192016-03-12 00:31:13 +0000417Scalar::~Scalar() = default;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000418
Adrian Prantl9b23df62019-09-10 16:17:38 +0000419Scalar::Type Scalar::GetBestTypeForBitSize(size_t bit_size, bool sign) {
420 // Scalar types are always host types, hence the sizeof().
421 if (sign) {
422 if (bit_size <= sizeof(int)*8) return Scalar::e_sint;
423 if (bit_size <= sizeof(long)*8) return Scalar::e_slong;
424 if (bit_size <= sizeof(long long)*8) return Scalar::e_slonglong;
425 if (bit_size <= 128) return Scalar::e_sint128;
426 if (bit_size <= 256) return Scalar::e_sint256;
427 if (bit_size <= 512) return Scalar::e_sint512;
428 } else {
429 if (bit_size <= sizeof(unsigned int)*8) return Scalar::e_uint;
430 if (bit_size <= sizeof(unsigned long)*8) return Scalar::e_ulong;
431 if (bit_size <= sizeof(unsigned long long)*8) return Scalar::e_ulonglong;
432 if (bit_size <= 128) return Scalar::e_uint128;
433 if (bit_size <= 256) return Scalar::e_uint256;
434 if (bit_size <= 512) return Scalar::e_uint512;
435 }
436 return Scalar::e_void;
437};
438
439void Scalar::TruncOrExtendTo(Scalar::Type type, uint16_t bits) {
440 switch (type) {
441 case e_sint:
442 case e_slong:
443 case e_slonglong:
444 case e_sint128:
445 case e_sint256:
446 case e_sint512:
447 m_integer = m_integer.sextOrTrunc(bits);
448 break;
449 case e_uint:
450 case e_ulong:
451 case e_ulonglong:
452 case e_uint128:
453 case e_uint256:
454 case e_uint512:
455 m_integer = m_integer.zextOrTrunc(bits);
456 break;
457 default:
458 llvm_unreachable("Promoting a Scalar to a specific number of bits is only "
459 "supported for integer types.");
460 }
461 m_type = type;
462}
463
Kate Stoneb9c1b512016-09-06 20:57:50 +0000464bool Scalar::Promote(Scalar::Type type) {
465 bool success = false;
466 switch (m_type) {
467 case e_void:
468 break;
469
470 case e_sint:
471 switch (type) {
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000472 case e_void:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000473 break;
Oleksiy Vyalov9dcdd2e2015-08-10 21:49:50 +0000474 case e_sint:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000475 success = true;
476 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000477 case e_uint:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000478 m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
479 success = true;
480 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000481
482 case e_slong:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000483 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
484 success = true;
485 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000486
487 case e_ulong:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000488 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
489 success = true;
490 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000491
492 case e_slonglong:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000493 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
494 success = true;
495 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000496
497 case e_ulonglong:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000498 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
499 success = true;
500 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +0000501
502 case e_sint128:
Sagar Thakur8536fd12015-08-20 09:12:46 +0000503 case e_uint128:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000504 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
505 success = true;
506 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000507
Enrico Granata391075c2016-03-10 00:14:29 +0000508 case e_sint256:
Enrico Granata391075c2016-03-10 00:14:29 +0000509 case e_uint256:
Kate Stoneb9c1b512016-09-06 20:57:50 +0000510 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
511 success = true;
512 break;
Eugene Zelenko0e28a192016-03-12 00:31:13 +0000513
Davide Italiano51d46bd2019-01-30 18:05:36 +0000514 case e_sint512:
515 case e_uint512:
516 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
517 success = true;
518 break;
519
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000520 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000521 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
522 m_float.convertFromAPInt(m_integer, true,
523 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000524 success = true;
525 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000526
527 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000528 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
529 m_float.convertFromAPInt(m_integer, true,
530 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000531 success = true;
532 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000533
534 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000535 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
536 : llvm::APFloat::x87DoubleExtended());
537 m_float.convertFromAPInt(m_integer, true,
538 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000539 success = true;
540 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000541 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000542 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000543
Kate Stoneb9c1b512016-09-06 20:57:50 +0000544 case e_uint:
545 switch (type) {
546 case e_void:
547 case e_sint:
548 break;
549 case e_uint:
550 success = true;
551 break;
552 case e_slong:
553 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
554 success = true;
555 break;
556
557 case e_ulong:
558 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
559 success = true;
560 break;
561
562 case e_slonglong:
563 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
564 success = true;
565 break;
566
567 case e_ulonglong:
568 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
569 success = true;
570 break;
571
572 case e_sint128:
573 case e_uint128:
574 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
575 success = true;
576 break;
577
578 case e_sint256:
579 case e_uint256:
580 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
581 success = true;
582 break;
583
Davide Italiano51d46bd2019-01-30 18:05:36 +0000584 case e_sint512:
585 case e_uint512:
586 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
587 success = true;
588 break;
589
Kate Stoneb9c1b512016-09-06 20:57:50 +0000590 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000591 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
592 m_float.convertFromAPInt(m_integer, false,
593 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000594 success = true;
595 break;
596
597 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000598 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
599 m_float.convertFromAPInt(m_integer, false,
600 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000601 success = true;
602 break;
603
604 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000605 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
606 : llvm::APFloat::x87DoubleExtended());
607 m_float.convertFromAPInt(m_integer, false,
608 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000609 success = true;
610 break;
611 }
612 break;
613
614 case e_slong:
615 switch (type) {
616 case e_void:
617 case e_sint:
618 case e_uint:
619 break;
620 case e_slong:
621 success = true;
622 break;
623 case e_ulong:
624 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
625 success = true;
626 break;
627
628 case e_slonglong:
629 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
630 success = true;
631 break;
632
633 case e_ulonglong:
634 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
635 success = true;
636 break;
637
638 case e_sint128:
639 case e_uint128:
640 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
641 success = true;
642 break;
643
644 case e_sint256:
645 case e_uint256:
646 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
647 success = true;
648 break;
649
Davide Italiano51d46bd2019-01-30 18:05:36 +0000650 case e_sint512:
651 case e_uint512:
652 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
653 success = true;
654 break;
655
Kate Stoneb9c1b512016-09-06 20:57:50 +0000656 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000657 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
658 m_float.convertFromAPInt(m_integer, true,
659 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000660 success = true;
661 break;
662
663 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000664 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
665 m_float.convertFromAPInt(m_integer, true,
666 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000667 success = true;
668 break;
669
670 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000671 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
672 : llvm::APFloat::x87DoubleExtended());
673 m_float.convertFromAPInt(m_integer, true,
674 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000675 success = true;
676 break;
677 }
678 break;
679
680 case e_ulong:
681 switch (type) {
682 case e_void:
683 case e_sint:
684 case e_uint:
685 case e_slong:
686 break;
687 case e_ulong:
688 success = true;
689 break;
690 case e_slonglong:
691 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
692 success = true;
693 break;
694
695 case e_ulonglong:
696 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
697 success = true;
698 break;
699
700 case e_sint128:
701 case e_uint128:
702 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
703 success = true;
704 break;
705
706 case e_sint256:
707 case e_uint256:
708 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
709 success = true;
710 break;
711
Davide Italiano51d46bd2019-01-30 18:05:36 +0000712 case e_sint512:
713 case e_uint512:
714 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
715 success = true;
716 break;
717
Kate Stoneb9c1b512016-09-06 20:57:50 +0000718 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000719 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
720 m_float.convertFromAPInt(m_integer, false,
721 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000722 success = true;
723 break;
724
725 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000726 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
727 m_float.convertFromAPInt(m_integer, false,
728 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000729 success = true;
730 break;
731
732 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000733 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
734 : llvm::APFloat::x87DoubleExtended());
735 m_float.convertFromAPInt(m_integer, false,
736 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000737 success = true;
738 break;
739 }
740 break;
741
742 case e_slonglong:
743 switch (type) {
744 case e_void:
745 case e_sint:
746 case e_uint:
747 case e_slong:
748 case e_ulong:
749 break;
750 case e_slonglong:
751 success = true;
752 break;
753 case e_ulonglong:
754 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
755 success = true;
756 break;
757
758 case e_sint128:
759 case e_uint128:
760 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
761 success = true;
762 break;
763
764 case e_sint256:
765 case e_uint256:
766 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
767 success = true;
768 break;
769
Davide Italiano51d46bd2019-01-30 18:05:36 +0000770 case e_sint512:
771 case e_uint512:
772 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
773 success = true;
774 break;
775
Kate Stoneb9c1b512016-09-06 20:57:50 +0000776 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000777 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
778 m_float.convertFromAPInt(m_integer, true,
779 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000780 success = true;
781 break;
782
783 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000784 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
785 m_float.convertFromAPInt(m_integer, true,
786 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000787 success = true;
788 break;
789
790 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000791 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
792 : llvm::APFloat::x87DoubleExtended());
793 m_float.convertFromAPInt(m_integer, true,
794 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000795 success = true;
796 break;
797 }
798 break;
799
800 case e_ulonglong:
801 switch (type) {
802 case e_void:
803 case e_sint:
804 case e_uint:
805 case e_slong:
806 case e_ulong:
807 case e_slonglong:
808 break;
809 case e_ulonglong:
810 success = true;
811 break;
812 case e_sint128:
813 case e_uint128:
814 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
815 success = true;
816 break;
817
818 case e_sint256:
819 case e_uint256:
820 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
821 success = true;
822 break;
823
Davide Italiano51d46bd2019-01-30 18:05:36 +0000824 case e_sint512:
825 case e_uint512:
826 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
827 success = true;
828 break;
829
Kate Stoneb9c1b512016-09-06 20:57:50 +0000830 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000831 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
832 m_float.convertFromAPInt(m_integer, false,
833 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000834 success = true;
835 break;
836
837 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000838 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
839 m_float.convertFromAPInt(m_integer, false,
840 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000841 success = true;
842 break;
843
844 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000845 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
846 : llvm::APFloat::x87DoubleExtended());
847 m_float.convertFromAPInt(m_integer, false,
848 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000849 success = true;
850 break;
851 }
852 break;
853
854 case e_sint128:
855 switch (type) {
856 case e_void:
857 case e_sint:
858 case e_uint:
859 case e_slong:
860 case e_ulong:
861 case e_slonglong:
862 case e_ulonglong:
863 break;
864 case e_sint128:
865 success = true;
866 break;
867 case e_uint128:
868 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
869 success = true;
870 break;
871
872 case e_sint256:
873 case e_uint256:
874 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
875 success = true;
876 break;
877
Davide Italiano51d46bd2019-01-30 18:05:36 +0000878 case e_sint512:
879 case e_uint512:
880 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
881 success = true;
882 break;
883
Kate Stoneb9c1b512016-09-06 20:57:50 +0000884 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000885 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
886 m_float.convertFromAPInt(m_integer, true,
887 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000888 success = true;
889 break;
890
891 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000892 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
893 m_float.convertFromAPInt(m_integer, true,
894 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000895 success = true;
896 break;
897
898 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000899 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
900 : llvm::APFloat::x87DoubleExtended());
901 m_float.convertFromAPInt(m_integer, true,
902 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000903 success = true;
904 break;
905 }
906 break;
907
908 case e_uint128:
909 switch (type) {
910 case e_void:
911 case e_sint:
912 case e_uint:
913 case e_slong:
914 case e_ulong:
915 case e_slonglong:
916 case e_ulonglong:
917 case e_sint128:
918 break;
919 case e_uint128:
920 success = true;
921 break;
922 case e_sint256:
923 case e_uint256:
924 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
925 success = true;
926 break;
927
Davide Italiano51d46bd2019-01-30 18:05:36 +0000928 case e_sint512:
929 case e_uint512:
930 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
931 success = true;
932 break;
933
Kate Stoneb9c1b512016-09-06 20:57:50 +0000934 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000935 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
936 m_float.convertFromAPInt(m_integer, false,
937 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000938 success = true;
939 break;
940
941 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000942 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
943 m_float.convertFromAPInt(m_integer, false,
944 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000945 success = true;
946 break;
947
948 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000949 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
950 : llvm::APFloat::x87DoubleExtended());
951 m_float.convertFromAPInt(m_integer, false,
952 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000953 success = true;
954 break;
955 }
956 break;
957
958 case e_sint256:
959 switch (type) {
960 case e_void:
961 case e_sint:
962 case e_uint:
963 case e_slong:
964 case e_ulong:
965 case e_slonglong:
966 case e_ulonglong:
967 case e_sint128:
968 case e_uint128:
969 break;
970 case e_sint256:
971 success = true;
972 break;
973 case e_uint256:
974 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
975 success = true;
976 break;
977
Davide Italiano51d46bd2019-01-30 18:05:36 +0000978 case e_sint512:
979 case e_uint512:
980 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
981 success = true;
982 break;
983
Kate Stoneb9c1b512016-09-06 20:57:50 +0000984 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +0000985 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
986 m_float.convertFromAPInt(m_integer, true,
987 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000988 success = true;
989 break;
990
991 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000992 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
993 m_float.convertFromAPInt(m_integer, true,
994 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +0000995 success = true;
996 break;
997
998 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +0000999 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
1000 : llvm::APFloat::x87DoubleExtended());
1001 m_float.convertFromAPInt(m_integer, true,
1002 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001003 success = true;
1004 break;
1005 }
1006 break;
1007
1008 case e_uint256:
1009 switch (type) {
1010 case e_void:
1011 case e_sint:
1012 case e_uint:
1013 case e_slong:
1014 case e_ulong:
1015 case e_slonglong:
1016 case e_ulonglong:
1017 case e_sint128:
1018 case e_uint128:
1019 case e_sint256:
1020 break;
1021 case e_uint256:
1022 success = true;
1023 break;
Davide Italiano51d46bd2019-01-30 18:05:36 +00001024
1025 case e_sint512:
1026 case e_uint512:
1027 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
1028 success = true;
1029 break;
1030
Kate Stoneb9c1b512016-09-06 20:57:50 +00001031 case e_float:
Davide Italiano49d80282018-04-02 16:50:54 +00001032 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
1033 m_float.convertFromAPInt(m_integer, false,
1034 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001035 success = true;
1036 break;
1037
1038 case e_double:
Davide Italiano49d80282018-04-02 16:50:54 +00001039 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
1040 m_float.convertFromAPInt(m_integer, false,
1041 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001042 success = true;
1043 break;
1044
1045 case e_long_double:
Davide Italiano49d80282018-04-02 16:50:54 +00001046 m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
1047 : llvm::APFloat::x87DoubleExtended());
1048 m_float.convertFromAPInt(m_integer, false,
1049 llvm::APFloat::rmNearestTiesToEven);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001050 success = true;
1051 break;
1052 }
1053 break;
1054
Davide Italiano51d46bd2019-01-30 18:05:36 +00001055 case e_sint512:
1056 case e_uint512:
1057 lldbassert(false && "unimplemented");
1058 break;
1059
Kate Stoneb9c1b512016-09-06 20:57:50 +00001060 case e_float:
1061 switch (type) {
1062 case e_void:
1063 case e_sint:
1064 case e_uint:
1065 case e_slong:
1066 case e_ulong:
1067 case e_slonglong:
1068 case e_ulonglong:
1069 case e_sint128:
1070 case e_uint128:
1071 case e_sint256:
1072 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001073 case e_uint512:
1074 case e_sint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001075 break;
1076 case e_float:
1077 success = true;
1078 break;
1079 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001080 m_float = llvm::APFloat(static_cast<double_t>(m_float.convertToFloat()));
Kate Stoneb9c1b512016-09-06 20:57:50 +00001081 success = true;
1082 break;
1083
Davide Italiano49d80282018-04-02 16:50:54 +00001084 case e_long_double: {
1085 bool ignore;
1086 m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
1087 : llvm::APFloat::x87DoubleExtended(),
1088 llvm::APFloat::rmNearestTiesToEven, &ignore);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001089 success = true;
1090 break;
1091 }
Davide Italiano49d80282018-04-02 16:50:54 +00001092 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001093 break;
1094
1095 case e_double:
1096 switch (type) {
1097 case e_void:
1098 case e_sint:
1099 case e_uint:
1100 case e_slong:
1101 case e_ulong:
1102 case e_slonglong:
1103 case e_ulonglong:
1104 case e_sint128:
1105 case e_uint128:
1106 case e_sint256:
1107 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001108 case e_sint512:
1109 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001110 case e_float:
1111 break;
1112 case e_double:
1113 success = true;
1114 break;
Davide Italiano49d80282018-04-02 16:50:54 +00001115 case e_long_double: {
1116 bool ignore;
1117 m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
1118 : llvm::APFloat::x87DoubleExtended(),
1119 llvm::APFloat::rmNearestTiesToEven, &ignore);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001120 success = true;
1121 break;
1122 }
Davide Italiano49d80282018-04-02 16:50:54 +00001123 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001124 break;
1125
1126 case e_long_double:
1127 switch (type) {
1128 case e_void:
1129 case e_sint:
1130 case e_uint:
1131 case e_slong:
1132 case e_ulong:
1133 case e_slonglong:
1134 case e_ulonglong:
1135 case e_sint128:
1136 case e_uint128:
1137 case e_sint256:
1138 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001139 case e_sint512:
1140 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001141 case e_float:
1142 case e_double:
1143 break;
1144 case e_long_double:
1145 success = true;
1146 break;
1147 }
1148 break;
1149 }
1150
1151 if (success)
1152 m_type = type;
1153 return success;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001154}
1155
Kate Stoneb9c1b512016-09-06 20:57:50 +00001156const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
1157 switch (type) {
1158 case e_void:
1159 return "void";
1160 case e_sint:
1161 return "int";
1162 case e_uint:
1163 return "unsigned int";
1164 case e_slong:
1165 return "long";
1166 case e_ulong:
1167 return "unsigned long";
1168 case e_slonglong:
1169 return "long long";
1170 case e_ulonglong:
1171 return "unsigned long long";
1172 case e_float:
1173 return "float";
1174 case e_double:
1175 return "double";
1176 case e_long_double:
1177 return "long double";
1178 case e_sint128:
1179 return "int128_t";
1180 case e_uint128:
1181 return "uint128_t";
1182 case e_sint256:
1183 return "int256_t";
1184 case e_uint256:
1185 return "uint256_t";
Davide Italiano51d46bd2019-01-30 18:05:36 +00001186 case e_sint512:
1187 return "int512_t";
1188 case e_uint512:
1189 return "uint512_t";
Kate Stoneb9c1b512016-09-06 20:57:50 +00001190 }
1191 return "???";
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001192}
1193
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001194Scalar::Type
Kate Stoneb9c1b512016-09-06 20:57:50 +00001195Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
1196 if (byte_size <= sizeof(sint_t))
1197 return e_sint;
1198 if (byte_size <= sizeof(slong_t))
1199 return e_slong;
1200 if (byte_size <= sizeof(slonglong_t))
1201 return e_slonglong;
1202 return e_void;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001203}
1204
1205Scalar::Type
Kate Stoneb9c1b512016-09-06 20:57:50 +00001206Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
1207 if (byte_size <= sizeof(uint_t))
1208 return e_uint;
1209 if (byte_size <= sizeof(ulong_t))
1210 return e_ulong;
1211 if (byte_size <= sizeof(ulonglong_t))
1212 return e_ulonglong;
1213 return e_void;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001214}
1215
Kate Stoneb9c1b512016-09-06 20:57:50 +00001216Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
1217 if (byte_size == sizeof(float_t))
1218 return e_float;
1219 if (byte_size == sizeof(double_t))
1220 return e_double;
1221 if (byte_size == sizeof(long_double_t))
1222 return e_long_double;
1223 return e_void;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001224}
1225
Kate Stoneb9c1b512016-09-06 20:57:50 +00001226bool Scalar::MakeSigned() {
1227 bool success = false;
1228
1229 switch (m_type) {
1230 case e_void:
1231 break;
1232 case e_sint:
1233 success = true;
1234 break;
1235 case e_uint:
1236 m_type = e_sint;
1237 success = true;
1238 break;
1239 case e_slong:
1240 success = true;
1241 break;
1242 case e_ulong:
1243 m_type = e_slong;
1244 success = true;
1245 break;
1246 case e_slonglong:
1247 success = true;
1248 break;
1249 case e_ulonglong:
1250 m_type = e_slonglong;
1251 success = true;
1252 break;
1253 case e_sint128:
1254 success = true;
1255 break;
1256 case e_uint128:
1257 m_type = e_sint128;
1258 success = true;
1259 break;
1260 case e_sint256:
1261 success = true;
1262 break;
1263 case e_uint256:
1264 m_type = e_sint256;
1265 success = true;
1266 break;
Davide Italiano51d46bd2019-01-30 18:05:36 +00001267 case e_sint512:
1268 success = true;
1269 break;
1270 case e_uint512:
1271 m_type = e_sint512;
1272 success = true;
1273 break;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001274 case e_float:
1275 success = true;
1276 break;
1277 case e_double:
1278 success = true;
1279 break;
1280 case e_long_double:
1281 success = true;
1282 break;
1283 }
1284
1285 return success;
1286}
1287
1288bool Scalar::MakeUnsigned() {
1289 bool success = false;
1290
1291 switch (m_type) {
1292 case e_void:
1293 break;
1294 case e_sint:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001295 m_type = e_uint;
1296 success = true;
1297 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001298 case e_uint:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001299 success = true;
1300 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001301 case e_slong:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001302 m_type = e_ulong;
1303 success = true;
1304 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001305 case e_ulong:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001306 success = true;
1307 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001308 case e_slonglong:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001309 m_type = e_ulonglong;
1310 success = true;
1311 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001312 case e_ulonglong:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001313 success = true;
1314 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001315 case e_sint128:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001316 m_type = e_uint128;
1317 success = true;
1318 break;
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001319 case e_uint128:
1320 success = true;
1321 break;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001322 case e_sint256:
Davide Italianoa9d84cb2018-07-12 00:31:04 +00001323 m_type = e_uint256;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001324 success = true;
1325 break;
1326 case e_uint256:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001327 success = true;
1328 break;
Davide Italiano51d46bd2019-01-30 18:05:36 +00001329 case e_sint512:
1330 m_type = e_uint512;
1331 success = true;
1332 break;
1333 case e_uint512:
1334 success = true;
1335 break;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001336 case e_float:
1337 success = true;
1338 break;
1339 case e_double:
1340 success = true;
1341 break;
1342 case e_long_double:
1343 success = true;
1344 break;
1345 }
1346
1347 return success;
1348}
1349
1350signed char Scalar::SChar(char fail_value) const {
1351 switch (m_type) {
1352 case e_void:
1353 break;
1354 case e_sint:
1355 case e_uint:
1356 case e_slong:
1357 case e_ulong:
1358 case e_slonglong:
1359 case e_ulonglong:
1360 case e_sint128:
1361 case e_uint128:
1362 case e_sint256:
1363 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001364 case e_sint512:
1365 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001366 return static_cast<schar_t>(
1367 (m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001368 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001369 return static_cast<schar_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001370 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001371 return static_cast<schar_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001372 case e_long_double:
1373 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001374 return static_cast<schar_t>(
1375 (ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001376 }
1377 return fail_value;
1378}
1379
1380unsigned char Scalar::UChar(unsigned char fail_value) const {
1381 switch (m_type) {
1382 case e_void:
1383 break;
1384 case e_sint:
1385 case e_uint:
1386 case e_slong:
1387 case e_ulong:
1388 case e_slonglong:
1389 case e_ulonglong:
1390 case e_sint128:
1391 case e_uint128:
1392 case e_sint256:
1393 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001394 case e_sint512:
1395 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001396 return static_cast<uchar_t>(
1397 (m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001398 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001399 return static_cast<uchar_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001400 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001401 return static_cast<uchar_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001402 case e_long_double:
1403 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001404 return static_cast<uchar_t>(
1405 (ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001406 }
1407 return fail_value;
1408}
1409
1410short Scalar::SShort(short fail_value) const {
1411 switch (m_type) {
1412 case e_void:
1413 break;
1414 case e_sint:
1415 case e_uint:
1416 case e_slong:
1417 case e_ulong:
1418 case e_slonglong:
1419 case e_ulonglong:
1420 case e_sint128:
1421 case e_uint128:
1422 case e_sint256:
1423 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001424 case e_sint512:
1425 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001426 return static_cast<sshort_t>(
1427 (m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001428 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001429 return static_cast<sshort_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001430 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001431 return static_cast<sshort_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001432 case e_long_double:
1433 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001434 return static_cast<sshort_t>(
1435 (ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001436 }
1437 return fail_value;
1438}
1439
1440unsigned short Scalar::UShort(unsigned short fail_value) const {
1441 switch (m_type) {
1442 case e_void:
1443 break;
1444 case e_sint:
1445 case e_uint:
1446 case e_slong:
1447 case e_ulong:
1448 case e_slonglong:
1449 case e_ulonglong:
1450 case e_sint128:
1451 case e_uint128:
1452 case e_sint256:
1453 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001454 case e_sint512:
1455 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001456 return static_cast<ushort_t>(
1457 (m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001458 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001459 return static_cast<ushort_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001460 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001461 return static_cast<ushort_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001462 case e_long_double:
1463 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001464 return static_cast<ushort_t>(
1465 (ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001466 }
1467 return fail_value;
1468}
1469
1470int Scalar::SInt(int fail_value) const {
1471 switch (m_type) {
1472 case e_void:
1473 break;
1474 case e_sint:
1475 case e_uint:
1476 case e_slong:
1477 case e_ulong:
1478 case e_slonglong:
1479 case e_ulonglong:
1480 case e_sint128:
1481 case e_uint128:
1482 case e_sint256:
1483 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001484 case e_sint512:
1485 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001486 return static_cast<sint_t>(
1487 (m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001488 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001489 return static_cast<sint_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001490 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001491 return static_cast<sint_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001492 case e_long_double:
1493 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001494 return static_cast<sint_t>(
1495 (ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001496 }
1497 return fail_value;
1498}
1499
1500unsigned int Scalar::UInt(unsigned int fail_value) const {
1501 switch (m_type) {
1502 case e_void:
1503 break;
1504 case e_sint:
1505 case e_uint:
1506 case e_slong:
1507 case e_ulong:
1508 case e_slonglong:
1509 case e_ulonglong:
1510 case e_sint128:
1511 case e_uint128:
1512 case e_sint256:
1513 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001514 case e_sint512:
1515 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001516 return static_cast<uint_t>(
1517 (m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001518 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001519 return static_cast<uint_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001520 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001521 return static_cast<uint_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001522 case e_long_double:
1523 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001524 return static_cast<uint_t>(
1525 (ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001526 }
1527 return fail_value;
1528}
1529
1530long Scalar::SLong(long fail_value) const {
1531 switch (m_type) {
1532 case e_void:
1533 break;
1534 case e_sint:
1535 case e_uint:
1536 case e_slong:
1537 case e_ulong:
1538 case e_slonglong:
1539 case e_ulonglong:
1540 case e_sint128:
1541 case e_uint128:
1542 case e_sint256:
1543 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001544 case e_sint512:
1545 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001546 return static_cast<slong_t>(
1547 (m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001548 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001549 return static_cast<slong_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001550 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001551 return static_cast<slong_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001552 case e_long_double:
1553 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001554 return static_cast<slong_t>(
1555 (ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001556 }
1557 return fail_value;
1558}
1559
1560unsigned long Scalar::ULong(unsigned long fail_value) const {
1561 switch (m_type) {
1562 case e_void:
1563 break;
1564 case e_sint:
1565 case e_uint:
1566 case e_slong:
1567 case e_ulong:
1568 case e_slonglong:
1569 case e_ulonglong:
1570 case e_sint128:
1571 case e_uint128:
1572 case e_sint256:
1573 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001574 case e_sint512:
1575 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001576 return static_cast<ulong_t>(
1577 (m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001578 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001579 return static_cast<ulong_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001580 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001581 return static_cast<ulong_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001582 case e_long_double:
1583 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001584 return static_cast<ulong_t>(
1585 (ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001586 }
1587 return fail_value;
1588}
1589
1590long long Scalar::SLongLong(long long fail_value) const {
1591 switch (m_type) {
1592 case e_void:
1593 break;
1594 case e_sint:
1595 case e_uint:
1596 case e_slong:
1597 case e_ulong:
1598 case e_slonglong:
1599 case e_ulonglong:
1600 case e_sint128:
1601 case e_uint128:
1602 case e_sint256:
1603 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001604 case e_sint512:
1605 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001606 return static_cast<slonglong_t>(
1607 (m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001608 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001609 return static_cast<slonglong_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001610 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001611 return static_cast<slonglong_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001612 case e_long_double:
1613 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001614 return static_cast<slonglong_t>(
1615 (ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001616 }
1617 return fail_value;
1618}
1619
1620unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
1621 switch (m_type) {
1622 case e_void:
1623 break;
1624 case e_sint:
1625 case e_uint:
1626 case e_slong:
1627 case e_ulong:
1628 case e_slonglong:
1629 case e_ulonglong:
1630 case e_sint128:
1631 case e_uint128:
1632 case e_sint256:
1633 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001634 case e_sint512:
1635 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001636 return static_cast<ulonglong_t>(
1637 (m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001638 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001639 return static_cast<ulonglong_t>(m_float.convertToFloat());
Davide Italianof06ffee2018-09-07 18:22:27 +00001640 case e_double: {
1641 double d_val = m_float.convertToDouble();
1642 llvm::APInt rounded_double =
1643 llvm::APIntOps::RoundDoubleToAPInt(d_val, sizeof(ulonglong_t) * 8);
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001644 return static_cast<ulonglong_t>(
1645 (rounded_double.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
Davide Italianof06ffee2018-09-07 18:22:27 +00001646 }
1647 case e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001648 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001649 return static_cast<ulonglong_t>(
1650 (ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001651 }
1652 return fail_value;
1653}
1654
1655llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
1656 switch (m_type) {
1657 case e_void:
1658 break;
1659 case e_sint:
1660 case e_uint:
1661 case e_slong:
1662 case e_ulong:
1663 case e_slonglong:
1664 case e_ulonglong:
1665 case e_sint128:
1666 case e_uint128:
1667 case e_sint256:
1668 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001669 case e_sint512:
1670 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001671 return m_integer;
1672 case e_float:
1673 case e_double:
1674 case e_long_double:
1675 return m_float.bitcastToAPInt();
1676 }
1677 return fail_value;
1678}
1679
1680llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
1681 switch (m_type) {
1682 case e_void:
1683 break;
1684 case e_sint:
1685 case e_uint:
1686 case e_slong:
1687 case e_ulong:
1688 case e_slonglong:
1689 case e_ulonglong:
1690 case e_sint128:
1691 case e_uint128:
1692 case e_sint256:
1693 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001694 case e_sint512:
1695 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001696 return m_integer;
1697 case e_float:
1698 case e_double:
1699 case e_long_double:
1700 return m_float.bitcastToAPInt();
1701 }
1702 return fail_value;
1703}
1704
Kate Stoneb9c1b512016-09-06 20:57:50 +00001705float Scalar::Float(float fail_value) const {
1706 switch (m_type) {
1707 case e_void:
1708 break;
1709 case e_sint:
1710 case e_uint:
1711 case e_slong:
1712 case e_ulong:
1713 case e_slonglong:
1714 case e_ulonglong:
1715 case e_sint128:
1716 case e_uint128:
1717 case e_sint256:
1718 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001719 case e_sint512:
1720 case e_uint512:
Davide Italiano49d80282018-04-02 16:50:54 +00001721 return llvm::APIntOps::RoundAPIntToFloat(m_integer);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001722 case e_float:
1723 return m_float.convertToFloat();
1724 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001725 return static_cast<float_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001726 case e_long_double:
1727 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1728 return ldbl_val.bitsToFloat();
1729 }
1730 return fail_value;
1731}
1732
1733double Scalar::Double(double fail_value) const {
1734 switch (m_type) {
1735 case e_void:
1736 break;
1737 case e_sint:
1738 case e_uint:
1739 case e_slong:
1740 case e_ulong:
1741 case e_slonglong:
1742 case e_ulonglong:
1743 case e_sint128:
1744 case e_uint128:
1745 case e_sint256:
1746 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001747 case e_sint512:
1748 case e_uint512:
Davide Italiano49d80282018-04-02 16:50:54 +00001749 return llvm::APIntOps::RoundAPIntToDouble(m_integer);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001750 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001751 return static_cast<double_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001752 case e_double:
1753 return m_float.convertToDouble();
1754 case e_long_double:
1755 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1756 return ldbl_val.bitsToFloat();
1757 }
1758 return fail_value;
1759}
1760
1761long double Scalar::LongDouble(long double fail_value) const {
1762 switch (m_type) {
1763 case e_void:
1764 break;
1765 case e_sint:
1766 case e_uint:
1767 case e_slong:
1768 case e_ulong:
1769 case e_slonglong:
1770 case e_ulonglong:
1771 case e_sint128:
1772 case e_uint128:
1773 case e_sint256:
1774 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001775 case e_sint512:
1776 case e_uint512:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001777 return static_cast<long_double_t>(
1778 llvm::APIntOps::RoundAPIntToDouble(m_integer));
Kate Stoneb9c1b512016-09-06 20:57:50 +00001779 case e_float:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001780 return static_cast<long_double_t>(m_float.convertToFloat());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001781 case e_double:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001782 return static_cast<long_double_t>(m_float.convertToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001783 case e_long_double:
1784 llvm::APInt ldbl_val = m_float.bitcastToAPInt();
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00001785 return static_cast<long_double_t>(ldbl_val.bitsToDouble());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001786 }
1787 return fail_value;
1788}
1789
1790Scalar &Scalar::operator+=(const Scalar &rhs) {
1791 Scalar temp_value;
1792 const Scalar *a;
1793 const Scalar *b;
1794 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
1795 Scalar::e_void) {
1796 switch (m_type) {
1797 case e_void:
1798 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00001799 case e_sint:
1800 case e_uint:
1801 case e_slong:
1802 case e_ulong:
1803 case e_slonglong:
1804 case e_ulonglong:
1805 case e_sint128:
1806 case e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00001807 case e_sint256:
1808 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001809 case e_sint512:
1810 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001811 m_integer = a->m_integer + b->m_integer;
1812 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00001813
Sagar Thakur8536fd12015-08-20 09:12:46 +00001814 case e_float:
1815 case e_double:
1816 case e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001817 m_float = a->m_float + b->m_float;
1818 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00001819 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001820 }
1821 return *this;
Sagar Thakur8536fd12015-08-20 09:12:46 +00001822}
1823
Kate Stoneb9c1b512016-09-06 20:57:50 +00001824Scalar &Scalar::operator<<=(const Scalar &rhs) {
1825 switch (m_type) {
1826 case e_void:
1827 case e_float:
1828 case e_double:
1829 case e_long_double:
1830 m_type = e_void;
1831 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001832
Kate Stoneb9c1b512016-09-06 20:57:50 +00001833 case e_sint:
1834 case e_uint:
1835 case e_slong:
1836 case e_ulong:
1837 case e_slonglong:
1838 case e_ulonglong:
1839 case e_sint128:
1840 case e_uint128:
1841 case e_sint256:
1842 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001843 case e_sint512:
1844 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001845 switch (rhs.m_type) {
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001846 case e_void:
1847 case e_float:
1848 case e_double:
1849 case e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001850 m_type = e_void;
1851 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001852 case e_sint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001853 case e_uint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001854 case e_slong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001855 case e_ulong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001856 case e_slonglong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001857 case e_ulonglong:
Sagar Thakur8536fd12015-08-20 09:12:46 +00001858 case e_sint128:
1859 case e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00001860 case e_sint256:
1861 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001862 case e_sint512:
1863 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001864 m_integer = m_integer << rhs.m_integer;
1865 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001866 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001867 break;
1868 }
1869 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001870}
1871
Kate Stoneb9c1b512016-09-06 20:57:50 +00001872bool Scalar::ShiftRightLogical(const Scalar &rhs) {
1873 switch (m_type) {
1874 case e_void:
1875 case e_float:
1876 case e_double:
1877 case e_long_double:
1878 m_type = e_void;
1879 break;
1880
1881 case e_sint:
1882 case e_uint:
1883 case e_slong:
1884 case e_ulong:
1885 case e_slonglong:
1886 case e_ulonglong:
1887 case e_sint128:
1888 case e_uint128:
1889 case e_sint256:
1890 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001891 case e_sint512:
1892 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001893 switch (rhs.m_type) {
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001894 case e_void:
1895 case e_float:
1896 case e_double:
1897 case e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001898 m_type = e_void;
1899 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001900 case e_sint:
1901 case e_uint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001902 case e_slong:
1903 case e_ulong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001904 case e_slonglong:
1905 case e_ulonglong:
Sagar Thakur8536fd12015-08-20 09:12:46 +00001906 case e_sint128:
1907 case e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00001908 case e_sint256:
1909 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001910 case e_sint512:
1911 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001912 m_integer = m_integer.lshr(rhs.m_integer);
1913 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001914 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001915 break;
1916 }
1917 return m_type != e_void;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001918}
1919
Kate Stoneb9c1b512016-09-06 20:57:50 +00001920Scalar &Scalar::operator>>=(const Scalar &rhs) {
1921 switch (m_type) {
1922 case e_void:
1923 case e_float:
1924 case e_double:
1925 case e_long_double:
1926 m_type = e_void;
1927 break;
1928
1929 case e_sint:
1930 case e_uint:
1931 case e_slong:
1932 case e_ulong:
1933 case e_slonglong:
1934 case e_ulonglong:
1935 case e_sint128:
1936 case e_uint128:
1937 case e_sint256:
1938 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001939 case e_sint512:
1940 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001941 switch (rhs.m_type) {
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001942 case e_void:
1943 case e_float:
1944 case e_double:
1945 case e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001946 m_type = e_void;
1947 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001948 case e_sint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001949 case e_uint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001950 case e_slong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001951 case e_ulong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001952 case e_slonglong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001953 case e_ulonglong:
Sagar Thakur8536fd12015-08-20 09:12:46 +00001954 case e_sint128:
1955 case e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00001956 case e_sint256:
1957 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001958 case e_sint512:
1959 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001960 m_integer = m_integer.ashr(rhs.m_integer);
1961 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001962 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001963 break;
1964 }
1965 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001966}
1967
Kate Stoneb9c1b512016-09-06 20:57:50 +00001968Scalar &Scalar::operator&=(const Scalar &rhs) {
1969 switch (m_type) {
1970 case e_void:
1971 case e_float:
1972 case e_double:
1973 case e_long_double:
1974 m_type = e_void;
1975 break;
1976
1977 case e_sint:
1978 case e_uint:
1979 case e_slong:
1980 case e_ulong:
1981 case e_slonglong:
1982 case e_ulonglong:
1983 case e_sint128:
1984 case e_uint128:
1985 case e_sint256:
1986 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00001987 case e_sint512:
1988 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001989 switch (rhs.m_type) {
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001990 case e_void:
1991 case e_float:
1992 case e_double:
1993 case e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00001994 m_type = e_void;
1995 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001996 case e_sint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001997 case e_uint:
Pavel Labathbb467f62015-08-17 15:28:05 +00001998 case e_slong:
Pavel Labathbb467f62015-08-17 15:28:05 +00001999 case e_ulong:
Pavel Labathbb467f62015-08-17 15:28:05 +00002000 case e_slonglong:
Pavel Labathbb467f62015-08-17 15:28:05 +00002001 case e_ulonglong:
Sagar Thakur8536fd12015-08-20 09:12:46 +00002002 case e_sint128:
2003 case e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00002004 case e_sint256:
2005 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002006 case e_sint512:
2007 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002008 m_integer &= rhs.m_integer;
2009 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002010 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002011 break;
2012 }
2013 return *this;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002014}
2015
Kate Stoneb9c1b512016-09-06 20:57:50 +00002016bool Scalar::AbsoluteValue() {
2017 switch (m_type) {
2018 case e_void:
2019 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002020
Kate Stoneb9c1b512016-09-06 20:57:50 +00002021 case e_sint:
2022 case e_slong:
2023 case e_slonglong:
2024 case e_sint128:
2025 case e_sint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002026 case e_sint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002027 if (m_integer.isNegative())
2028 m_integer = -m_integer;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002029 return true;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002030
2031 case e_uint:
2032 case e_ulong:
2033 case e_ulonglong:
2034 return true;
2035 case e_uint128:
2036 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002037 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002038 case e_float:
2039 case e_double:
2040 case e_long_double:
2041 m_float.clearSign();
2042 return true;
2043 }
2044 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002045}
2046
Kate Stoneb9c1b512016-09-06 20:57:50 +00002047bool Scalar::UnaryNegate() {
2048 switch (m_type) {
2049 case e_void:
2050 break;
2051 case e_sint:
2052 case e_uint:
2053 case e_slong:
2054 case e_ulong:
2055 case e_slonglong:
2056 case e_ulonglong:
2057 case e_sint128:
2058 case e_uint128:
2059 case e_sint256:
2060 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002061 case e_sint512:
2062 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002063 m_integer = -m_integer;
2064 return true;
2065 case e_float:
2066 case e_double:
2067 case e_long_double:
2068 m_float.changeSign();
2069 return true;
2070 }
2071 return false;
2072}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002073
Kate Stoneb9c1b512016-09-06 20:57:50 +00002074bool Scalar::OnesComplement() {
2075 switch (m_type) {
2076 case e_sint:
2077 case e_uint:
2078 case e_slong:
2079 case e_ulong:
2080 case e_slonglong:
2081 case e_ulonglong:
2082 case e_sint128:
2083 case e_uint128:
2084 case e_sint256:
2085 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002086 case e_sint512:
2087 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002088 m_integer = ~m_integer;
2089 return true;
2090
2091 case e_void:
2092 case e_float:
2093 case e_double:
2094 case e_long_double:
2095 break;
2096 }
2097 return false;
2098}
2099
2100const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
2101 Scalar result;
2102 Scalar temp_value;
2103 const Scalar *a;
2104 const Scalar *b;
2105 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2106 Scalar::e_void) {
2107 switch (result.m_type) {
2108 case Scalar::e_void:
2109 break;
2110 case Scalar::e_sint:
2111 case Scalar::e_uint:
2112 case Scalar::e_slong:
2113 case Scalar::e_ulong:
2114 case Scalar::e_slonglong:
2115 case Scalar::e_ulonglong:
2116 case Scalar::e_sint128:
2117 case Scalar::e_uint128:
2118 case Scalar::e_sint256:
2119 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002120 case Scalar::e_sint512:
2121 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002122 result.m_integer = a->m_integer + b->m_integer;
2123 break;
2124 case Scalar::e_float:
2125 case Scalar::e_double:
2126 case Scalar::e_long_double:
2127 result.m_float = a->m_float + b->m_float;
2128 break;
2129 }
2130 }
2131 return result;
2132}
2133
2134const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
2135 Scalar result;
2136 Scalar temp_value;
2137 const Scalar *a;
2138 const Scalar *b;
2139 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2140 Scalar::e_void) {
2141 switch (result.m_type) {
2142 case Scalar::e_void:
2143 break;
2144 case Scalar::e_sint:
2145 case Scalar::e_uint:
2146 case Scalar::e_slong:
2147 case Scalar::e_ulong:
2148 case Scalar::e_slonglong:
2149 case Scalar::e_ulonglong:
2150 case Scalar::e_sint128:
2151 case Scalar::e_uint128:
2152 case Scalar::e_sint256:
2153 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002154 case Scalar::e_sint512:
2155 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002156 result.m_integer = a->m_integer - b->m_integer;
2157 break;
2158 case Scalar::e_float:
2159 case Scalar::e_double:
2160 case Scalar::e_long_double:
2161 result.m_float = a->m_float - b->m_float;
2162 break;
2163 }
2164 }
2165 return result;
2166}
2167
2168const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
2169 Scalar result;
2170 Scalar temp_value;
2171 const Scalar *a;
2172 const Scalar *b;
2173 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2174 Scalar::e_void) {
2175 switch (result.m_type) {
2176 case Scalar::e_void:
2177 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002178 case Scalar::e_sint:
2179 case Scalar::e_slong:
2180 case Scalar::e_slonglong:
2181 case Scalar::e_sint128:
Enrico Granata391075c2016-03-10 00:14:29 +00002182 case Scalar::e_sint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002183 case Scalar::e_sint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002184 if (b->m_integer != 0) {
2185 result.m_integer = a->m_integer.sdiv(b->m_integer);
2186 return result;
2187 }
2188 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002189 case Scalar::e_uint:
2190 case Scalar::e_ulong:
2191 case Scalar::e_ulonglong:
2192 case Scalar::e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00002193 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002194 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002195 if (b->m_integer != 0) {
2196 result.m_integer = a->m_integer.udiv(b->m_integer);
2197 return result;
2198 }
2199 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002200 case Scalar::e_float:
2201 case Scalar::e_double:
2202 case Scalar::e_long_double:
Davide Italiano01c33b82018-03-27 18:37:54 +00002203 if (!b->m_float.isZero()) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002204 result.m_float = a->m_float / b->m_float;
2205 return result;
2206 }
2207 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002208 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002209 }
2210 // For division only, the only way it should make it here is if a promotion
Adrian Prantl05097242018-04-30 16:49:04 +00002211 // failed, or if we are trying to do a divide by zero.
Kate Stoneb9c1b512016-09-06 20:57:50 +00002212 result.m_type = Scalar::e_void;
2213 return result;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002214}
2215
Kate Stoneb9c1b512016-09-06 20:57:50 +00002216const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
2217 Scalar result;
2218 Scalar temp_value;
2219 const Scalar *a;
2220 const Scalar *b;
2221 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2222 Scalar::e_void) {
2223 switch (result.m_type) {
2224 case Scalar::e_void:
2225 break;
2226 case Scalar::e_sint:
2227 case Scalar::e_uint:
2228 case Scalar::e_slong:
2229 case Scalar::e_ulong:
2230 case Scalar::e_slonglong:
2231 case Scalar::e_ulonglong:
2232 case Scalar::e_sint128:
2233 case Scalar::e_uint128:
2234 case Scalar::e_sint256:
2235 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002236 case Scalar::e_sint512:
2237 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002238 result.m_integer = a->m_integer * b->m_integer;
2239 break;
2240 case Scalar::e_float:
2241 case Scalar::e_double:
2242 case Scalar::e_long_double:
2243 result.m_float = a->m_float * b->m_float;
2244 break;
2245 }
2246 }
2247 return result;
2248}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002249
Kate Stoneb9c1b512016-09-06 20:57:50 +00002250const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
2251 Scalar result;
2252 Scalar temp_value;
2253 const Scalar *a;
2254 const Scalar *b;
2255 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2256 Scalar::e_void) {
2257 switch (result.m_type) {
2258 case Scalar::e_sint:
2259 case Scalar::e_uint:
2260 case Scalar::e_slong:
2261 case Scalar::e_ulong:
2262 case Scalar::e_slonglong:
2263 case Scalar::e_ulonglong:
2264 case Scalar::e_sint128:
2265 case Scalar::e_uint128:
2266 case Scalar::e_sint256:
2267 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002268 case Scalar::e_sint512:
2269 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002270 result.m_integer = a->m_integer & b->m_integer;
2271 break;
2272 case Scalar::e_void:
2273 case Scalar::e_float:
2274 case Scalar::e_double:
2275 case Scalar::e_long_double:
2276 // No bitwise AND on floats, doubles of long doubles
2277 result.m_type = Scalar::e_void;
2278 break;
2279 }
2280 }
2281 return result;
2282}
2283
2284const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
2285 Scalar result;
2286 Scalar temp_value;
2287 const Scalar *a;
2288 const Scalar *b;
2289 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2290 Scalar::e_void) {
2291 switch (result.m_type) {
2292 case Scalar::e_sint:
2293 case Scalar::e_uint:
2294 case Scalar::e_slong:
2295 case Scalar::e_ulong:
2296 case Scalar::e_slonglong:
2297 case Scalar::e_ulonglong:
2298 case Scalar::e_sint128:
2299 case Scalar::e_uint128:
2300 case Scalar::e_sint256:
2301 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002302 case Scalar::e_sint512:
2303 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002304 result.m_integer = a->m_integer | b->m_integer;
2305 break;
2306
2307 case Scalar::e_void:
2308 case Scalar::e_float:
2309 case Scalar::e_double:
2310 case Scalar::e_long_double:
2311 // No bitwise AND on floats, doubles of long doubles
2312 result.m_type = Scalar::e_void;
2313 break;
2314 }
2315 }
2316 return result;
2317}
2318
2319const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
2320 Scalar result;
2321 Scalar temp_value;
2322 const Scalar *a;
2323 const Scalar *b;
2324 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2325 Scalar::e_void) {
2326 switch (result.m_type) {
2327 default:
2328 break;
2329 case Scalar::e_void:
2330 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002331 case Scalar::e_sint:
2332 case Scalar::e_slong:
2333 case Scalar::e_slonglong:
2334 case Scalar::e_sint128:
Enrico Granata391075c2016-03-10 00:14:29 +00002335 case Scalar::e_sint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002336 case Scalar::e_sint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002337 if (b->m_integer != 0) {
2338 result.m_integer = a->m_integer.srem(b->m_integer);
2339 return result;
2340 }
2341 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002342 case Scalar::e_uint:
2343 case Scalar::e_ulong:
2344 case Scalar::e_ulonglong:
2345 case Scalar::e_uint128:
Enrico Granata391075c2016-03-10 00:14:29 +00002346 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002347 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002348 if (b->m_integer != 0) {
2349 result.m_integer = a->m_integer.urem(b->m_integer);
2350 return result;
2351 }
2352 break;
2353 }
2354 }
2355 result.m_type = Scalar::e_void;
2356 return result;
2357}
2358
2359const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
2360 Scalar result;
2361 Scalar temp_value;
2362 const Scalar *a;
2363 const Scalar *b;
2364 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2365 Scalar::e_void) {
2366 switch (result.m_type) {
2367 case Scalar::e_sint:
2368 case Scalar::e_uint:
2369 case Scalar::e_slong:
2370 case Scalar::e_ulong:
2371 case Scalar::e_slonglong:
2372 case Scalar::e_ulonglong:
2373 case Scalar::e_sint128:
2374 case Scalar::e_uint128:
2375 case Scalar::e_sint256:
2376 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002377 case Scalar::e_sint512:
2378 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002379 result.m_integer = a->m_integer ^ b->m_integer;
2380 break;
2381
2382 case Scalar::e_void:
Sagar Thakur8536fd12015-08-20 09:12:46 +00002383 case Scalar::e_float:
2384 case Scalar::e_double:
2385 case Scalar::e_long_double:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002386 // No bitwise AND on floats, doubles of long doubles
2387 result.m_type = Scalar::e_void;
2388 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002389 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002390 }
2391 return result;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002392}
2393
Kate Stoneb9c1b512016-09-06 20:57:50 +00002394const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
2395 Scalar result = lhs;
2396 result <<= rhs;
2397 return result;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002398}
2399
Kate Stoneb9c1b512016-09-06 20:57:50 +00002400const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
2401 Scalar result = lhs;
2402 result >>= rhs;
2403 return result;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002404}
2405
Zachary Turner97206d52017-05-12 04:51:55 +00002406Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
2407 size_t byte_size) {
2408 Status error;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002409 if (value_str == nullptr || value_str[0] == '\0') {
2410 error.SetErrorString("Invalid c-string value string.");
2411 return error;
2412 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002413 switch (encoding) {
2414 case eEncodingInvalid:
2415 error.SetErrorString("Invalid encoding.");
2416 break;
2417
2418 case eEncodingUint:
Pavel Labath61547252018-06-19 17:24:03 +00002419 if (byte_size <= sizeof(uint64_t)) {
2420 uint64_t uval64;
2421 if (!llvm::to_integer(value_str, uval64))
Kate Stoneb9c1b512016-09-06 20:57:50 +00002422 error.SetErrorStringWithFormat(
2423 "'%s' is not a valid unsigned integer string value", value_str);
2424 else if (!UIntValueIsValidForSize(uval64, byte_size))
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002425 error.SetErrorStringWithFormat(
2426 "value 0x%" PRIx64 " is too large to fit in a %" PRIu64
2427 " byte unsigned integer value",
2428 uval64, static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002429 else {
2430 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
2431 switch (m_type) {
2432 case e_uint:
2433 m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
2434 break;
2435 case e_ulong:
2436 m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
2437 break;
2438 case e_ulonglong:
2439 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
2440 break;
2441 default:
2442 error.SetErrorStringWithFormat(
2443 "unsupported unsigned integer byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002444 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002445 break;
2446 }
2447 }
2448 } else {
2449 error.SetErrorStringWithFormat(
2450 "unsupported unsigned integer byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002451 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002452 return error;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002453 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002454 break;
2455
2456 case eEncodingSint:
Pavel Labath61547252018-06-19 17:24:03 +00002457 if (byte_size <= sizeof(int64_t)) {
2458 int64_t sval64;
2459 if (!llvm::to_integer(value_str, sval64))
Kate Stoneb9c1b512016-09-06 20:57:50 +00002460 error.SetErrorStringWithFormat(
2461 "'%s' is not a valid signed integer string value", value_str);
2462 else if (!SIntValueIsValidForSize(sval64, byte_size))
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002463 error.SetErrorStringWithFormat(
2464 "value 0x%" PRIx64 " is too large to fit in a %" PRIu64
2465 " byte signed integer value",
2466 sval64, static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002467 else {
2468 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
2469 switch (m_type) {
2470 case e_sint:
2471 m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
2472 break;
2473 case e_slong:
2474 m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
2475 break;
2476 case e_slonglong:
2477 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
2478 break;
2479 default:
2480 error.SetErrorStringWithFormat(
2481 "unsupported signed integer byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002482 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002483 break;
2484 }
2485 }
2486 } else {
2487 error.SetErrorStringWithFormat(
2488 "unsupported signed integer byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002489 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002490 return error;
2491 }
2492 break;
2493
2494 case eEncodingIEEE754:
2495 static float f_val;
2496 static double d_val;
2497 static long double l_val;
2498 if (byte_size == sizeof(float)) {
2499 if (::sscanf(value_str, "%f", &f_val) == 1) {
2500 m_float = llvm::APFloat(f_val);
2501 m_type = e_float;
2502 } else
2503 error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2504 value_str);
2505 } else if (byte_size == sizeof(double)) {
2506 if (::sscanf(value_str, "%lf", &d_val) == 1) {
2507 m_float = llvm::APFloat(d_val);
2508 m_type = e_double;
2509 } else
2510 error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2511 value_str);
2512 } else if (byte_size == sizeof(long double)) {
2513 if (::sscanf(value_str, "%Lf", &l_val) == 1) {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002514 m_float = llvm::APFloat(
2515 llvm::APFloat::x87DoubleExtended(),
2516 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
2517 (reinterpret_cast<type128 *>(&l_val))->x));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002518 m_type = e_long_double;
2519 } else
2520 error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2521 value_str);
2522 } else {
2523 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002524 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002525 return error;
2526 }
2527 break;
2528
2529 case eEncodingVector:
2530 error.SetErrorString("vector encoding unsupported.");
2531 break;
2532 }
2533 if (error.Fail())
2534 m_type = e_void;
2535
2536 return error;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002537}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002538
Zachary Turner97206d52017-05-12 04:51:55 +00002539Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
2540 size_t byte_size) {
2541 Status error;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002542
2543 type128 int128;
2544 type256 int256;
2545 switch (encoding) {
2546 case lldb::eEncodingInvalid:
2547 error.SetErrorString("invalid encoding");
2548 break;
2549 case lldb::eEncodingVector:
2550 error.SetErrorString("vector encoding unsupported");
2551 break;
2552 case lldb::eEncodingUint: {
2553 lldb::offset_t offset = 0;
2554
2555 switch (byte_size) {
2556 case 1:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002557 operator=(data.GetU8(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002558 break;
2559 case 2:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002560 operator=(data.GetU16(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002561 break;
2562 case 4:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002563 operator=(data.GetU32(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002564 break;
2565 case 8:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002566 operator=(data.GetU64(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002567 break;
2568 case 16:
2569 if (data.GetByteOrder() == eByteOrderBig) {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002570 int128.x[1] = data.GetU64(&offset);
2571 int128.x[0] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002572 } else {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002573 int128.x[0] = data.GetU64(&offset);
2574 int128.x[1] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002575 }
2576 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2577 break;
2578 case 32:
2579 if (data.GetByteOrder() == eByteOrderBig) {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002580 int256.x[3] = data.GetU64(&offset);
2581 int256.x[2] = data.GetU64(&offset);
2582 int256.x[1] = data.GetU64(&offset);
2583 int256.x[0] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002584 } else {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002585 int256.x[0] = data.GetU64(&offset);
2586 int256.x[1] = data.GetU64(&offset);
2587 int256.x[2] = data.GetU64(&offset);
2588 int256.x[3] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002589 }
2590 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2591 break;
2592 default:
2593 error.SetErrorStringWithFormat(
2594 "unsupported unsigned integer byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002595 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002596 break;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002597 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002598 } break;
2599 case lldb::eEncodingSint: {
2600 lldb::offset_t offset = 0;
2601
2602 switch (byte_size) {
2603 case 1:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002604 operator=(static_cast<int8_t>(data.GetU8(&offset)));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002605 break;
2606 case 2:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002607 operator=(static_cast<int16_t>(data.GetU16(&offset)));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002608 break;
2609 case 4:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002610 operator=(static_cast<int32_t>(data.GetU32(&offset)));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002611 break;
2612 case 8:
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002613 operator=(static_cast<int64_t>(data.GetU64(&offset)));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002614 break;
2615 case 16:
2616 if (data.GetByteOrder() == eByteOrderBig) {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002617 int128.x[1] = data.GetU64(&offset);
2618 int128.x[0] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002619 } else {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002620 int128.x[0] = data.GetU64(&offset);
2621 int128.x[1] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002622 }
2623 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2624 break;
2625 case 32:
2626 if (data.GetByteOrder() == eByteOrderBig) {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002627 int256.x[3] = data.GetU64(&offset);
2628 int256.x[2] = data.GetU64(&offset);
2629 int256.x[1] = data.GetU64(&offset);
2630 int256.x[0] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002631 } else {
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002632 int256.x[0] = data.GetU64(&offset);
2633 int256.x[1] = data.GetU64(&offset);
2634 int256.x[2] = data.GetU64(&offset);
2635 int256.x[3] = data.GetU64(&offset);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002636 }
2637 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2638 break;
2639 default:
2640 error.SetErrorStringWithFormat(
2641 "unsupported signed integer byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002642 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002643 break;
2644 }
2645 } break;
2646 case lldb::eEncodingIEEE754: {
2647 lldb::offset_t offset = 0;
2648
2649 if (byte_size == sizeof(float))
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002650 operator=(data.GetFloat(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002651 else if (byte_size == sizeof(double))
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002652 operator=(data.GetDouble(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002653 else if (byte_size == sizeof(long double))
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002654 operator=(data.GetLongDouble(&offset));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002655 else
2656 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
Jonas Devlieghere24374ae2019-05-23 05:12:11 +00002657 static_cast<uint64_t>(byte_size));
Kate Stoneb9c1b512016-09-06 20:57:50 +00002658 } break;
2659 }
2660
2661 return error;
Sagar Thakur8536fd12015-08-20 09:12:46 +00002662}
Oleksiy Vyalov9dcdd2e2015-08-10 21:49:50 +00002663
Kate Stoneb9c1b512016-09-06 20:57:50 +00002664bool Scalar::SignExtend(uint32_t sign_bit_pos) {
2665 const uint32_t max_bit_pos = GetByteSize() * 8;
2666
2667 if (sign_bit_pos < max_bit_pos) {
2668 switch (m_type) {
2669 case Scalar::e_void:
2670 case Scalar::e_float:
2671 case Scalar::e_double:
2672 case Scalar::e_long_double:
2673 return false;
2674
2675 case Scalar::e_sint:
2676 case Scalar::e_uint:
2677 case Scalar::e_slong:
2678 case Scalar::e_ulong:
2679 case Scalar::e_slonglong:
2680 case Scalar::e_ulonglong:
2681 case Scalar::e_sint128:
2682 case Scalar::e_uint128:
2683 case Scalar::e_sint256:
2684 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002685 case Scalar::e_sint512:
2686 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002687 if (max_bit_pos == sign_bit_pos)
2688 return true;
2689 else if (sign_bit_pos < (max_bit_pos - 1)) {
Sean Callananac3254a2017-04-20 18:07:51 +00002690 llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002691 llvm::APInt bitwize_and = m_integer & sign_bit;
2692 if (bitwize_and.getBoolValue()) {
2693 const llvm::APInt mask =
2694 ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
2695 m_integer |= mask;
2696 }
2697 return true;
2698 }
2699 break;
2700 }
2701 }
2702 return false;
2703}
2704
2705size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
2706 lldb::ByteOrder dst_byte_order,
Zachary Turner97206d52017-05-12 04:51:55 +00002707 Status &error) const {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002708 // Get a data extractor that points to the native scalar data
2709 DataExtractor data;
2710 if (!GetData(data)) {
2711 error.SetErrorString("invalid scalar value");
2712 return 0;
2713 }
2714
2715 const size_t src_len = data.GetByteSize();
2716
2717 // Prepare a memory buffer that contains some or all of the register value
2718 const size_t bytes_copied =
2719 data.CopyByteOrderedData(0, // src offset
2720 src_len, // src length
2721 dst, // dst buffer
2722 dst_len, // dst length
2723 dst_byte_order); // dst byte order
2724 if (bytes_copied == 0)
2725 error.SetErrorString("failed to copy data");
2726
2727 return bytes_copied;
2728}
2729
2730bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
2731 if (bit_size == 0)
2732 return true;
2733
2734 switch (m_type) {
2735 case Scalar::e_void:
2736 case Scalar::e_float:
2737 case Scalar::e_double:
2738 case Scalar::e_long_double:
2739 break;
2740
2741 case Scalar::e_sint:
2742 case Scalar::e_slong:
2743 case Scalar::e_slonglong:
2744 case Scalar::e_sint128:
2745 case Scalar::e_sint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002746 case Scalar::e_sint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002747 m_integer = m_integer.ashr(bit_offset)
2748 .sextOrTrunc(bit_size)
2749 .sextOrSelf(8 * GetByteSize());
2750 return true;
2751
2752 case Scalar::e_uint:
2753 case Scalar::e_ulong:
2754 case Scalar::e_ulonglong:
2755 case Scalar::e_uint128:
2756 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002757 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002758 m_integer = m_integer.lshr(bit_offset)
2759 .zextOrTrunc(bit_size)
2760 .zextOrSelf(8 * GetByteSize());
2761 return true;
2762 }
2763 return false;
2764}
2765
2766bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
2767 // If either entry is void then we can just compare the types
2768 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2769 return lhs.m_type == rhs.m_type;
2770
2771 Scalar temp_value;
2772 const Scalar *a;
2773 const Scalar *b;
2774 llvm::APFloat::cmpResult result;
2775 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2776 case Scalar::e_void:
2777 break;
2778 case Scalar::e_sint:
2779 case Scalar::e_uint:
2780 case Scalar::e_slong:
2781 case Scalar::e_ulong:
2782 case Scalar::e_slonglong:
2783 case Scalar::e_ulonglong:
2784 case Scalar::e_sint128:
2785 case Scalar::e_uint128:
2786 case Scalar::e_sint256:
2787 case Scalar::e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002788 case Scalar::e_sint512:
2789 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002790 return a->m_integer == b->m_integer;
2791 case Scalar::e_float:
2792 case Scalar::e_double:
2793 case Scalar::e_long_double:
2794 result = a->m_float.compare(b->m_float);
2795 if (result == llvm::APFloat::cmpEqual)
2796 return true;
2797 }
2798 return false;
2799}
2800
2801bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
Davide Italiano18a0ce92018-12-21 22:42:00 +00002802 return !(lhs == rhs);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002803}
2804
2805bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
2806 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2807 return false;
2808
2809 Scalar temp_value;
2810 const Scalar *a;
2811 const Scalar *b;
2812 llvm::APFloat::cmpResult result;
2813 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2814 case Scalar::e_void:
2815 break;
2816 case Scalar::e_sint:
2817 case Scalar::e_slong:
2818 case Scalar::e_slonglong:
2819 case Scalar::e_sint128:
2820 case Scalar::e_sint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002821 case Scalar::e_sint512:
2822 case Scalar::e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002823 return a->m_integer.slt(b->m_integer);
2824 case Scalar::e_uint:
2825 case Scalar::e_ulong:
2826 case Scalar::e_ulonglong:
2827 case Scalar::e_uint128:
2828 case Scalar::e_uint256:
2829 return a->m_integer.ult(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::cmpLessThan)
2835 return true;
2836 }
2837 return false;
2838}
2839
2840bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
Davide Italianoff92a1a2019-01-04 19:23:52 +00002841 return !(rhs < lhs);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002842}
2843
2844bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
Davide Italianoff92a1a2019-01-04 19:23:52 +00002845 return rhs < lhs;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002846}
2847
2848bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
Davide Italianoff92a1a2019-01-04 19:23:52 +00002849 return !(lhs < rhs);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002850}
2851
2852bool Scalar::ClearBit(uint32_t bit) {
2853 switch (m_type) {
2854 case e_void:
2855 break;
2856 case e_sint:
2857 case e_uint:
2858 case e_slong:
2859 case e_ulong:
2860 case e_slonglong:
2861 case e_ulonglong:
2862 case e_sint128:
2863 case e_uint128:
2864 case e_sint256:
2865 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002866 case e_sint512:
2867 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002868 m_integer.clearBit(bit);
2869 return true;
2870 case e_float:
2871 case e_double:
2872 case e_long_double:
2873 break;
2874 }
2875 return false;
2876}
2877
2878bool Scalar::SetBit(uint32_t bit) {
2879 switch (m_type) {
2880 case e_void:
2881 break;
2882 case e_sint:
2883 case e_uint:
2884 case e_slong:
2885 case e_ulong:
2886 case e_slonglong:
2887 case e_ulonglong:
2888 case e_sint128:
2889 case e_uint128:
2890 case e_sint256:
2891 case e_uint256:
Davide Italiano51d46bd2019-01-30 18:05:36 +00002892 case e_sint512:
2893 case e_uint512:
Kate Stoneb9c1b512016-09-06 20:57:50 +00002894 m_integer.setBit(bit);
2895 return true;
2896 case e_float:
2897 case e_double:
2898 case e_long_double:
2899 break;
2900 }
2901 return false;
2902}
Pavel Labathb07a7992019-04-29 10:55:22 +00002903
2904llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os, const Scalar &scalar) {
2905 StreamString s;
2906 scalar.GetValue(&s, /*show_type*/ true);
2907 return os << s.GetString();
2908}