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