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