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