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