1 //===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Scalar.h"
15 #include "lldb/Interpreter/Args.h"
16 #include "lldb/Core/Error.h"
17 #include "lldb/Core/Stream.h"
18 #include "lldb/Core/DataExtractor.h"
19 #include "lldb/Host/Endian.h"
21 #include "Plugins/Process/Utility/InstructionUtils.h"
24 using namespace lldb_private;
26 //----------------------------------------------------------------------
27 // Promote to max type currently follows the ANSI C rule for type
28 // promotion in expressions.
29 //----------------------------------------------------------------------
33 const Scalar& lhs, // The const left hand side object
34 const Scalar& rhs, // The const right hand side object
35 Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
36 const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
37 const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
41 // Initialize the promoted values for both the right and left hand side values
42 // to be the objects themselves. If no promotion is needed (both right and left
43 // 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();
50 if (lhs_type > rhs_type)
52 // Right hand side need to be promoted
53 temp_value = rhs; // Copy right hand side into the temp value
54 if (temp_value.Promote(lhs_type)) // Promote it
55 promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
57 else if (lhs_type < rhs_type)
59 // Left hand side need to be promoted
60 temp_value = lhs; // Copy left hand side value into the temp value
61 if (temp_value.Promote(rhs_type)) // Promote it
62 promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
65 // Make sure our type promotion worked as exptected
66 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
67 return promoted_lhs_ptr->GetType(); // Return the resulting max type
69 // Return the void type (zero) if we fail to promote either of the values.
70 return Scalar::e_void;
74 //----------------------------------------------------------------------
76 //----------------------------------------------------------------------
83 //----------------------------------------------------------------------
84 // Scalar copy constructor
85 //----------------------------------------------------------------------
86 Scalar::Scalar(const Scalar& rhs) :
88 m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union??
92 //Scalar::Scalar(const RegisterValue& reg) :
96 // switch (reg.info.encoding)
98 // case eEncodingUint: // unsigned integer
99 // switch (reg.info.byte_size)
101 // case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
102 // case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
103 // case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
104 // case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
109 // case eEncodingSint: // signed integer
110 // switch (reg.info.byte_size)
112 // case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
113 // case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
114 // case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
115 // case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
120 // case eEncodingIEEE754: // float
121 // switch (reg.info.byte_size)
123 // case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
124 // case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
128 // case eEncodingVector: // vector registers
134 Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
136 size_t byte_size = GetByteSize();
139 if (limit_byte_size < byte_size)
141 if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
143 // On little endian systems if we want fewer bytes from the
144 // current type we just specify fewer bytes since the LSByte
146 data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
148 else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
150 // On big endian systems if we want fewer bytes from the
151 // current type have to advance our initial byte pointer and
152 // trim down the number of bytes since the MSByte is first
153 data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
158 // We want all of the data
159 data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
168 Scalar::GetByteSize() const
174 case e_sint: return sizeof(m_data.sint);
175 case e_uint: return sizeof(m_data.uint);
176 case e_slong: return sizeof(m_data.slong);
177 case e_ulong: return sizeof(m_data.ulong);
178 case e_slonglong: return sizeof(m_data.slonglong);
179 case e_ulonglong: return sizeof(m_data.ulonglong);
180 case e_float: return sizeof(m_data.flt);
181 case e_double: return sizeof(m_data.dbl);
182 case e_long_double: return sizeof(m_data.ldbl);
188 Scalar::IsZero() const
194 case e_sint: return m_data.sint == 0;
195 case e_uint: return m_data.uint == 0;
196 case e_slong: return m_data.slong == 0;
197 case e_ulong: return m_data.ulong == 0;
198 case e_slonglong: return m_data.slonglong == 0;
199 case e_ulonglong: return m_data.ulonglong == 0;
200 case e_float: return m_data.flt == 0.0f;
201 case e_double: return m_data.dbl == 0.0;
202 case e_long_double: return m_data.ldbl == 0.0;
208 Scalar::GetValue (Stream *s, bool show_type) const
211 s->Printf("(%s) ", GetTypeAsCString());
217 case e_sint: s->Printf("%i", m_data.sint); break;
218 case e_uint: s->Printf("0x%8.8x", m_data.uint); break;
219 case e_slong: s->Printf("%li", m_data.slong); break;
220 case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break;
221 case e_slonglong: s->Printf("%lli", m_data.slonglong); break;
222 case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break;
223 case e_float: s->Printf("%f", m_data.flt); break;
224 case e_double: s->Printf("%g", m_data.dbl); break;
225 case e_long_double: s->Printf("%Lg", m_data.ldbl); break;
230 Scalar::GetTypeAsCString() const
234 case e_void: return "void";
235 case e_sint: return "int";
236 case e_uint: return "unsigned int";
237 case e_slong: return "long";
238 case e_ulong: return "unsigned long";
239 case e_slonglong: return "long long";
240 case e_ulonglong: return "unsigned long long";
241 case e_float: return "float";
242 case e_double: return "double";
243 case e_long_double: return "long double";
245 return "<invalid Scalar type>";
250 //----------------------------------------------------------------------
251 // Scalar copy constructor
252 //----------------------------------------------------------------------
254 Scalar::operator=(const Scalar& rhs)
259 ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
265 Scalar::operator= (const int v)
274 Scalar::operator= (unsigned int v)
282 Scalar::operator= (long v)
290 Scalar::operator= (unsigned long v)
298 Scalar::operator= (long long v)
300 m_type = e_slonglong;
301 m_data.slonglong = v;
306 Scalar::operator= (unsigned long long v)
308 m_type = e_ulonglong;
309 m_data.ulonglong = v;
314 Scalar::operator= (float v)
322 Scalar::operator= (double v)
330 Scalar::operator= (long double v)
332 m_type = e_long_double;
337 //----------------------------------------------------------------------
339 //----------------------------------------------------------------------
345 Scalar::Promote(Scalar::Type type)
347 bool success = false;
357 case e_sint: success = true; break;
358 case e_uint: m_data.uint = m_data.sint; success = true; break;
359 case e_slong: m_data.slong = m_data.sint; success = true; break;
360 case e_ulong: m_data.ulong = m_data.sint; success = true; break;
361 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
362 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
363 case e_float: m_data.flt = m_data.sint; success = true; break;
364 case e_double: m_data.dbl = m_data.sint; success = true; break;
365 case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
374 case e_uint: success = true; break;
375 case e_slong: m_data.slong = m_data.uint; success = true; break;
376 case e_ulong: m_data.ulong = m_data.uint; success = true; break;
377 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
378 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
379 case e_float: m_data.flt = m_data.uint; success = true; break;
380 case e_double: m_data.dbl = m_data.uint; success = true; break;
381 case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
391 case e_slong: success = true; break;
392 case e_ulong: m_data.ulong = m_data.slong; success = true; break;
393 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
394 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
395 case e_float: m_data.flt = m_data.slong; success = true; break;
396 case e_double: m_data.dbl = m_data.slong; success = true; break;
397 case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
408 case e_ulong: success = true; break;
409 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
410 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
411 case e_float: m_data.flt = m_data.ulong; success = true; break;
412 case e_double: m_data.dbl = m_data.ulong; success = true; break;
413 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
425 case e_slonglong: success = true; break;
426 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
427 case e_float: m_data.flt = m_data.slonglong; success = true; break;
428 case e_double: m_data.dbl = m_data.slonglong; success = true; break;
429 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
441 case e_slonglong: break;
442 case e_ulonglong: success = true; break;
443 case e_float: m_data.flt = m_data.ulonglong; success = true; break;
444 case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
445 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
458 case e_ulonglong: break;
459 case e_float: success = true; break;
460 case e_double: m_data.dbl = m_data.flt; success = true; break;
461 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
476 case e_double: success = true; break;
477 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
492 case e_double: break;
493 case e_long_double: success = true; break;
504 Scalar::GetValueTypeAsCString (Scalar::Type type)
508 case e_void: return "void";
509 case e_sint: return "int";
510 case e_uint: return "unsigned int";
511 case e_slong: return "long";
512 case e_ulong: return "unsigned long";
513 case e_slonglong: return "long long";
514 case e_ulonglong: return "unsigned long long";
515 case e_float: return "float";
516 case e_double: return "double";
517 case e_long_double: return "long double";
524 Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
526 if (byte_size <= sizeof(sint_t))
528 if (byte_size <= sizeof(slong_t))
530 if (byte_size <= sizeof(slonglong_t))
536 Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
538 if (byte_size <= sizeof(uint_t))
540 if (byte_size <= sizeof(ulong_t))
542 if (byte_size <= sizeof(ulonglong_t))
548 Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
550 if (byte_size == sizeof(float_t))
552 if (byte_size == sizeof(double_t))
554 if (byte_size == sizeof(long_double_t))
555 return e_long_double;
560 Scalar::Cast(Scalar::Type type)
562 bool success = false;
572 case e_sint: success = true; break;
573 case e_uint: m_data.uint = m_data.sint; success = true; break;
574 case e_slong: m_data.slong = m_data.sint; success = true; break;
575 case e_ulong: m_data.ulong = m_data.sint; success = true; break;
576 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
577 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
578 case e_float: m_data.flt = m_data.sint; success = true; break;
579 case e_double: m_data.dbl = m_data.sint; success = true; break;
580 case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
588 case e_sint: m_data.sint = m_data.uint; success = true; break;
589 case e_uint: success = true; break;
590 case e_slong: m_data.slong = m_data.uint; success = true; break;
591 case e_ulong: m_data.ulong = m_data.uint; success = true; break;
592 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
593 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
594 case e_float: m_data.flt = m_data.uint; success = true; break;
595 case e_double: m_data.dbl = m_data.uint; success = true; break;
596 case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
604 case e_sint: m_data.sint = (sint_t)m_data.slong; success = true; break;
605 case e_uint: m_data.uint = (uint_t)m_data.slong; success = true; break;
606 case e_slong: success = true; break;
607 case e_ulong: m_data.ulong = m_data.slong; success = true; break;
608 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
609 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
610 case e_float: m_data.flt = m_data.slong; success = true; break;
611 case e_double: m_data.dbl = m_data.slong; success = true; break;
612 case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
620 case e_sint: m_data.sint = (sint_t)m_data.ulong; success = true; break;
621 case e_uint: m_data.uint = (uint_t)m_data.ulong; success = true; break;
622 case e_slong: m_data.slong = m_data.ulong; success = true; break;
623 case e_ulong: success = true; break;
624 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
625 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
626 case e_float: m_data.flt = m_data.ulong; success = true; break;
627 case e_double: m_data.dbl = m_data.ulong; success = true; break;
628 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
636 case e_sint: m_data.sint = (sint_t)m_data.slonglong; success = true; break;
637 case e_uint: m_data.uint = (uint_t)m_data.slonglong; success = true; break;
638 case e_slong: m_data.slong = m_data.slonglong; success = true; break;
639 case e_ulong: m_data.ulong = m_data.slonglong; success = true; break;
640 case e_slonglong: success = true; break;
641 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
642 case e_float: m_data.flt = m_data.slonglong; success = true; break;
643 case e_double: m_data.dbl = m_data.slonglong; success = true; break;
644 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
652 case e_sint: m_data.sint = (sint_t)m_data.ulonglong; success = true; break;
653 case e_uint: m_data.uint = (uint_t)m_data.ulonglong; success = true; break;
654 case e_slong: m_data.slong = m_data.ulonglong; success = true; break;
655 case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break;
656 case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break;
657 case e_ulonglong: success = true; break;
658 case e_float: m_data.flt = m_data.ulonglong; success = true; break;
659 case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
660 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
668 case e_sint: m_data.sint = (sint_t)m_data.flt; success = true; break;
669 case e_uint: m_data.uint = (uint_t)m_data.flt; success = true; break;
670 case e_slong: m_data.slong = (slong_t)m_data.flt; success = true; break;
671 case e_ulong: m_data.ulong = (ulong_t)m_data.flt; success = true; break;
672 case e_slonglong: m_data.slonglong = (slonglong_t)m_data.flt; success = true; break;
673 case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.flt; success = true; break;
674 case e_float: success = true; break;
675 case e_double: m_data.dbl = m_data.flt; success = true; break;
676 case e_long_double: m_data.ldbl = m_data.flt; success = true; break;
684 case e_sint: m_data.sint = (sint_t)m_data.dbl; success = true; break;
685 case e_uint: m_data.uint = (uint_t)m_data.dbl; success = true; break;
686 case e_slong: m_data.slong = (slong_t)m_data.dbl; success = true; break;
687 case e_ulong: m_data.ulong = (ulong_t)m_data.dbl; success = true; break;
688 case e_slonglong: m_data.slonglong = (slonglong_t)m_data.dbl; success = true; break;
689 case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.dbl; success = true; break;
690 case e_float: m_data.flt = (float_t)m_data.dbl; success = true; break;
691 case e_double: success = true; break;
692 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
700 case e_sint: m_data.sint = (sint_t)m_data.ldbl; success = true; break;
701 case e_uint: m_data.uint = (uint_t)m_data.ldbl; success = true; break;
702 case e_slong: m_data.slong = (slong_t)m_data.ldbl; success = true; break;
703 case e_ulong: m_data.ulong = (ulong_t)m_data.ldbl; success = true; break;
704 case e_slonglong: m_data.slonglong = (slonglong_t)m_data.ldbl; success = true; break;
705 case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.ldbl; success = true; break;
706 case e_float: m_data.flt = (float_t)m_data.ldbl; success = true; break;
707 case e_double: m_data.dbl = (double_t)m_data.ldbl; success = true; break;
708 case e_long_double: success = true; break;
719 Scalar::MakeSigned ()
721 bool success = false;
726 case e_sint: success = true; break;
727 case e_uint: m_type = e_sint; success = true; break;
728 case e_slong: success = true; break;
729 case e_ulong: m_type = e_slong; success = true; break;
730 case e_slonglong: success = true; break;
731 case e_ulonglong: m_type = e_slonglong; success = true; break;
732 case e_float: success = true; break;
733 case e_double: success = true; break;
734 case e_long_double: success = true; break;
741 Scalar::SInt(int fail_value) const
746 case e_sint: return m_data.sint;
747 case e_uint: return (int)m_data.uint;
748 case e_slong: return (int)m_data.slong;
749 case e_ulong: return (int)m_data.ulong;
750 case e_slonglong: return (int)m_data.slonglong;
751 case e_ulonglong: return (int)m_data.ulonglong;
752 case e_float: return (int)m_data.flt;
753 case e_double: return (int)m_data.dbl;
754 case e_long_double: return (int)m_data.ldbl;
760 Scalar::UInt(unsigned int fail_value) const
765 case e_sint: return (unsigned int)m_data.sint;
766 case e_uint: return (unsigned int)m_data.uint;
767 case e_slong: return (unsigned int)m_data.slong;
768 case e_ulong: return (unsigned int)m_data.ulong;
769 case e_slonglong: return (unsigned int)m_data.slonglong;
770 case e_ulonglong: return (unsigned int)m_data.ulonglong;
771 case e_float: return (unsigned int)m_data.flt;
772 case e_double: return (unsigned int)m_data.dbl;
773 case e_long_double: return (unsigned int)m_data.ldbl;
780 Scalar::SLong(long fail_value) const
785 case e_sint: return (long)m_data.sint;
786 case e_uint: return (long)m_data.uint;
787 case e_slong: return (long)m_data.slong;
788 case e_ulong: return (long)m_data.ulong;
789 case e_slonglong: return (long)m_data.slonglong;
790 case e_ulonglong: return (long)m_data.ulonglong;
791 case e_float: return (long)m_data.flt;
792 case e_double: return (long)m_data.dbl;
793 case e_long_double: return (long)m_data.ldbl;
801 Scalar::ULong(unsigned long fail_value) const
806 case e_sint: return (unsigned long)m_data.sint;
807 case e_uint: return (unsigned long)m_data.uint;
808 case e_slong: return (unsigned long)m_data.slong;
809 case e_ulong: return (unsigned long)m_data.ulong;
810 case e_slonglong: return (unsigned long)m_data.slonglong;
811 case e_ulonglong: return (unsigned long)m_data.ulonglong;
812 case e_float: return (unsigned long)m_data.flt;
813 case e_double: return (unsigned long)m_data.dbl;
814 case e_long_double: return (unsigned long)m_data.ldbl;
820 Scalar::GetRawBits64(uint64_t fail_value) const
837 return m_data.ulonglong;
840 if (sizeof(m_data.flt) == sizeof(m_data.uint))
842 else if (sizeof(m_data.flt) == sizeof(m_data.ulong))
844 else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong))
845 return m_data.ulonglong;
849 if (sizeof(m_data.dbl) == sizeof(m_data.uint))
851 else if (sizeof(m_data.dbl) == sizeof(m_data.ulong))
853 else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong))
854 return m_data.ulonglong;
858 if (sizeof(m_data.ldbl) == sizeof(m_data.uint))
860 else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong))
862 else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong))
863 return m_data.ulonglong;
872 Scalar::SLongLong(long long fail_value) const
877 case e_sint: return (long long)m_data.sint;
878 case e_uint: return (long long)m_data.uint;
879 case e_slong: return (long long)m_data.slong;
880 case e_ulong: return (long long)m_data.ulong;
881 case e_slonglong: return (long long)m_data.slonglong;
882 case e_ulonglong: return (long long)m_data.ulonglong;
883 case e_float: return (long long)m_data.flt;
884 case e_double: return (long long)m_data.dbl;
885 case e_long_double: return (long long)m_data.ldbl;
892 Scalar::ULongLong(unsigned long long fail_value) const
897 case e_sint: return (unsigned long long)m_data.sint;
898 case e_uint: return (unsigned long long)m_data.uint;
899 case e_slong: return (unsigned long long)m_data.slong;
900 case e_ulong: return (unsigned long long)m_data.ulong;
901 case e_slonglong: return (unsigned long long)m_data.slonglong;
902 case e_ulonglong: return (unsigned long long)m_data.ulonglong;
903 case e_float: return (unsigned long long)m_data.flt;
904 case e_double: return (unsigned long long)m_data.dbl;
905 case e_long_double: return (unsigned long long)m_data.ldbl;
912 Scalar::Float(float fail_value) const
917 case e_sint: return (float)m_data.sint;
918 case e_uint: return (float)m_data.uint;
919 case e_slong: return (float)m_data.slong;
920 case e_ulong: return (float)m_data.ulong;
921 case e_slonglong: return (float)m_data.slonglong;
922 case e_ulonglong: return (float)m_data.ulonglong;
923 case e_float: return (float)m_data.flt;
924 case e_double: return (float)m_data.dbl;
925 case e_long_double: return (float)m_data.ldbl;
932 Scalar::Double(double fail_value) const
937 case e_sint: return (double)m_data.sint;
938 case e_uint: return (double)m_data.uint;
939 case e_slong: return (double)m_data.slong;
940 case e_ulong: return (double)m_data.ulong;
941 case e_slonglong: return (double)m_data.slonglong;
942 case e_ulonglong: return (double)m_data.ulonglong;
943 case e_float: return (double)m_data.flt;
944 case e_double: return (double)m_data.dbl;
945 case e_long_double: return (double)m_data.ldbl;
952 Scalar::LongDouble(long double fail_value) const
957 case e_sint: return (long double)m_data.sint;
958 case e_uint: return (long double)m_data.uint;
959 case e_slong: return (long double)m_data.slong;
960 case e_ulong: return (long double)m_data.ulong;
961 case e_slonglong: return (long double)m_data.slonglong;
962 case e_ulonglong: return (long double)m_data.ulonglong;
963 case e_float: return (long double)m_data.flt;
964 case e_double: return (long double)m_data.dbl;
965 case e_long_double: return (long double)m_data.ldbl;
972 Scalar::operator+= (const Scalar& rhs)
977 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
982 case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break;
983 case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break;
984 case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break;
985 case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
986 case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
987 case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
988 case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break;
989 case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
990 case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
997 Scalar::operator<<= (const Scalar& rhs)
1017 case e_sint: m_data.sint <<= rhs.m_data.sint; break;
1018 case e_uint: m_data.sint <<= rhs.m_data.uint; break;
1019 case e_slong: m_data.sint <<= rhs.m_data.slong; break;
1020 case e_ulong: m_data.sint <<= rhs.m_data.ulong; break;
1021 case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break;
1022 case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break;
1035 case e_sint: m_data.uint <<= rhs.m_data.sint; break;
1036 case e_uint: m_data.uint <<= rhs.m_data.uint; break;
1037 case e_slong: m_data.uint <<= rhs.m_data.slong; break;
1038 case e_ulong: m_data.uint <<= rhs.m_data.ulong; break;
1039 case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break;
1040 case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break;
1053 case e_sint: m_data.slong <<= rhs.m_data.sint; break;
1054 case e_uint: m_data.slong <<= rhs.m_data.uint; break;
1055 case e_slong: m_data.slong <<= rhs.m_data.slong; break;
1056 case e_ulong: m_data.slong <<= rhs.m_data.ulong; break;
1057 case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break;
1058 case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break;
1071 case e_sint: m_data.ulong <<= rhs.m_data.sint; break;
1072 case e_uint: m_data.ulong <<= rhs.m_data.uint; break;
1073 case e_slong: m_data.ulong <<= rhs.m_data.slong; break;
1074 case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break;
1075 case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break;
1076 case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break;
1088 case e_sint: m_data.slonglong <<= rhs.m_data.sint; break;
1089 case e_uint: m_data.slonglong <<= rhs.m_data.uint; break;
1090 case e_slong: m_data.slonglong <<= rhs.m_data.slong; break;
1091 case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break;
1092 case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break;
1093 case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break;
1106 case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break;
1107 case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break;
1108 case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break;
1109 case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break;
1110 case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break;
1111 case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break;
1119 Scalar::ShiftRightLogical(const Scalar& rhs)
1140 case e_sint: m_data.uint >>= rhs.m_data.sint; break;
1141 case e_uint: m_data.uint >>= rhs.m_data.uint; break;
1142 case e_slong: m_data.uint >>= rhs.m_data.slong; break;
1143 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
1144 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
1145 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
1159 case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
1160 case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
1161 case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
1162 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
1163 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
1164 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
1178 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
1179 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
1180 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
1181 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
1182 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
1183 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
1187 return m_type != e_void;
1192 Scalar::operator>>= (const Scalar& rhs)
1212 case e_sint: m_data.sint >>= rhs.m_data.sint; break;
1213 case e_uint: m_data.sint >>= rhs.m_data.uint; break;
1214 case e_slong: m_data.sint >>= rhs.m_data.slong; break;
1215 case e_ulong: m_data.sint >>= rhs.m_data.ulong; break;
1216 case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break;
1217 case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break;
1230 case e_sint: m_data.uint >>= rhs.m_data.sint; break;
1231 case e_uint: m_data.uint >>= rhs.m_data.uint; break;
1232 case e_slong: m_data.uint >>= rhs.m_data.slong; break;
1233 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
1234 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
1235 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
1248 case e_sint: m_data.slong >>= rhs.m_data.sint; break;
1249 case e_uint: m_data.slong >>= rhs.m_data.uint; break;
1250 case e_slong: m_data.slong >>= rhs.m_data.slong; break;
1251 case e_ulong: m_data.slong >>= rhs.m_data.ulong; break;
1252 case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break;
1253 case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break;
1266 case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
1267 case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
1268 case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
1269 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
1270 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
1271 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
1283 case e_sint: m_data.slonglong >>= rhs.m_data.sint; break;
1284 case e_uint: m_data.slonglong >>= rhs.m_data.uint; break;
1285 case e_slong: m_data.slonglong >>= rhs.m_data.slong; break;
1286 case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break;
1287 case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break;
1288 case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break;
1301 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
1302 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
1303 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
1304 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
1305 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
1306 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
1315 Scalar::operator&= (const Scalar& rhs)
1335 case e_sint: m_data.sint &= rhs.m_data.sint; break;
1336 case e_uint: m_data.sint &= rhs.m_data.uint; break;
1337 case e_slong: m_data.sint &= rhs.m_data.slong; break;
1338 case e_ulong: m_data.sint &= rhs.m_data.ulong; break;
1339 case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break;
1340 case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break;
1353 case e_sint: m_data.uint &= rhs.m_data.sint; break;
1354 case e_uint: m_data.uint &= rhs.m_data.uint; break;
1355 case e_slong: m_data.uint &= rhs.m_data.slong; break;
1356 case e_ulong: m_data.uint &= rhs.m_data.ulong; break;
1357 case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break;
1358 case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break;
1371 case e_sint: m_data.slong &= rhs.m_data.sint; break;
1372 case e_uint: m_data.slong &= rhs.m_data.uint; break;
1373 case e_slong: m_data.slong &= rhs.m_data.slong; break;
1374 case e_ulong: m_data.slong &= rhs.m_data.ulong; break;
1375 case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break;
1376 case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break;
1389 case e_sint: m_data.ulong &= rhs.m_data.sint; break;
1390 case e_uint: m_data.ulong &= rhs.m_data.uint; break;
1391 case e_slong: m_data.ulong &= rhs.m_data.slong; break;
1392 case e_ulong: m_data.ulong &= rhs.m_data.ulong; break;
1393 case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break;
1394 case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break;
1406 case e_sint: m_data.slonglong &= rhs.m_data.sint; break;
1407 case e_uint: m_data.slonglong &= rhs.m_data.uint; break;
1408 case e_slong: m_data.slonglong &= rhs.m_data.slong; break;
1409 case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break;
1410 case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break;
1411 case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break;
1424 case e_sint: m_data.ulonglong &= rhs.m_data.sint; break;
1425 case e_uint: m_data.ulonglong &= rhs.m_data.uint; break;
1426 case e_slong: m_data.ulonglong &= rhs.m_data.slong; break;
1427 case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break;
1428 case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break;
1429 case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break;
1439 Scalar::AbsoluteValue()
1447 if (m_data.sint < 0)
1448 m_data.sint = -m_data.sint;
1452 if (m_data.slong < 0)
1453 m_data.slong = -m_data.slong;
1457 if (m_data.slonglong < 0)
1458 m_data.slonglong = -m_data.slonglong;
1463 case e_ulonglong: return true;
1464 case e_float: m_data.flt = fabsf(m_data.flt); return true;
1465 case e_double: m_data.dbl = fabs(m_data.dbl); return true;
1466 case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true;
1473 Scalar::UnaryNegate()
1478 case e_sint: m_data.sint = -m_data.sint; return true;
1479 case e_uint: m_data.uint = -m_data.uint; return true;
1480 case e_slong: m_data.slong = -m_data.slong; return true;
1481 case e_ulong: m_data.ulong = -m_data.ulong; return true;
1482 case e_slonglong: m_data.slonglong = -m_data.slonglong; return true;
1483 case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true;
1484 case e_float: m_data.flt = -m_data.flt; return true;
1485 case e_double: m_data.dbl = -m_data.dbl; return true;
1486 case e_long_double: m_data.ldbl = -m_data.ldbl; return true;
1492 Scalar::OnesComplement()
1496 case e_sint: m_data.sint = ~m_data.sint; return true;
1497 case e_uint: m_data.uint = ~m_data.uint; return true;
1498 case e_slong: m_data.slong = ~m_data.slong; return true;
1499 case e_ulong: m_data.ulong = ~m_data.ulong; return true;
1500 case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true;
1501 case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true;
1514 lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
1520 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1522 switch (result.m_type)
1524 case Scalar::e_void: break;
1525 case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break;
1526 case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break;
1527 case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break;
1528 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
1529 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
1530 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
1531 case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break;
1532 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
1533 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
1541 lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
1547 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1549 switch (result.m_type)
1551 case Scalar::e_void: break;
1552 case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break;
1553 case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break;
1554 case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break;
1555 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break;
1556 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break;
1557 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break;
1558 case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break;
1559 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break;
1560 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break;
1567 lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
1573 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1575 switch (result.m_type)
1577 case Scalar::e_void: break;
1579 case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break;
1580 case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break;
1581 case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break;
1582 case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break;
1583 case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break;
1584 case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break;
1585 case Scalar::e_float: if (b->m_data.flt != 0.0f) { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break;
1586 case Scalar::e_double: if (b->m_data.dbl != 0.0) { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break;
1587 case Scalar::e_long_double: if (b->m_data.ldbl != 0.0) { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break;
1590 // For division only, the only way it should make it here is if a promotion failed,
1591 // or if we are trying to do a divide by zero.
1592 result.m_type = Scalar::e_void;
1597 lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
1603 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1605 switch (result.m_type)
1607 case Scalar::e_void: break;
1608 case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break;
1609 case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break;
1610 case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break;
1611 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break;
1612 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break;
1613 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break;
1614 case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break;
1615 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break;
1616 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break;
1623 lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
1629 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1631 switch (result.m_type)
1633 case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break;
1634 case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break;
1635 case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break;
1636 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break;
1637 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break;
1638 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break;
1640 case Scalar::e_void:
1641 case Scalar::e_float:
1642 case Scalar::e_double:
1643 case Scalar::e_long_double:
1644 // No bitwise AND on floats, doubles of long doubles
1645 result.m_type = Scalar::e_void;
1653 lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
1659 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1661 switch (result.m_type)
1663 case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break;
1664 case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break;
1665 case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break;
1666 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break;
1667 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break;
1668 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break;
1670 case Scalar::e_void:
1671 case Scalar::e_float:
1672 case Scalar::e_double:
1673 case Scalar::e_long_double:
1674 // No bitwise AND on floats, doubles of long doubles
1675 result.m_type = Scalar::e_void;
1683 lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
1689 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1691 switch (result.m_type)
1694 case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint % b->m_data.sint; return result; } break;
1695 case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint % b->m_data.uint; return result; } break;
1696 case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong % b->m_data.slong; return result; } break;
1697 case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong % b->m_data.ulong; return result; } break;
1698 case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong % b->m_data.slonglong; return result; } break;
1699 case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong % b->m_data.ulonglong; return result; } break;
1702 result.m_type = Scalar::e_void;
1707 lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
1713 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1715 switch (result.m_type)
1717 case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break;
1718 case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break;
1719 case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break;
1720 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break;
1721 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break;
1722 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break;
1724 case Scalar::e_void:
1725 case Scalar::e_float:
1726 case Scalar::e_double:
1727 case Scalar::e_long_double:
1728 // No bitwise AND on floats, doubles of long doubles
1729 result.m_type = Scalar::e_void;
1737 lldb_private::operator<< (const Scalar& lhs, const Scalar &rhs)
1739 Scalar result = lhs;
1745 lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
1747 Scalar result = lhs;
1752 // Return the raw unsigned integer without any casting or conversion
1754 Scalar::RawUInt () const
1759 // Return the raw unsigned long without any casting or conversion
1761 Scalar::RawULong () const
1763 return m_data.ulong;
1766 // Return the raw unsigned long long without any casting or conversion
1768 Scalar::RawULongLong () const
1770 return m_data.ulonglong;
1775 Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
1778 if (value_str == NULL || value_str[0] == '\0')
1780 error.SetErrorString ("Invalid c-string value string.");
1783 bool success = false;
1786 case eEncodingInvalid:
1787 error.SetErrorString ("Invalid encoding.");
1791 if (byte_size <= sizeof (unsigned long long))
1793 uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
1795 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
1796 else if (!UIntValueIsValidForSize (uval64, byte_size))
1797 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte unsigned integer value", uval64, byte_size);
1800 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
1803 case e_uint: m_data.uint = (uint_t)uval64; break;
1804 case e_ulong: m_data.ulong = (ulong_t)uval64; break;
1805 case e_ulonglong: m_data.ulonglong = (ulonglong_t)uval64; break;
1807 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
1814 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
1820 if (byte_size <= sizeof (long long))
1822 uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
1824 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
1825 else if (!SIntValueIsValidForSize (sval64, byte_size))
1826 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte signed integer value", sval64, byte_size);
1829 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
1832 case e_sint: m_data.sint = (sint_t)sval64; break;
1833 case e_slong: m_data.slong = (slong_t)sval64; break;
1834 case e_slonglong: m_data.slonglong = (slonglong_t)sval64; break;
1836 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
1843 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
1848 case eEncodingIEEE754:
1849 if (byte_size == sizeof (float))
1851 if (::sscanf (value_str, "%f", &m_data.flt) == 1)
1854 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
1856 else if (byte_size == sizeof (double))
1858 if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
1861 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
1863 else if (byte_size == sizeof (long double))
1865 if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
1866 m_type = e_long_double;
1868 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
1872 error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size);
1877 case eEncodingVector:
1878 error.SetErrorString ("vector encoding unsupported.");
1888 Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size)
1894 case lldb::eEncodingInvalid:
1895 error.SetErrorString ("invalid encoding");
1897 case lldb::eEncodingVector:
1898 error.SetErrorString ("vector encoding unsupported");
1900 case lldb::eEncodingUint:
1902 lldb::offset_t offset;
1906 case 1: operator=((uint8_t)data.GetU8(&offset)); break;
1907 case 2: operator=((uint16_t)data.GetU16(&offset)); break;
1908 case 4: operator=((uint32_t)data.GetU32(&offset)); break;
1909 case 8: operator=((uint64_t)data.GetU64(&offset)); break;
1911 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
1916 case lldb::eEncodingSint:
1918 lldb::offset_t offset;
1922 case 1: operator=((int8_t)data.GetU8(&offset)); break;
1923 case 2: operator=((int16_t)data.GetU16(&offset)); break;
1924 case 4: operator=((int32_t)data.GetU32(&offset)); break;
1925 case 8: operator=((int64_t)data.GetU64(&offset)); break;
1927 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
1932 case lldb::eEncodingIEEE754:
1934 lldb::offset_t offset;
1936 if (byte_size == sizeof (float))
1937 operator=((float)data.GetFloat(&offset));
1938 else if (byte_size == sizeof (double))
1939 operator=((double)data.GetDouble(&offset));
1940 else if (byte_size == sizeof (long double))
1941 operator=((long double)data.GetLongDouble(&offset));
1943 error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size);
1952 Scalar::SignExtend (uint32_t sign_bit_pos)
1954 const uint32_t max_bit_pos = GetByteSize() * 8;
1956 if (sign_bit_pos < max_bit_pos)
1960 case Scalar::e_void:
1961 case Scalar::e_float:
1962 case Scalar::e_double:
1963 case Scalar::e_long_double:
1966 case Scalar::e_sint:
1967 case Scalar::e_uint:
1968 if (max_bit_pos == sign_bit_pos)
1970 else if (sign_bit_pos < (max_bit_pos-1))
1972 unsigned int sign_bit = 1u << sign_bit_pos;
1973 if (m_data.uint & sign_bit)
1975 const unsigned int mask = ~(sign_bit) + 1u;
1976 m_data.uint |= mask;
1982 case Scalar::e_slong:
1983 case Scalar::e_ulong:
1984 if (max_bit_pos == sign_bit_pos)
1986 else if (sign_bit_pos < (max_bit_pos-1))
1988 unsigned long sign_bit = 1ul << sign_bit_pos;
1989 if (m_data.ulong & sign_bit)
1991 const unsigned long mask = ~(sign_bit) + 1ul;
1992 m_data.ulong |= mask;
1998 case Scalar::e_slonglong:
1999 case Scalar::e_ulonglong:
2000 if (max_bit_pos == sign_bit_pos)
2002 else if (sign_bit_pos < (max_bit_pos-1))
2004 unsigned long long sign_bit = 1ull << sign_bit_pos;
2005 if (m_data.ulonglong & sign_bit)
2007 const unsigned long long mask = ~(sign_bit) + 1ull;
2008 m_data.ulonglong |= mask;
2019 Scalar::GetAsMemoryData (void *dst,
2021 lldb::ByteOrder dst_byte_order,
2024 // Get a data extractor that points to the native scalar data
2028 error.SetErrorString ("invalid scalar value");
2032 const size_t src_len = data.GetByteSize();
2034 // Prepare a memory buffer that contains some or all of the register value
2035 const size_t bytes_copied = data.CopyByteOrderedData (0, // src offset
2036 src_len, // src length
2038 dst_len, // dst length
2039 dst_byte_order); // dst byte order
2040 if (bytes_copied == 0)
2041 error.SetErrorString ("failed to copy data");
2043 return bytes_copied;
2047 Scalar::ExtractBitfield (uint32_t bit_size,
2048 uint32_t bit_offset)
2053 uint32_t msbit = bit_offset + bit_size - 1;
2054 uint32_t lsbit = bit_offset;
2057 case Scalar::e_void:
2061 if (sizeof(m_data.flt) == sizeof(sint_t))
2062 m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
2063 else if (sizeof(m_data.flt) == sizeof(ulong_t))
2064 m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
2065 else if (sizeof(m_data.flt) == sizeof(ulonglong_t))
2066 m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
2072 if (sizeof(m_data.dbl) == sizeof(sint_t))
2073 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2074 else if (sizeof(m_data.dbl) == sizeof(ulong_t))
2075 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2076 else if (sizeof(m_data.dbl) == sizeof(ulonglong_t))
2077 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2083 if (sizeof(m_data.ldbl) == sizeof(sint_t))
2084 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2085 else if (sizeof(m_data.ldbl) == sizeof(ulong_t))
2086 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2087 else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t))
2088 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2093 case Scalar::e_sint:
2094 m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
2097 case Scalar::e_uint:
2098 m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit);
2101 case Scalar::e_slong:
2102 m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
2105 case Scalar::e_ulong:
2106 m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit);
2109 case Scalar::e_slonglong:
2110 m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
2113 case Scalar::e_ulonglong:
2114 m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit);
2125 lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
2127 // If either entry is void then we can just compare the types
2128 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2129 return lhs.m_type == rhs.m_type;
2134 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2136 case Scalar::e_void: break;
2137 case Scalar::e_sint: return a->m_data.sint == b->m_data.sint;
2138 case Scalar::e_uint: return a->m_data.uint == b->m_data.uint;
2139 case Scalar::e_slong: return a->m_data.slong == b->m_data.slong;
2140 case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong;
2141 case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong;
2142 case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong;
2143 case Scalar::e_float: return a->m_data.flt == b->m_data.flt;
2144 case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl;
2145 case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl;
2151 lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
2153 // If either entry is void then we can just compare the types
2154 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2155 return lhs.m_type != rhs.m_type;
2157 Scalar temp_value; // A temp value that might get a copy of either promoted value
2160 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2162 case Scalar::e_void: break;
2163 case Scalar::e_sint: return a->m_data.sint != b->m_data.sint;
2164 case Scalar::e_uint: return a->m_data.uint != b->m_data.uint;
2165 case Scalar::e_slong: return a->m_data.slong != b->m_data.slong;
2166 case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong;
2167 case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong;
2168 case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong;
2169 case Scalar::e_float: return a->m_data.flt != b->m_data.flt;
2170 case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl;
2171 case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl;
2177 lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
2179 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2185 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2187 case Scalar::e_void: break;
2188 case Scalar::e_sint: return a->m_data.sint < b->m_data.sint;
2189 case Scalar::e_uint: return a->m_data.uint < b->m_data.uint;
2190 case Scalar::e_slong: return a->m_data.slong < b->m_data.slong;
2191 case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong;
2192 case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong;
2193 case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong;
2194 case Scalar::e_float: return a->m_data.flt < b->m_data.flt;
2195 case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl;
2196 case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl;
2202 lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
2204 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2210 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2212 case Scalar::e_void: break;
2213 case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint;
2214 case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint;
2215 case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong;
2216 case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong;
2217 case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong;
2218 case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong;
2219 case Scalar::e_float: return a->m_data.flt <= b->m_data.flt;
2220 case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl;
2221 case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl;
2228 lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
2230 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2236 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2238 case Scalar::e_void: break;
2239 case Scalar::e_sint: return a->m_data.sint > b->m_data.sint;
2240 case Scalar::e_uint: return a->m_data.uint > b->m_data.uint;
2241 case Scalar::e_slong: return a->m_data.slong > b->m_data.slong;
2242 case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong;
2243 case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong;
2244 case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong;
2245 case Scalar::e_float: return a->m_data.flt > b->m_data.flt;
2246 case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl;
2247 case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl;
2253 lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
2255 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2261 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2263 case Scalar::e_void: break;
2264 case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint;
2265 case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint;
2266 case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong;
2267 case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong;
2268 case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong;
2269 case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong;
2270 case Scalar::e_float: return a->m_data.flt >= b->m_data.flt;
2271 case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl;
2272 case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl;