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