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