1 //===-- Scalar.cpp --------------------------------------------------------===//
2 //
3 // 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
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Utility/Scalar.h"
10 
11 #include "lldb/Utility/DataExtractor.h"
12 #include "lldb/Utility/Endian.h"
13 #include "lldb/Utility/Status.h"
14 #include "lldb/Utility/Stream.h"
15 #include "lldb/Utility/StreamString.h"
16 #include "lldb/lldb-types.h"
17 
18 #include "llvm/ADT/SmallString.h"
19 
20 #include <cinttypes>
21 #include <cstdio>
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 // Promote to max type currently follows the ANSI C rule for type promotion in
27 // expressions.
28 static 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)
39 ) {
40   Scalar result;
41   // 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.
44   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();
49 
50   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   }
63 
64   // 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
67 
68   // Return the void type (zero) if we fail to promote either of the values.
69   return Scalar::e_void;
70 }
71 
72 Scalar::Scalar() : m_type(e_void), m_float(static_cast<float>(0)) {}
73 
74 bool 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 = static_cast<const uint8_t *>(GetBytes());
78 
79     if (limit_byte_size < byte_size) {
80       if (endian::InlHostByteOrder() == eByteOrderLittle) {
81         // On little endian systems if we want fewer bytes from the current
82         // type we just specify fewer bytes since the LSByte is first...
83         byte_size = limit_byte_size;
84       } else if (endian::InlHostByteOrder() == eByteOrderBig) {
85         // 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
88         bytes += byte_size - limit_byte_size;
89         byte_size = limit_byte_size;
90       }
91     }
92 
93     data.SetData(bytes, byte_size, endian::InlHostByteOrder());
94     return true;
95   }
96   data.Clear();
97   return false;
98 }
99 
100 const 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;
105   static uint64_t swapped_words[8];
106   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());
116     // 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.
118     if (endian::InlHostByteOrder() == eByteOrderBig) {
119       size_t byte_size = m_integer.getBitWidth() / 8;
120       if (byte_size < 8)
121         bytes += 8 - byte_size;
122     }
123     return bytes;
124   // 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.
127   case e_sint128:
128   case e_uint128:
129     apint_words = m_integer.getRawData();
130     if (endian::InlHostByteOrder() == eByteOrderBig) {
131       swapped_words[0] = apint_words[1];
132       swapped_words[1] = apint_words[0];
133       apint_words = swapped_words;
134     }
135     return static_cast<const void *>(apint_words);
136   case e_sint256:
137   case e_uint256:
138     apint_words = m_integer.getRawData();
139     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;
145     }
146     return static_cast<const void *>(apint_words);
147   case e_sint512:
148   case e_uint512:
149     apint_words = m_integer.getRawData();
150     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 static_cast<const void *>(apint_words);
162   case e_float:
163     flt_val = m_float.convertToFloat();
164     return static_cast<const void *>(&flt_val);
165   case e_double:
166     dbl_val = m_float.convertToDouble();
167     return static_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;
178     }
179     return static_cast<const void *>(apint_words);
180   }
181   return nullptr;
182 }
183 
184 size_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:
198   case e_sint512:
199   case e_uint512:
200     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;
209 }
210 
211 bool 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:
226   case e_uint512:
227   case e_sint512:
228     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;
235 }
236 
237 void 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:
249   case e_sint512:
250     s->PutCString(m_integer.toString(10, true));
251     break;
252   case e_uint:
253   case e_ulong:
254   case e_ulonglong:
255   case e_uint128:
256   case e_uint256:
257   case e_uint512:
258     s->PutCString(m_integer.toString(10, false));
259     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   }
268 }
269 
270 const 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";
294   case e_sint512:
295     return "int512_t";
296   case e_uint512:
297     return "unsigned int512_t";
298   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>";
306 }
307 
308 Scalar &Scalar::operator=(const int v) {
309   m_type = e_sint;
310   m_integer = llvm::APInt(sizeof(int) * 8, v, true);
311   return *this;
312 }
313 
314 Scalar &Scalar::operator=(unsigned int v) {
315   m_type = e_uint;
316   m_integer = llvm::APInt(sizeof(int) * 8, v);
317   return *this;
318 }
319 
320 Scalar &Scalar::operator=(long v) {
321   m_type = e_slong;
322   m_integer = llvm::APInt(sizeof(long) * 8, v, true);
323   return *this;
324 }
325 
326 Scalar &Scalar::operator=(unsigned long v) {
327   m_type = e_ulong;
328   m_integer = llvm::APInt(sizeof(long) * 8, v);
329   return *this;
330 }
331 
332 Scalar &Scalar::operator=(long long v) {
333   m_type = e_slonglong;
334   m_integer = llvm::APInt(sizeof(long long) * 8, v, true);
335   return *this;
336 }
337 
338 Scalar &Scalar::operator=(unsigned long long v) {
339   m_type = e_ulonglong;
340   m_integer = llvm::APInt(sizeof(long long) * 8, v);
341   return *this;
342 }
343 
344 Scalar &Scalar::operator=(float v) {
345   m_type = e_float;
346   m_float = llvm::APFloat(v);
347   return *this;
348 }
349 
350 Scalar &Scalar::operator=(double v) {
351   m_type = e_double;
352   m_float = llvm::APFloat(v);
353   return *this;
354 }
355 
356 Scalar &Scalar::operator=(long double v) {
357   m_type = e_long_double;
358   m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
359                           llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
360                                       (reinterpret_cast<type128 *>(&v))->x));
361   return *this;
362 }
363 
364 Scalar &Scalar::operator=(llvm::APInt rhs) {
365   m_integer = llvm::APInt(rhs);
366   switch (m_integer.getBitWidth()) {
367   case 8:
368   case 16:
369   case 32:
370     if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
371       m_type = e_sint;
372     else
373       m_type = e_uint;
374     break;
375   case 64:
376     if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
377       m_type = e_slonglong;
378     else
379       m_type = e_ulonglong;
380     break;
381   case 128:
382     if (m_integer.isSignedIntN(BITWIDTH_INT128))
383       m_type = e_sint128;
384     else
385       m_type = e_uint128;
386     break;
387   case 256:
388     if (m_integer.isSignedIntN(BITWIDTH_INT256))
389       m_type = e_sint256;
390     else
391       m_type = e_uint256;
392     break;
393   case 512:
394     if (m_integer.isSignedIntN(BITWIDTH_INT512))
395       m_type = e_sint512;
396     else
397       m_type = e_uint512;
398     break;
399   }
400   return *this;
401 }
402 
403 Scalar::~Scalar() = default;
404 
405 Scalar::Type Scalar::GetBestTypeForBitSize(size_t bit_size, bool sign) {
406   // Scalar types are always host types, hence the sizeof().
407   if (sign) {
408     if (bit_size <= sizeof(int)*8) return Scalar::e_sint;
409     if (bit_size <= sizeof(long)*8) return Scalar::e_slong;
410     if (bit_size <= sizeof(long long)*8) return Scalar::e_slonglong;
411     if (bit_size <= 128) return Scalar::e_sint128;
412     if (bit_size <= 256) return Scalar::e_sint256;
413     if (bit_size <= 512) return Scalar::e_sint512;
414   } else {
415     if (bit_size <= sizeof(unsigned int)*8) return Scalar::e_uint;
416     if (bit_size <= sizeof(unsigned long)*8) return Scalar::e_ulong;
417     if (bit_size <= sizeof(unsigned long long)*8) return Scalar::e_ulonglong;
418     if (bit_size <= 128) return Scalar::e_uint128;
419     if (bit_size <= 256) return Scalar::e_uint256;
420     if (bit_size <= 512) return Scalar::e_uint512;
421   }
422   return Scalar::e_void;
423 }
424 
425 void Scalar::TruncOrExtendTo(Scalar::Type type, uint16_t bits) {
426   switch (type) {
427   case e_sint:
428   case e_slong:
429   case e_slonglong:
430   case e_sint128:
431   case e_sint256:
432   case e_sint512:
433     m_integer = m_integer.sextOrTrunc(bits);
434     break;
435   case e_uint:
436   case e_ulong:
437   case e_ulonglong:
438   case e_uint128:
439   case e_uint256:
440   case e_uint512:
441     m_integer = m_integer.zextOrTrunc(bits);
442     break;
443   default:
444     llvm_unreachable("Promoting a Scalar to a specific number of bits is only "
445                      "supported for integer types.");
446   }
447   m_type = type;
448 }
449 
450 bool Scalar::Promote(Scalar::Type type) {
451   bool success = false;
452   switch (m_type) {
453   case e_void:
454     break;
455 
456   case e_sint:
457     switch (type) {
458     case e_void:
459       break;
460     case e_sint:
461       success = true;
462       break;
463     case e_uint:
464       m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
465       success = true;
466       break;
467 
468     case e_slong:
469       m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
470       success = true;
471       break;
472 
473     case e_ulong:
474       m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
475       success = true;
476       break;
477 
478     case e_slonglong:
479       m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
480       success = true;
481       break;
482 
483     case e_ulonglong:
484       m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
485       success = true;
486       break;
487 
488     case e_sint128:
489     case e_uint128:
490       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
491       success = true;
492       break;
493 
494     case e_sint256:
495     case e_uint256:
496       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
497       success = true;
498       break;
499 
500     case e_sint512:
501     case e_uint512:
502       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
503       success = true;
504       break;
505 
506     case e_float:
507       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
508       m_float.convertFromAPInt(m_integer, true,
509                                llvm::APFloat::rmNearestTiesToEven);
510       success = true;
511       break;
512 
513     case e_double:
514       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
515       m_float.convertFromAPInt(m_integer, true,
516                                llvm::APFloat::rmNearestTiesToEven);
517       success = true;
518       break;
519 
520     case e_long_double:
521       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
522       m_float.convertFromAPInt(m_integer, true,
523                                llvm::APFloat::rmNearestTiesToEven);
524       success = true;
525       break;
526     }
527     break;
528 
529   case e_uint:
530     switch (type) {
531     case e_void:
532     case e_sint:
533       break;
534     case e_uint:
535       success = true;
536       break;
537     case e_slong:
538       m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
539       success = true;
540       break;
541 
542     case e_ulong:
543       m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
544       success = true;
545       break;
546 
547     case e_slonglong:
548       m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
549       success = true;
550       break;
551 
552     case e_ulonglong:
553       m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
554       success = true;
555       break;
556 
557     case e_sint128:
558     case e_uint128:
559       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
560       success = true;
561       break;
562 
563     case e_sint256:
564     case e_uint256:
565       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
566       success = true;
567       break;
568 
569     case e_sint512:
570     case e_uint512:
571       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
572       success = true;
573       break;
574 
575     case e_float:
576       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
577       m_float.convertFromAPInt(m_integer, false,
578                                llvm::APFloat::rmNearestTiesToEven);
579       success = true;
580       break;
581 
582     case e_double:
583       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
584       m_float.convertFromAPInt(m_integer, false,
585                                llvm::APFloat::rmNearestTiesToEven);
586       success = true;
587       break;
588 
589     case e_long_double:
590       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
591       m_float.convertFromAPInt(m_integer, false,
592                                llvm::APFloat::rmNearestTiesToEven);
593       success = true;
594       break;
595     }
596     break;
597 
598   case e_slong:
599     switch (type) {
600     case e_void:
601     case e_sint:
602     case e_uint:
603       break;
604     case e_slong:
605       success = true;
606       break;
607     case e_ulong:
608       m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
609       success = true;
610       break;
611 
612     case e_slonglong:
613       m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
614       success = true;
615       break;
616 
617     case e_ulonglong:
618       m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
619       success = true;
620       break;
621 
622     case e_sint128:
623     case e_uint128:
624       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
625       success = true;
626       break;
627 
628     case e_sint256:
629     case e_uint256:
630       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
631       success = true;
632       break;
633 
634     case e_sint512:
635     case e_uint512:
636       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
637       success = true;
638       break;
639 
640     case e_float:
641       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
642       m_float.convertFromAPInt(m_integer, true,
643                                llvm::APFloat::rmNearestTiesToEven);
644       success = true;
645       break;
646 
647     case e_double:
648       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
649       m_float.convertFromAPInt(m_integer, true,
650                                llvm::APFloat::rmNearestTiesToEven);
651       success = true;
652       break;
653 
654     case e_long_double:
655       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
656       m_float.convertFromAPInt(m_integer, true,
657                                llvm::APFloat::rmNearestTiesToEven);
658       success = true;
659       break;
660     }
661     break;
662 
663   case e_ulong:
664     switch (type) {
665     case e_void:
666     case e_sint:
667     case e_uint:
668     case e_slong:
669       break;
670     case e_ulong:
671       success = true;
672       break;
673     case e_slonglong:
674       m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
675       success = true;
676       break;
677 
678     case e_ulonglong:
679       m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
680       success = true;
681       break;
682 
683     case e_sint128:
684     case e_uint128:
685       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
686       success = true;
687       break;
688 
689     case e_sint256:
690     case e_uint256:
691       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
692       success = true;
693       break;
694 
695     case e_sint512:
696     case e_uint512:
697       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
698       success = true;
699       break;
700 
701     case e_float:
702       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
703       m_float.convertFromAPInt(m_integer, false,
704                                llvm::APFloat::rmNearestTiesToEven);
705       success = true;
706       break;
707 
708     case e_double:
709       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
710       m_float.convertFromAPInt(m_integer, false,
711                                llvm::APFloat::rmNearestTiesToEven);
712       success = true;
713       break;
714 
715     case e_long_double:
716       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
717       m_float.convertFromAPInt(m_integer, false,
718                                llvm::APFloat::rmNearestTiesToEven);
719       success = true;
720       break;
721     }
722     break;
723 
724   case e_slonglong:
725     switch (type) {
726     case e_void:
727     case e_sint:
728     case e_uint:
729     case e_slong:
730     case e_ulong:
731       break;
732     case e_slonglong:
733       success = true;
734       break;
735     case e_ulonglong:
736       m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
737       success = true;
738       break;
739 
740     case e_sint128:
741     case e_uint128:
742       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
743       success = true;
744       break;
745 
746     case e_sint256:
747     case e_uint256:
748       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
749       success = true;
750       break;
751 
752     case e_sint512:
753     case e_uint512:
754       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
755       success = true;
756       break;
757 
758     case e_float:
759       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
760       m_float.convertFromAPInt(m_integer, true,
761                                llvm::APFloat::rmNearestTiesToEven);
762       success = true;
763       break;
764 
765     case e_double:
766       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
767       m_float.convertFromAPInt(m_integer, true,
768                                llvm::APFloat::rmNearestTiesToEven);
769       success = true;
770       break;
771 
772     case e_long_double:
773       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
774       m_float.convertFromAPInt(m_integer, true,
775                                llvm::APFloat::rmNearestTiesToEven);
776       success = true;
777       break;
778     }
779     break;
780 
781   case e_ulonglong:
782     switch (type) {
783     case e_void:
784     case e_sint:
785     case e_uint:
786     case e_slong:
787     case e_ulong:
788     case e_slonglong:
789       break;
790     case e_ulonglong:
791       success = true;
792       break;
793     case e_sint128:
794     case e_uint128:
795       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
796       success = true;
797       break;
798 
799     case e_sint256:
800     case e_uint256:
801       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
802       success = true;
803       break;
804 
805     case e_sint512:
806     case e_uint512:
807       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
808       success = true;
809       break;
810 
811     case e_float:
812       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
813       m_float.convertFromAPInt(m_integer, false,
814                                llvm::APFloat::rmNearestTiesToEven);
815       success = true;
816       break;
817 
818     case e_double:
819       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
820       m_float.convertFromAPInt(m_integer, false,
821                                llvm::APFloat::rmNearestTiesToEven);
822       success = true;
823       break;
824 
825     case e_long_double:
826       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
827       m_float.convertFromAPInt(m_integer, false,
828                                llvm::APFloat::rmNearestTiesToEven);
829       success = true;
830       break;
831     }
832     break;
833 
834   case e_sint128:
835     switch (type) {
836     case e_void:
837     case e_sint:
838     case e_uint:
839     case e_slong:
840     case e_ulong:
841     case e_slonglong:
842     case e_ulonglong:
843       break;
844     case e_sint128:
845       success = true;
846       break;
847     case e_uint128:
848       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
849       success = true;
850       break;
851 
852     case e_sint256:
853     case e_uint256:
854       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
855       success = true;
856       break;
857 
858     case e_sint512:
859     case e_uint512:
860       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
861       success = true;
862       break;
863 
864     case e_float:
865       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
866       m_float.convertFromAPInt(m_integer, true,
867                                llvm::APFloat::rmNearestTiesToEven);
868       success = true;
869       break;
870 
871     case e_double:
872       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
873       m_float.convertFromAPInt(m_integer, true,
874                                llvm::APFloat::rmNearestTiesToEven);
875       success = true;
876       break;
877 
878     case e_long_double:
879       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
880       m_float.convertFromAPInt(m_integer, true,
881                                llvm::APFloat::rmNearestTiesToEven);
882       success = true;
883       break;
884     }
885     break;
886 
887   case e_uint128:
888     switch (type) {
889     case e_void:
890     case e_sint:
891     case e_uint:
892     case e_slong:
893     case e_ulong:
894     case e_slonglong:
895     case e_ulonglong:
896     case e_sint128:
897       break;
898     case e_uint128:
899       success = true;
900       break;
901     case e_sint256:
902     case e_uint256:
903       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
904       success = true;
905       break;
906 
907     case e_sint512:
908     case e_uint512:
909       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
910       success = true;
911       break;
912 
913     case e_float:
914       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
915       m_float.convertFromAPInt(m_integer, false,
916                                llvm::APFloat::rmNearestTiesToEven);
917       success = true;
918       break;
919 
920     case e_double:
921       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
922       m_float.convertFromAPInt(m_integer, false,
923                                llvm::APFloat::rmNearestTiesToEven);
924       success = true;
925       break;
926 
927     case e_long_double:
928       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
929       m_float.convertFromAPInt(m_integer, false,
930                                llvm::APFloat::rmNearestTiesToEven);
931       success = true;
932       break;
933     }
934     break;
935 
936   case e_sint256:
937     switch (type) {
938     case e_void:
939     case e_sint:
940     case e_uint:
941     case e_slong:
942     case e_ulong:
943     case e_slonglong:
944     case e_ulonglong:
945     case e_sint128:
946     case e_uint128:
947       break;
948     case e_sint256:
949       success = true;
950       break;
951     case e_uint256:
952       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
953       success = true;
954       break;
955 
956     case e_sint512:
957     case e_uint512:
958       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
959       success = true;
960       break;
961 
962     case e_float:
963       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
964       m_float.convertFromAPInt(m_integer, true,
965                                llvm::APFloat::rmNearestTiesToEven);
966       success = true;
967       break;
968 
969     case e_double:
970       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
971       m_float.convertFromAPInt(m_integer, true,
972                                llvm::APFloat::rmNearestTiesToEven);
973       success = true;
974       break;
975 
976     case e_long_double:
977       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
978       m_float.convertFromAPInt(m_integer, true,
979                                llvm::APFloat::rmNearestTiesToEven);
980       success = true;
981       break;
982     }
983     break;
984 
985   case e_uint256:
986     switch (type) {
987     case e_void:
988     case e_sint:
989     case e_uint:
990     case e_slong:
991     case e_ulong:
992     case e_slonglong:
993     case e_ulonglong:
994     case e_sint128:
995     case e_uint128:
996     case e_sint256:
997       break;
998     case e_uint256:
999       success = true;
1000       break;
1001 
1002     case e_sint512:
1003     case e_uint512:
1004       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
1005       success = true;
1006       break;
1007 
1008     case e_float:
1009       m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
1010       m_float.convertFromAPInt(m_integer, false,
1011                                llvm::APFloat::rmNearestTiesToEven);
1012       success = true;
1013       break;
1014 
1015     case e_double:
1016       m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
1017       m_float.convertFromAPInt(m_integer, false,
1018                                llvm::APFloat::rmNearestTiesToEven);
1019       success = true;
1020       break;
1021 
1022     case e_long_double:
1023       m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended());
1024       m_float.convertFromAPInt(m_integer, false,
1025                                llvm::APFloat::rmNearestTiesToEven);
1026       success = true;
1027       break;
1028     }
1029     break;
1030 
1031   case e_sint512:
1032   case e_uint512:
1033     lldbassert(false && "unimplemented");
1034     break;
1035 
1036   case e_float:
1037     switch (type) {
1038     case e_void:
1039     case e_sint:
1040     case e_uint:
1041     case e_slong:
1042     case e_ulong:
1043     case e_slonglong:
1044     case e_ulonglong:
1045     case e_sint128:
1046     case e_uint128:
1047     case e_sint256:
1048     case e_uint256:
1049     case e_uint512:
1050     case e_sint512:
1051       break;
1052     case e_float:
1053       success = true;
1054       break;
1055     case e_double:
1056       m_float = llvm::APFloat(static_cast<double_t>(m_float.convertToFloat()));
1057       success = true;
1058       break;
1059 
1060     case e_long_double: {
1061       bool ignore;
1062       m_float.convert(llvm::APFloat::x87DoubleExtended(),
1063                       llvm::APFloat::rmNearestTiesToEven, &ignore);
1064       success = true;
1065       break;
1066     }
1067     }
1068     break;
1069 
1070   case e_double:
1071     switch (type) {
1072     case e_void:
1073     case e_sint:
1074     case e_uint:
1075     case e_slong:
1076     case e_ulong:
1077     case e_slonglong:
1078     case e_ulonglong:
1079     case e_sint128:
1080     case e_uint128:
1081     case e_sint256:
1082     case e_uint256:
1083     case e_sint512:
1084     case e_uint512:
1085     case e_float:
1086       break;
1087     case e_double:
1088       success = true;
1089       break;
1090     case e_long_double: {
1091       bool ignore;
1092       m_float.convert(llvm::APFloat::x87DoubleExtended(),
1093                       llvm::APFloat::rmNearestTiesToEven, &ignore);
1094       success = true;
1095       break;
1096     }
1097     }
1098     break;
1099 
1100   case e_long_double:
1101     switch (type) {
1102     case e_void:
1103     case e_sint:
1104     case e_uint:
1105     case e_slong:
1106     case e_ulong:
1107     case e_slonglong:
1108     case e_ulonglong:
1109     case e_sint128:
1110     case e_uint128:
1111     case e_sint256:
1112     case e_uint256:
1113     case e_sint512:
1114     case e_uint512:
1115     case e_float:
1116     case e_double:
1117       break;
1118     case e_long_double:
1119       success = true;
1120       break;
1121     }
1122     break;
1123   }
1124 
1125   if (success)
1126     m_type = type;
1127   return success;
1128 }
1129 
1130 const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
1131   switch (type) {
1132   case e_void:
1133     return "void";
1134   case e_sint:
1135     return "int";
1136   case e_uint:
1137     return "unsigned int";
1138   case e_slong:
1139     return "long";
1140   case e_ulong:
1141     return "unsigned long";
1142   case e_slonglong:
1143     return "long long";
1144   case e_ulonglong:
1145     return "unsigned long long";
1146   case e_float:
1147     return "float";
1148   case e_double:
1149     return "double";
1150   case e_long_double:
1151     return "long double";
1152   case e_sint128:
1153     return "int128_t";
1154   case e_uint128:
1155     return "uint128_t";
1156   case e_sint256:
1157     return "int256_t";
1158   case e_uint256:
1159     return "uint256_t";
1160   case e_sint512:
1161     return "int512_t";
1162   case e_uint512:
1163     return "uint512_t";
1164   }
1165   return "???";
1166 }
1167 
1168 Scalar::Type
1169 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
1170   if (byte_size <= sizeof(sint_t))
1171     return e_sint;
1172   if (byte_size <= sizeof(slong_t))
1173     return e_slong;
1174   if (byte_size <= sizeof(slonglong_t))
1175     return e_slonglong;
1176   return e_void;
1177 }
1178 
1179 Scalar::Type
1180 Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
1181   if (byte_size <= sizeof(uint_t))
1182     return e_uint;
1183   if (byte_size <= sizeof(ulong_t))
1184     return e_ulong;
1185   if (byte_size <= sizeof(ulonglong_t))
1186     return e_ulonglong;
1187   return e_void;
1188 }
1189 
1190 Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
1191   if (byte_size == sizeof(float_t))
1192     return e_float;
1193   if (byte_size == sizeof(double_t))
1194     return e_double;
1195   if (byte_size == sizeof(long_double_t))
1196     return e_long_double;
1197   return e_void;
1198 }
1199 
1200 bool Scalar::MakeSigned() {
1201   bool success = false;
1202 
1203   switch (m_type) {
1204   case e_void:
1205     break;
1206   case e_sint:
1207     success = true;
1208     break;
1209   case e_uint:
1210     m_type = e_sint;
1211     success = true;
1212     break;
1213   case e_slong:
1214     success = true;
1215     break;
1216   case e_ulong:
1217     m_type = e_slong;
1218     success = true;
1219     break;
1220   case e_slonglong:
1221     success = true;
1222     break;
1223   case e_ulonglong:
1224     m_type = e_slonglong;
1225     success = true;
1226     break;
1227   case e_sint128:
1228     success = true;
1229     break;
1230   case e_uint128:
1231     m_type = e_sint128;
1232     success = true;
1233     break;
1234   case e_sint256:
1235     success = true;
1236     break;
1237   case e_uint256:
1238     m_type = e_sint256;
1239     success = true;
1240     break;
1241   case e_sint512:
1242     success = true;
1243     break;
1244   case e_uint512:
1245     m_type = e_sint512;
1246     success = true;
1247     break;
1248   case e_float:
1249     success = true;
1250     break;
1251   case e_double:
1252     success = true;
1253     break;
1254   case e_long_double:
1255     success = true;
1256     break;
1257   }
1258 
1259   return success;
1260 }
1261 
1262 bool Scalar::MakeUnsigned() {
1263   bool success = false;
1264 
1265   switch (m_type) {
1266   case e_void:
1267     break;
1268   case e_sint:
1269     m_type = e_uint;
1270     success = true;
1271     break;
1272   case e_uint:
1273     success = true;
1274     break;
1275   case e_slong:
1276     m_type = e_ulong;
1277     success = true;
1278     break;
1279   case e_ulong:
1280     success = true;
1281     break;
1282   case e_slonglong:
1283     m_type = e_ulonglong;
1284     success = true;
1285     break;
1286   case e_ulonglong:
1287     success = true;
1288     break;
1289   case e_sint128:
1290     m_type = e_uint128;
1291     success = true;
1292     break;
1293   case e_uint128:
1294     success = true;
1295     break;
1296   case e_sint256:
1297     m_type = e_uint256;
1298     success = true;
1299     break;
1300   case e_uint256:
1301     success = true;
1302     break;
1303   case e_sint512:
1304     m_type = e_uint512;
1305     success = true;
1306     break;
1307   case e_uint512:
1308     success = true;
1309     break;
1310   case e_float:
1311     success = true;
1312     break;
1313   case e_double:
1314     success = true;
1315     break;
1316   case e_long_double:
1317     success = true;
1318     break;
1319   }
1320 
1321   return success;
1322 }
1323 
1324 signed char Scalar::SChar(char fail_value) const {
1325   switch (m_type) {
1326   case e_void:
1327     break;
1328   case e_sint:
1329   case e_uint:
1330   case e_slong:
1331   case e_ulong:
1332   case e_slonglong:
1333   case e_ulonglong:
1334   case e_sint128:
1335   case e_uint128:
1336   case e_sint256:
1337   case e_uint256:
1338   case e_sint512:
1339   case e_uint512:
1340     return static_cast<schar_t>(
1341         (m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
1342   case e_float:
1343     return static_cast<schar_t>(m_float.convertToFloat());
1344   case e_double:
1345     return static_cast<schar_t>(m_float.convertToDouble());
1346   case e_long_double:
1347     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1348     return static_cast<schar_t>(
1349         (ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
1350   }
1351   return fail_value;
1352 }
1353 
1354 unsigned char Scalar::UChar(unsigned char fail_value) const {
1355   switch (m_type) {
1356   case e_void:
1357     break;
1358   case e_sint:
1359   case e_uint:
1360   case e_slong:
1361   case e_ulong:
1362   case e_slonglong:
1363   case e_ulonglong:
1364   case e_sint128:
1365   case e_uint128:
1366   case e_sint256:
1367   case e_uint256:
1368   case e_sint512:
1369   case e_uint512:
1370     return static_cast<uchar_t>(
1371         (m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
1372   case e_float:
1373     return static_cast<uchar_t>(m_float.convertToFloat());
1374   case e_double:
1375     return static_cast<uchar_t>(m_float.convertToDouble());
1376   case e_long_double:
1377     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1378     return static_cast<uchar_t>(
1379         (ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue());
1380   }
1381   return fail_value;
1382 }
1383 
1384 short Scalar::SShort(short fail_value) const {
1385   switch (m_type) {
1386   case e_void:
1387     break;
1388   case e_sint:
1389   case e_uint:
1390   case e_slong:
1391   case e_ulong:
1392   case e_slonglong:
1393   case e_ulonglong:
1394   case e_sint128:
1395   case e_uint128:
1396   case e_sint256:
1397   case e_uint256:
1398   case e_sint512:
1399   case e_uint512:
1400     return static_cast<sshort_t>(
1401         (m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
1402   case e_float:
1403     return static_cast<sshort_t>(m_float.convertToFloat());
1404   case e_double:
1405     return static_cast<sshort_t>(m_float.convertToDouble());
1406   case e_long_double:
1407     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1408     return static_cast<sshort_t>(
1409         (ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue());
1410   }
1411   return fail_value;
1412 }
1413 
1414 unsigned short Scalar::UShort(unsigned short fail_value) const {
1415   switch (m_type) {
1416   case e_void:
1417     break;
1418   case e_sint:
1419   case e_uint:
1420   case e_slong:
1421   case e_ulong:
1422   case e_slonglong:
1423   case e_ulonglong:
1424   case e_sint128:
1425   case e_uint128:
1426   case e_sint256:
1427   case e_uint256:
1428   case e_sint512:
1429   case e_uint512:
1430     return static_cast<ushort_t>(
1431         (m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
1432   case e_float:
1433     return static_cast<ushort_t>(m_float.convertToFloat());
1434   case e_double:
1435     return static_cast<ushort_t>(m_float.convertToDouble());
1436   case e_long_double:
1437     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1438     return static_cast<ushort_t>(
1439         (ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue());
1440   }
1441   return fail_value;
1442 }
1443 
1444 int Scalar::SInt(int fail_value) const {
1445   switch (m_type) {
1446   case e_void:
1447     break;
1448   case e_sint:
1449   case e_uint:
1450   case e_slong:
1451   case e_ulong:
1452   case e_slonglong:
1453   case e_ulonglong:
1454   case e_sint128:
1455   case e_uint128:
1456   case e_sint256:
1457   case e_uint256:
1458   case e_sint512:
1459   case e_uint512:
1460     return static_cast<sint_t>(
1461         (m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
1462   case e_float:
1463     return static_cast<sint_t>(m_float.convertToFloat());
1464   case e_double:
1465     return static_cast<sint_t>(m_float.convertToDouble());
1466   case e_long_double:
1467     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1468     return static_cast<sint_t>(
1469         (ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue());
1470   }
1471   return fail_value;
1472 }
1473 
1474 unsigned int Scalar::UInt(unsigned int fail_value) const {
1475   switch (m_type) {
1476   case e_void:
1477     break;
1478   case e_sint:
1479   case e_uint:
1480   case e_slong:
1481   case e_ulong:
1482   case e_slonglong:
1483   case e_ulonglong:
1484   case e_sint128:
1485   case e_uint128:
1486   case e_sint256:
1487   case e_uint256:
1488   case e_sint512:
1489   case e_uint512:
1490     return static_cast<uint_t>(
1491         (m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
1492   case e_float:
1493     return static_cast<uint_t>(m_float.convertToFloat());
1494   case e_double:
1495     return static_cast<uint_t>(m_float.convertToDouble());
1496   case e_long_double:
1497     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1498     return static_cast<uint_t>(
1499         (ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue());
1500   }
1501   return fail_value;
1502 }
1503 
1504 long Scalar::SLong(long fail_value) const {
1505   switch (m_type) {
1506   case e_void:
1507     break;
1508   case e_sint:
1509   case e_uint:
1510   case e_slong:
1511   case e_ulong:
1512   case e_slonglong:
1513   case e_ulonglong:
1514   case e_sint128:
1515   case e_uint128:
1516   case e_sint256:
1517   case e_uint256:
1518   case e_sint512:
1519   case e_uint512:
1520     return static_cast<slong_t>(
1521         (m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
1522   case e_float:
1523     return static_cast<slong_t>(m_float.convertToFloat());
1524   case e_double:
1525     return static_cast<slong_t>(m_float.convertToDouble());
1526   case e_long_double:
1527     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1528     return static_cast<slong_t>(
1529         (ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue());
1530   }
1531   return fail_value;
1532 }
1533 
1534 unsigned long Scalar::ULong(unsigned long fail_value) const {
1535   switch (m_type) {
1536   case e_void:
1537     break;
1538   case e_sint:
1539   case e_uint:
1540   case e_slong:
1541   case e_ulong:
1542   case e_slonglong:
1543   case e_ulonglong:
1544   case e_sint128:
1545   case e_uint128:
1546   case e_sint256:
1547   case e_uint256:
1548   case e_sint512:
1549   case e_uint512:
1550     return static_cast<ulong_t>(
1551         (m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
1552   case e_float:
1553     return static_cast<ulong_t>(m_float.convertToFloat());
1554   case e_double:
1555     return static_cast<ulong_t>(m_float.convertToDouble());
1556   case e_long_double:
1557     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1558     return static_cast<ulong_t>(
1559         (ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue());
1560   }
1561   return fail_value;
1562 }
1563 
1564 long long Scalar::SLongLong(long long fail_value) const {
1565   switch (m_type) {
1566   case e_void:
1567     break;
1568   case e_sint:
1569   case e_uint:
1570   case e_slong:
1571   case e_ulong:
1572   case e_slonglong:
1573   case e_ulonglong:
1574   case e_sint128:
1575   case e_uint128:
1576   case e_sint256:
1577   case e_uint256:
1578   case e_sint512:
1579   case e_uint512:
1580     return static_cast<slonglong_t>(
1581         (m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
1582   case e_float:
1583     return static_cast<slonglong_t>(m_float.convertToFloat());
1584   case e_double:
1585     return static_cast<slonglong_t>(m_float.convertToDouble());
1586   case e_long_double:
1587     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1588     return static_cast<slonglong_t>(
1589         (ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue());
1590   }
1591   return fail_value;
1592 }
1593 
1594 unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
1595   switch (m_type) {
1596   case e_void:
1597     break;
1598   case e_sint:
1599   case e_uint:
1600   case e_slong:
1601   case e_ulong:
1602   case e_slonglong:
1603   case e_ulonglong:
1604   case e_sint128:
1605   case e_uint128:
1606   case e_sint256:
1607   case e_uint256:
1608   case e_sint512:
1609   case e_uint512:
1610     return static_cast<ulonglong_t>(
1611         (m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
1612   case e_float:
1613     return static_cast<ulonglong_t>(m_float.convertToFloat());
1614   case e_double: {
1615     double d_val = m_float.convertToDouble();
1616     llvm::APInt rounded_double =
1617         llvm::APIntOps::RoundDoubleToAPInt(d_val, sizeof(ulonglong_t) * 8);
1618     return static_cast<ulonglong_t>(
1619         (rounded_double.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
1620   }
1621   case e_long_double:
1622     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1623     return static_cast<ulonglong_t>(
1624         (ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue());
1625   }
1626   return fail_value;
1627 }
1628 
1629 llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
1630   switch (m_type) {
1631   case e_void:
1632     break;
1633   case e_sint:
1634   case e_uint:
1635   case e_slong:
1636   case e_ulong:
1637   case e_slonglong:
1638   case e_ulonglong:
1639   case e_sint128:
1640   case e_uint128:
1641   case e_sint256:
1642   case e_uint256:
1643   case e_sint512:
1644   case e_uint512:
1645     return m_integer;
1646   case e_float:
1647   case e_double:
1648   case e_long_double:
1649     return m_float.bitcastToAPInt();
1650   }
1651   return fail_value;
1652 }
1653 
1654 llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
1655   switch (m_type) {
1656   case e_void:
1657     break;
1658   case e_sint:
1659   case e_uint:
1660   case e_slong:
1661   case e_ulong:
1662   case e_slonglong:
1663   case e_ulonglong:
1664   case e_sint128:
1665   case e_uint128:
1666   case e_sint256:
1667   case e_uint256:
1668   case e_sint512:
1669   case e_uint512:
1670     return m_integer;
1671   case e_float:
1672   case e_double:
1673   case e_long_double:
1674     return m_float.bitcastToAPInt();
1675   }
1676   return fail_value;
1677 }
1678 
1679 float Scalar::Float(float fail_value) const {
1680   switch (m_type) {
1681   case e_void:
1682     break;
1683   case e_sint:
1684   case e_uint:
1685   case e_slong:
1686   case e_ulong:
1687   case e_slonglong:
1688   case e_ulonglong:
1689   case e_sint128:
1690   case e_uint128:
1691   case e_sint256:
1692   case e_uint256:
1693   case e_sint512:
1694   case e_uint512:
1695     return llvm::APIntOps::RoundAPIntToFloat(m_integer);
1696   case e_float:
1697     return m_float.convertToFloat();
1698   case e_double:
1699     return static_cast<float_t>(m_float.convertToDouble());
1700   case e_long_double:
1701     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1702     return ldbl_val.bitsToFloat();
1703   }
1704   return fail_value;
1705 }
1706 
1707 double Scalar::Double(double fail_value) const {
1708   switch (m_type) {
1709   case e_void:
1710     break;
1711   case e_sint:
1712   case e_uint:
1713   case e_slong:
1714   case e_ulong:
1715   case e_slonglong:
1716   case e_ulonglong:
1717   case e_sint128:
1718   case e_uint128:
1719   case e_sint256:
1720   case e_uint256:
1721   case e_sint512:
1722   case e_uint512:
1723     return llvm::APIntOps::RoundAPIntToDouble(m_integer);
1724   case e_float:
1725     return static_cast<double_t>(m_float.convertToFloat());
1726   case e_double:
1727     return m_float.convertToDouble();
1728   case e_long_double:
1729     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1730     return ldbl_val.bitsToFloat();
1731   }
1732   return fail_value;
1733 }
1734 
1735 long double Scalar::LongDouble(long double fail_value) const {
1736   switch (m_type) {
1737   case e_void:
1738     break;
1739   case e_sint:
1740   case e_uint:
1741   case e_slong:
1742   case e_ulong:
1743   case e_slonglong:
1744   case e_ulonglong:
1745   case e_sint128:
1746   case e_uint128:
1747   case e_sint256:
1748   case e_uint256:
1749   case e_sint512:
1750   case e_uint512:
1751     return static_cast<long_double_t>(
1752         llvm::APIntOps::RoundAPIntToDouble(m_integer));
1753   case e_float:
1754     return static_cast<long_double_t>(m_float.convertToFloat());
1755   case e_double:
1756     return static_cast<long_double_t>(m_float.convertToDouble());
1757   case e_long_double:
1758     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
1759     return static_cast<long_double_t>(ldbl_val.bitsToDouble());
1760   }
1761   return fail_value;
1762 }
1763 
1764 Scalar &Scalar::operator+=(const Scalar &rhs) {
1765   Scalar temp_value;
1766   const Scalar *a;
1767   const Scalar *b;
1768   if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
1769       Scalar::e_void) {
1770     switch (m_type) {
1771     case e_void:
1772       break;
1773     case e_sint:
1774     case e_uint:
1775     case e_slong:
1776     case e_ulong:
1777     case e_slonglong:
1778     case e_ulonglong:
1779     case e_sint128:
1780     case e_uint128:
1781     case e_sint256:
1782     case e_uint256:
1783     case e_sint512:
1784     case e_uint512:
1785       m_integer = a->m_integer + b->m_integer;
1786       break;
1787 
1788     case e_float:
1789     case e_double:
1790     case e_long_double:
1791       m_float = a->m_float + b->m_float;
1792       break;
1793     }
1794   }
1795   return *this;
1796 }
1797 
1798 Scalar &Scalar::operator<<=(const Scalar &rhs) {
1799   switch (m_type) {
1800   case e_void:
1801   case e_float:
1802   case e_double:
1803   case e_long_double:
1804     m_type = e_void;
1805     break;
1806 
1807   case e_sint:
1808   case e_uint:
1809   case e_slong:
1810   case e_ulong:
1811   case e_slonglong:
1812   case e_ulonglong:
1813   case e_sint128:
1814   case e_uint128:
1815   case e_sint256:
1816   case e_uint256:
1817   case e_sint512:
1818   case e_uint512:
1819     switch (rhs.m_type) {
1820     case e_void:
1821     case e_float:
1822     case e_double:
1823     case e_long_double:
1824       m_type = e_void;
1825       break;
1826     case e_sint:
1827     case e_uint:
1828     case e_slong:
1829     case e_ulong:
1830     case e_slonglong:
1831     case e_ulonglong:
1832     case e_sint128:
1833     case e_uint128:
1834     case e_sint256:
1835     case e_uint256:
1836     case e_sint512:
1837     case e_uint512:
1838       m_integer = m_integer << rhs.m_integer;
1839       break;
1840     }
1841     break;
1842   }
1843   return *this;
1844 }
1845 
1846 bool Scalar::ShiftRightLogical(const Scalar &rhs) {
1847   switch (m_type) {
1848   case e_void:
1849   case e_float:
1850   case e_double:
1851   case e_long_double:
1852     m_type = e_void;
1853     break;
1854 
1855   case e_sint:
1856   case e_uint:
1857   case e_slong:
1858   case e_ulong:
1859   case e_slonglong:
1860   case e_ulonglong:
1861   case e_sint128:
1862   case e_uint128:
1863   case e_sint256:
1864   case e_uint256:
1865   case e_sint512:
1866   case e_uint512:
1867     switch (rhs.m_type) {
1868     case e_void:
1869     case e_float:
1870     case e_double:
1871     case e_long_double:
1872       m_type = e_void;
1873       break;
1874     case e_sint:
1875     case e_uint:
1876     case e_slong:
1877     case e_ulong:
1878     case e_slonglong:
1879     case e_ulonglong:
1880     case e_sint128:
1881     case e_uint128:
1882     case e_sint256:
1883     case e_uint256:
1884     case e_sint512:
1885     case e_uint512:
1886       m_integer = m_integer.lshr(rhs.m_integer);
1887       break;
1888     }
1889     break;
1890   }
1891   return m_type != e_void;
1892 }
1893 
1894 Scalar &Scalar::operator>>=(const Scalar &rhs) {
1895   switch (m_type) {
1896   case e_void:
1897   case e_float:
1898   case e_double:
1899   case e_long_double:
1900     m_type = e_void;
1901     break;
1902 
1903   case e_sint:
1904   case e_uint:
1905   case e_slong:
1906   case e_ulong:
1907   case e_slonglong:
1908   case e_ulonglong:
1909   case e_sint128:
1910   case e_uint128:
1911   case e_sint256:
1912   case e_uint256:
1913   case e_sint512:
1914   case e_uint512:
1915     switch (rhs.m_type) {
1916     case e_void:
1917     case e_float:
1918     case e_double:
1919     case e_long_double:
1920       m_type = e_void;
1921       break;
1922     case e_sint:
1923     case e_uint:
1924     case e_slong:
1925     case e_ulong:
1926     case e_slonglong:
1927     case e_ulonglong:
1928     case e_sint128:
1929     case e_uint128:
1930     case e_sint256:
1931     case e_uint256:
1932     case e_sint512:
1933     case e_uint512:
1934       m_integer = m_integer.ashr(rhs.m_integer);
1935       break;
1936     }
1937     break;
1938   }
1939   return *this;
1940 }
1941 
1942 Scalar &Scalar::operator&=(const Scalar &rhs) {
1943   switch (m_type) {
1944   case e_void:
1945   case e_float:
1946   case e_double:
1947   case e_long_double:
1948     m_type = e_void;
1949     break;
1950 
1951   case e_sint:
1952   case e_uint:
1953   case e_slong:
1954   case e_ulong:
1955   case e_slonglong:
1956   case e_ulonglong:
1957   case e_sint128:
1958   case e_uint128:
1959   case e_sint256:
1960   case e_uint256:
1961   case e_sint512:
1962   case e_uint512:
1963     switch (rhs.m_type) {
1964     case e_void:
1965     case e_float:
1966     case e_double:
1967     case e_long_double:
1968       m_type = e_void;
1969       break;
1970     case e_sint:
1971     case e_uint:
1972     case e_slong:
1973     case e_ulong:
1974     case e_slonglong:
1975     case e_ulonglong:
1976     case e_sint128:
1977     case e_uint128:
1978     case e_sint256:
1979     case e_uint256:
1980     case e_sint512:
1981     case e_uint512:
1982       m_integer &= rhs.m_integer;
1983       break;
1984     }
1985     break;
1986   }
1987   return *this;
1988 }
1989 
1990 bool Scalar::AbsoluteValue() {
1991   switch (m_type) {
1992   case e_void:
1993     break;
1994 
1995   case e_sint:
1996   case e_slong:
1997   case e_slonglong:
1998   case e_sint128:
1999   case e_sint256:
2000   case e_sint512:
2001     if (m_integer.isNegative())
2002       m_integer = -m_integer;
2003     return true;
2004 
2005   case e_uint:
2006   case e_ulong:
2007   case e_ulonglong:
2008     return true;
2009   case e_uint128:
2010   case e_uint256:
2011   case e_uint512:
2012   case e_float:
2013   case e_double:
2014   case e_long_double:
2015     m_float.clearSign();
2016     return true;
2017   }
2018   return false;
2019 }
2020 
2021 bool Scalar::UnaryNegate() {
2022   switch (m_type) {
2023   case e_void:
2024     break;
2025   case e_sint:
2026   case e_uint:
2027   case e_slong:
2028   case e_ulong:
2029   case e_slonglong:
2030   case e_ulonglong:
2031   case e_sint128:
2032   case e_uint128:
2033   case e_sint256:
2034   case e_uint256:
2035   case e_sint512:
2036   case e_uint512:
2037     m_integer = -m_integer;
2038     return true;
2039   case e_float:
2040   case e_double:
2041   case e_long_double:
2042     m_float.changeSign();
2043     return true;
2044   }
2045   return false;
2046 }
2047 
2048 bool Scalar::OnesComplement() {
2049   switch (m_type) {
2050   case e_sint:
2051   case e_uint:
2052   case e_slong:
2053   case e_ulong:
2054   case e_slonglong:
2055   case e_ulonglong:
2056   case e_sint128:
2057   case e_uint128:
2058   case e_sint256:
2059   case e_uint256:
2060   case e_sint512:
2061   case e_uint512:
2062     m_integer = ~m_integer;
2063     return true;
2064 
2065   case e_void:
2066   case e_float:
2067   case e_double:
2068   case e_long_double:
2069     break;
2070   }
2071   return false;
2072 }
2073 
2074 const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
2075   Scalar result;
2076   Scalar temp_value;
2077   const Scalar *a;
2078   const Scalar *b;
2079   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2080       Scalar::e_void) {
2081     switch (result.m_type) {
2082     case Scalar::e_void:
2083       break;
2084     case Scalar::e_sint:
2085     case Scalar::e_uint:
2086     case Scalar::e_slong:
2087     case Scalar::e_ulong:
2088     case Scalar::e_slonglong:
2089     case Scalar::e_ulonglong:
2090     case Scalar::e_sint128:
2091     case Scalar::e_uint128:
2092     case Scalar::e_sint256:
2093     case Scalar::e_uint256:
2094     case Scalar::e_sint512:
2095     case Scalar::e_uint512:
2096       result.m_integer = a->m_integer + b->m_integer;
2097       break;
2098     case Scalar::e_float:
2099     case Scalar::e_double:
2100     case Scalar::e_long_double:
2101       result.m_float = a->m_float + b->m_float;
2102       break;
2103     }
2104   }
2105   return result;
2106 }
2107 
2108 const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
2109   Scalar result;
2110   Scalar temp_value;
2111   const Scalar *a;
2112   const Scalar *b;
2113   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2114       Scalar::e_void) {
2115     switch (result.m_type) {
2116     case Scalar::e_void:
2117       break;
2118     case Scalar::e_sint:
2119     case Scalar::e_uint:
2120     case Scalar::e_slong:
2121     case Scalar::e_ulong:
2122     case Scalar::e_slonglong:
2123     case Scalar::e_ulonglong:
2124     case Scalar::e_sint128:
2125     case Scalar::e_uint128:
2126     case Scalar::e_sint256:
2127     case Scalar::e_uint256:
2128     case Scalar::e_sint512:
2129     case Scalar::e_uint512:
2130       result.m_integer = a->m_integer - b->m_integer;
2131       break;
2132     case Scalar::e_float:
2133     case Scalar::e_double:
2134     case Scalar::e_long_double:
2135       result.m_float = a->m_float - b->m_float;
2136       break;
2137     }
2138   }
2139   return result;
2140 }
2141 
2142 const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
2143   Scalar result;
2144   Scalar temp_value;
2145   const Scalar *a;
2146   const Scalar *b;
2147   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2148       Scalar::e_void) {
2149     switch (result.m_type) {
2150     case Scalar::e_void:
2151       break;
2152     case Scalar::e_sint:
2153     case Scalar::e_slong:
2154     case Scalar::e_slonglong:
2155     case Scalar::e_sint128:
2156     case Scalar::e_sint256:
2157     case Scalar::e_sint512:
2158       if (b->m_integer != 0) {
2159         result.m_integer = a->m_integer.sdiv(b->m_integer);
2160         return result;
2161       }
2162       break;
2163     case Scalar::e_uint:
2164     case Scalar::e_ulong:
2165     case Scalar::e_ulonglong:
2166     case Scalar::e_uint128:
2167     case Scalar::e_uint256:
2168     case Scalar::e_uint512:
2169       if (b->m_integer != 0) {
2170         result.m_integer = a->m_integer.udiv(b->m_integer);
2171         return result;
2172       }
2173       break;
2174     case Scalar::e_float:
2175     case Scalar::e_double:
2176     case Scalar::e_long_double:
2177       if (!b->m_float.isZero()) {
2178         result.m_float = a->m_float / b->m_float;
2179         return result;
2180       }
2181       break;
2182     }
2183   }
2184   // For division only, the only way it should make it here is if a promotion
2185   // failed, or if we are trying to do a divide by zero.
2186   result.m_type = Scalar::e_void;
2187   return result;
2188 }
2189 
2190 const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
2191   Scalar result;
2192   Scalar temp_value;
2193   const Scalar *a;
2194   const Scalar *b;
2195   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2196       Scalar::e_void) {
2197     switch (result.m_type) {
2198     case Scalar::e_void:
2199       break;
2200     case Scalar::e_sint:
2201     case Scalar::e_uint:
2202     case Scalar::e_slong:
2203     case Scalar::e_ulong:
2204     case Scalar::e_slonglong:
2205     case Scalar::e_ulonglong:
2206     case Scalar::e_sint128:
2207     case Scalar::e_uint128:
2208     case Scalar::e_sint256:
2209     case Scalar::e_uint256:
2210     case Scalar::e_sint512:
2211     case Scalar::e_uint512:
2212       result.m_integer = a->m_integer * b->m_integer;
2213       break;
2214     case Scalar::e_float:
2215     case Scalar::e_double:
2216     case Scalar::e_long_double:
2217       result.m_float = a->m_float * b->m_float;
2218       break;
2219     }
2220   }
2221   return result;
2222 }
2223 
2224 const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
2225   Scalar result;
2226   Scalar temp_value;
2227   const Scalar *a;
2228   const Scalar *b;
2229   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2230       Scalar::e_void) {
2231     switch (result.m_type) {
2232     case Scalar::e_sint:
2233     case Scalar::e_uint:
2234     case Scalar::e_slong:
2235     case Scalar::e_ulong:
2236     case Scalar::e_slonglong:
2237     case Scalar::e_ulonglong:
2238     case Scalar::e_sint128:
2239     case Scalar::e_uint128:
2240     case Scalar::e_sint256:
2241     case Scalar::e_uint256:
2242     case Scalar::e_sint512:
2243     case Scalar::e_uint512:
2244       result.m_integer = a->m_integer & b->m_integer;
2245       break;
2246     case Scalar::e_void:
2247     case Scalar::e_float:
2248     case Scalar::e_double:
2249     case Scalar::e_long_double:
2250       // No bitwise AND on floats, doubles of long doubles
2251       result.m_type = Scalar::e_void;
2252       break;
2253     }
2254   }
2255   return result;
2256 }
2257 
2258 const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
2259   Scalar result;
2260   Scalar temp_value;
2261   const Scalar *a;
2262   const Scalar *b;
2263   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2264       Scalar::e_void) {
2265     switch (result.m_type) {
2266     case Scalar::e_sint:
2267     case Scalar::e_uint:
2268     case Scalar::e_slong:
2269     case Scalar::e_ulong:
2270     case Scalar::e_slonglong:
2271     case Scalar::e_ulonglong:
2272     case Scalar::e_sint128:
2273     case Scalar::e_uint128:
2274     case Scalar::e_sint256:
2275     case Scalar::e_uint256:
2276     case Scalar::e_sint512:
2277     case Scalar::e_uint512:
2278       result.m_integer = a->m_integer | b->m_integer;
2279       break;
2280 
2281     case Scalar::e_void:
2282     case Scalar::e_float:
2283     case Scalar::e_double:
2284     case Scalar::e_long_double:
2285       // No bitwise AND on floats, doubles of long doubles
2286       result.m_type = Scalar::e_void;
2287       break;
2288     }
2289   }
2290   return result;
2291 }
2292 
2293 const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
2294   Scalar result;
2295   Scalar temp_value;
2296   const Scalar *a;
2297   const Scalar *b;
2298   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2299       Scalar::e_void) {
2300     switch (result.m_type) {
2301     default:
2302       break;
2303     case Scalar::e_void:
2304       break;
2305     case Scalar::e_sint:
2306     case Scalar::e_slong:
2307     case Scalar::e_slonglong:
2308     case Scalar::e_sint128:
2309     case Scalar::e_sint256:
2310     case Scalar::e_sint512:
2311       if (b->m_integer != 0) {
2312         result.m_integer = a->m_integer.srem(b->m_integer);
2313         return result;
2314       }
2315       break;
2316     case Scalar::e_uint:
2317     case Scalar::e_ulong:
2318     case Scalar::e_ulonglong:
2319     case Scalar::e_uint128:
2320     case Scalar::e_uint256:
2321     case Scalar::e_uint512:
2322       if (b->m_integer != 0) {
2323         result.m_integer = a->m_integer.urem(b->m_integer);
2324         return result;
2325       }
2326       break;
2327     }
2328   }
2329   result.m_type = Scalar::e_void;
2330   return result;
2331 }
2332 
2333 const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
2334   Scalar result;
2335   Scalar temp_value;
2336   const Scalar *a;
2337   const Scalar *b;
2338   if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
2339       Scalar::e_void) {
2340     switch (result.m_type) {
2341     case Scalar::e_sint:
2342     case Scalar::e_uint:
2343     case Scalar::e_slong:
2344     case Scalar::e_ulong:
2345     case Scalar::e_slonglong:
2346     case Scalar::e_ulonglong:
2347     case Scalar::e_sint128:
2348     case Scalar::e_uint128:
2349     case Scalar::e_sint256:
2350     case Scalar::e_uint256:
2351     case Scalar::e_sint512:
2352     case Scalar::e_uint512:
2353       result.m_integer = a->m_integer ^ b->m_integer;
2354       break;
2355 
2356     case Scalar::e_void:
2357     case Scalar::e_float:
2358     case Scalar::e_double:
2359     case Scalar::e_long_double:
2360       // No bitwise AND on floats, doubles of long doubles
2361       result.m_type = Scalar::e_void;
2362       break;
2363     }
2364   }
2365   return result;
2366 }
2367 
2368 const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
2369   Scalar result = lhs;
2370   result <<= rhs;
2371   return result;
2372 }
2373 
2374 const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
2375   Scalar result = lhs;
2376   result >>= rhs;
2377   return result;
2378 }
2379 
2380 Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
2381                                    size_t byte_size) {
2382   Status error;
2383   if (value_str == nullptr || value_str[0] == '\0') {
2384     error.SetErrorString("Invalid c-string value string.");
2385     return error;
2386   }
2387   switch (encoding) {
2388   case eEncodingInvalid:
2389     error.SetErrorString("Invalid encoding.");
2390     break;
2391 
2392   case eEncodingUint:
2393     if (byte_size <= sizeof(uint64_t)) {
2394       uint64_t uval64;
2395       if (!llvm::to_integer(value_str, uval64))
2396         error.SetErrorStringWithFormat(
2397             "'%s' is not a valid unsigned integer string value", value_str);
2398       else if (!UIntValueIsValidForSize(uval64, byte_size))
2399         error.SetErrorStringWithFormat(
2400             "value 0x%" PRIx64 " is too large to fit in a %" PRIu64
2401             " byte unsigned integer value",
2402             uval64, static_cast<uint64_t>(byte_size));
2403       else {
2404         m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
2405         switch (m_type) {
2406         case e_uint:
2407           m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
2408           break;
2409         case e_ulong:
2410           m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
2411           break;
2412         case e_ulonglong:
2413           m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
2414           break;
2415         default:
2416           error.SetErrorStringWithFormat(
2417               "unsupported unsigned integer byte size: %" PRIu64 "",
2418               static_cast<uint64_t>(byte_size));
2419           break;
2420         }
2421       }
2422     } else {
2423       error.SetErrorStringWithFormat(
2424           "unsupported unsigned integer byte size: %" PRIu64 "",
2425           static_cast<uint64_t>(byte_size));
2426       return error;
2427     }
2428     break;
2429 
2430   case eEncodingSint:
2431     if (byte_size <= sizeof(int64_t)) {
2432       int64_t sval64;
2433       if (!llvm::to_integer(value_str, sval64))
2434         error.SetErrorStringWithFormat(
2435             "'%s' is not a valid signed integer string value", value_str);
2436       else if (!SIntValueIsValidForSize(sval64, byte_size))
2437         error.SetErrorStringWithFormat(
2438             "value 0x%" PRIx64 " is too large to fit in a %" PRIu64
2439             " byte signed integer value",
2440             sval64, static_cast<uint64_t>(byte_size));
2441       else {
2442         m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
2443         switch (m_type) {
2444         case e_sint:
2445           m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
2446           break;
2447         case e_slong:
2448           m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
2449           break;
2450         case e_slonglong:
2451           m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
2452           break;
2453         default:
2454           error.SetErrorStringWithFormat(
2455               "unsupported signed integer byte size: %" PRIu64 "",
2456               static_cast<uint64_t>(byte_size));
2457           break;
2458         }
2459       }
2460     } else {
2461       error.SetErrorStringWithFormat(
2462           "unsupported signed integer byte size: %" PRIu64 "",
2463           static_cast<uint64_t>(byte_size));
2464       return error;
2465     }
2466     break;
2467 
2468   case eEncodingIEEE754:
2469     static float f_val;
2470     static double d_val;
2471     static long double l_val;
2472     if (byte_size == sizeof(float)) {
2473       if (::sscanf(value_str, "%f", &f_val) == 1) {
2474         m_float = llvm::APFloat(f_val);
2475         m_type = e_float;
2476       } else
2477         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2478                                        value_str);
2479     } else if (byte_size == sizeof(double)) {
2480       if (::sscanf(value_str, "%lf", &d_val) == 1) {
2481         m_float = llvm::APFloat(d_val);
2482         m_type = e_double;
2483       } else
2484         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2485                                        value_str);
2486     } else if (byte_size == sizeof(long double)) {
2487       if (::sscanf(value_str, "%Lf", &l_val) == 1) {
2488         m_float = llvm::APFloat(
2489             llvm::APFloat::x87DoubleExtended(),
2490             llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
2491                         (reinterpret_cast<type128 *>(&l_val))->x));
2492         m_type = e_long_double;
2493       } else
2494         error.SetErrorStringWithFormat("'%s' is not a valid float string value",
2495                                        value_str);
2496     } else {
2497       error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
2498                                      static_cast<uint64_t>(byte_size));
2499       return error;
2500     }
2501     break;
2502 
2503   case eEncodingVector:
2504     error.SetErrorString("vector encoding unsupported.");
2505     break;
2506   }
2507   if (error.Fail())
2508     m_type = e_void;
2509 
2510   return error;
2511 }
2512 
2513 Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
2514                                 size_t byte_size) {
2515   Status error;
2516 
2517   type128 int128;
2518   type256 int256;
2519   switch (encoding) {
2520   case lldb::eEncodingInvalid:
2521     error.SetErrorString("invalid encoding");
2522     break;
2523   case lldb::eEncodingVector:
2524     error.SetErrorString("vector encoding unsupported");
2525     break;
2526   case lldb::eEncodingUint: {
2527     lldb::offset_t offset = 0;
2528 
2529     switch (byte_size) {
2530     case 1:
2531       operator=(data.GetU8(&offset));
2532       break;
2533     case 2:
2534       operator=(data.GetU16(&offset));
2535       break;
2536     case 4:
2537       operator=(data.GetU32(&offset));
2538       break;
2539     case 8:
2540       operator=(data.GetU64(&offset));
2541       break;
2542     case 16:
2543       if (data.GetByteOrder() == eByteOrderBig) {
2544         int128.x[1] = data.GetU64(&offset);
2545         int128.x[0] = data.GetU64(&offset);
2546       } else {
2547         int128.x[0] = data.GetU64(&offset);
2548         int128.x[1] = data.GetU64(&offset);
2549       }
2550       operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2551       break;
2552     case 32:
2553       if (data.GetByteOrder() == eByteOrderBig) {
2554         int256.x[3] = data.GetU64(&offset);
2555         int256.x[2] = data.GetU64(&offset);
2556         int256.x[1] = data.GetU64(&offset);
2557         int256.x[0] = data.GetU64(&offset);
2558       } else {
2559         int256.x[0] = data.GetU64(&offset);
2560         int256.x[1] = data.GetU64(&offset);
2561         int256.x[2] = data.GetU64(&offset);
2562         int256.x[3] = data.GetU64(&offset);
2563       }
2564       operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2565       break;
2566     default:
2567       error.SetErrorStringWithFormat(
2568           "unsupported unsigned integer byte size: %" PRIu64 "",
2569           static_cast<uint64_t>(byte_size));
2570       break;
2571     }
2572   } break;
2573   case lldb::eEncodingSint: {
2574     lldb::offset_t offset = 0;
2575 
2576     switch (byte_size) {
2577     case 1:
2578       operator=(static_cast<int8_t>(data.GetU8(&offset)));
2579       break;
2580     case 2:
2581       operator=(static_cast<int16_t>(data.GetU16(&offset)));
2582       break;
2583     case 4:
2584       operator=(static_cast<int32_t>(data.GetU32(&offset)));
2585       break;
2586     case 8:
2587       operator=(static_cast<int64_t>(data.GetU64(&offset)));
2588       break;
2589     case 16:
2590       if (data.GetByteOrder() == eByteOrderBig) {
2591         int128.x[1] = data.GetU64(&offset);
2592         int128.x[0] = data.GetU64(&offset);
2593       } else {
2594         int128.x[0] = data.GetU64(&offset);
2595         int128.x[1] = data.GetU64(&offset);
2596       }
2597       operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
2598       break;
2599     case 32:
2600       if (data.GetByteOrder() == eByteOrderBig) {
2601         int256.x[3] = data.GetU64(&offset);
2602         int256.x[2] = data.GetU64(&offset);
2603         int256.x[1] = data.GetU64(&offset);
2604         int256.x[0] = data.GetU64(&offset);
2605       } else {
2606         int256.x[0] = data.GetU64(&offset);
2607         int256.x[1] = data.GetU64(&offset);
2608         int256.x[2] = data.GetU64(&offset);
2609         int256.x[3] = data.GetU64(&offset);
2610       }
2611       operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
2612       break;
2613     default:
2614       error.SetErrorStringWithFormat(
2615           "unsupported signed integer byte size: %" PRIu64 "",
2616           static_cast<uint64_t>(byte_size));
2617       break;
2618     }
2619   } break;
2620   case lldb::eEncodingIEEE754: {
2621     lldb::offset_t offset = 0;
2622 
2623     if (byte_size == sizeof(float))
2624       operator=(data.GetFloat(&offset));
2625     else if (byte_size == sizeof(double))
2626       operator=(data.GetDouble(&offset));
2627     else if (byte_size == sizeof(long double))
2628       operator=(data.GetLongDouble(&offset));
2629     else
2630       error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
2631                                      static_cast<uint64_t>(byte_size));
2632   } break;
2633   }
2634 
2635   return error;
2636 }
2637 
2638 bool Scalar::SignExtend(uint32_t sign_bit_pos) {
2639   const uint32_t max_bit_pos = GetByteSize() * 8;
2640 
2641   if (sign_bit_pos < max_bit_pos) {
2642     switch (m_type) {
2643     case Scalar::e_void:
2644     case Scalar::e_float:
2645     case Scalar::e_double:
2646     case Scalar::e_long_double:
2647       return false;
2648 
2649     case Scalar::e_sint:
2650     case Scalar::e_uint:
2651     case Scalar::e_slong:
2652     case Scalar::e_ulong:
2653     case Scalar::e_slonglong:
2654     case Scalar::e_ulonglong:
2655     case Scalar::e_sint128:
2656     case Scalar::e_uint128:
2657     case Scalar::e_sint256:
2658     case Scalar::e_uint256:
2659     case Scalar::e_sint512:
2660     case Scalar::e_uint512:
2661       if (max_bit_pos == sign_bit_pos)
2662         return true;
2663       else if (sign_bit_pos < (max_bit_pos - 1)) {
2664         llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
2665         llvm::APInt bitwize_and = m_integer & sign_bit;
2666         if (bitwize_and.getBoolValue()) {
2667           const llvm::APInt mask =
2668               ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
2669           m_integer |= mask;
2670         }
2671         return true;
2672       }
2673       break;
2674     }
2675   }
2676   return false;
2677 }
2678 
2679 size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
2680                                lldb::ByteOrder dst_byte_order,
2681                                Status &error) const {
2682   // Get a data extractor that points to the native scalar data
2683   DataExtractor data;
2684   if (!GetData(data)) {
2685     error.SetErrorString("invalid scalar value");
2686     return 0;
2687   }
2688 
2689   const size_t src_len = data.GetByteSize();
2690 
2691   // Prepare a memory buffer that contains some or all of the register value
2692   const size_t bytes_copied =
2693       data.CopyByteOrderedData(0,               // src offset
2694                                src_len,         // src length
2695                                dst,             // dst buffer
2696                                dst_len,         // dst length
2697                                dst_byte_order); // dst byte order
2698   if (bytes_copied == 0)
2699     error.SetErrorString("failed to copy data");
2700 
2701   return bytes_copied;
2702 }
2703 
2704 bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
2705   if (bit_size == 0)
2706     return true;
2707 
2708   switch (m_type) {
2709   case Scalar::e_void:
2710   case Scalar::e_float:
2711   case Scalar::e_double:
2712   case Scalar::e_long_double:
2713     break;
2714 
2715   case Scalar::e_sint:
2716   case Scalar::e_slong:
2717   case Scalar::e_slonglong:
2718   case Scalar::e_sint128:
2719   case Scalar::e_sint256:
2720   case Scalar::e_sint512:
2721     m_integer = m_integer.ashr(bit_offset)
2722                     .sextOrTrunc(bit_size)
2723                     .sextOrSelf(8 * GetByteSize());
2724     return true;
2725 
2726   case Scalar::e_uint:
2727   case Scalar::e_ulong:
2728   case Scalar::e_ulonglong:
2729   case Scalar::e_uint128:
2730   case Scalar::e_uint256:
2731   case Scalar::e_uint512:
2732     m_integer = m_integer.lshr(bit_offset)
2733                     .zextOrTrunc(bit_size)
2734                     .zextOrSelf(8 * GetByteSize());
2735     return true;
2736   }
2737   return false;
2738 }
2739 
2740 bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
2741   // If either entry is void then we can just compare the types
2742   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2743     return lhs.m_type == rhs.m_type;
2744 
2745   Scalar temp_value;
2746   const Scalar *a;
2747   const Scalar *b;
2748   llvm::APFloat::cmpResult result;
2749   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2750   case Scalar::e_void:
2751     break;
2752   case Scalar::e_sint:
2753   case Scalar::e_uint:
2754   case Scalar::e_slong:
2755   case Scalar::e_ulong:
2756   case Scalar::e_slonglong:
2757   case Scalar::e_ulonglong:
2758   case Scalar::e_sint128:
2759   case Scalar::e_uint128:
2760   case Scalar::e_sint256:
2761   case Scalar::e_uint256:
2762   case Scalar::e_sint512:
2763   case Scalar::e_uint512:
2764     return a->m_integer == b->m_integer;
2765   case Scalar::e_float:
2766   case Scalar::e_double:
2767   case Scalar::e_long_double:
2768     result = a->m_float.compare(b->m_float);
2769     if (result == llvm::APFloat::cmpEqual)
2770       return true;
2771   }
2772   return false;
2773 }
2774 
2775 bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
2776   return !(lhs == rhs);
2777 }
2778 
2779 bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
2780   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2781     return false;
2782 
2783   Scalar temp_value;
2784   const Scalar *a;
2785   const Scalar *b;
2786   llvm::APFloat::cmpResult result;
2787   switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
2788   case Scalar::e_void:
2789     break;
2790   case Scalar::e_sint:
2791   case Scalar::e_slong:
2792   case Scalar::e_slonglong:
2793   case Scalar::e_sint128:
2794   case Scalar::e_sint256:
2795   case Scalar::e_sint512:
2796   case Scalar::e_uint512:
2797     return a->m_integer.slt(b->m_integer);
2798   case Scalar::e_uint:
2799   case Scalar::e_ulong:
2800   case Scalar::e_ulonglong:
2801   case Scalar::e_uint128:
2802   case Scalar::e_uint256:
2803     return a->m_integer.ult(b->m_integer);
2804   case Scalar::e_float:
2805   case Scalar::e_double:
2806   case Scalar::e_long_double:
2807     result = a->m_float.compare(b->m_float);
2808     if (result == llvm::APFloat::cmpLessThan)
2809       return true;
2810   }
2811   return false;
2812 }
2813 
2814 bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
2815   return !(rhs < lhs);
2816 }
2817 
2818 bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
2819   return rhs < lhs;
2820 }
2821 
2822 bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
2823   return !(lhs < rhs);
2824 }
2825 
2826 bool Scalar::ClearBit(uint32_t bit) {
2827   switch (m_type) {
2828   case e_void:
2829     break;
2830   case e_sint:
2831   case e_uint:
2832   case e_slong:
2833   case e_ulong:
2834   case e_slonglong:
2835   case e_ulonglong:
2836   case e_sint128:
2837   case e_uint128:
2838   case e_sint256:
2839   case e_uint256:
2840   case e_sint512:
2841   case e_uint512:
2842     m_integer.clearBit(bit);
2843     return true;
2844   case e_float:
2845   case e_double:
2846   case e_long_double:
2847     break;
2848   }
2849   return false;
2850 }
2851 
2852 bool Scalar::SetBit(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:
2866   case e_sint512:
2867   case e_uint512:
2868     m_integer.setBit(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 
2878 llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os, const Scalar &scalar) {
2879   StreamString s;
2880   scalar.GetValue(&s, /*show_type*/ true);
2881   return os << s.GetString();
2882 }
2883