Bug Summary

File:tools/lldb/source/Core/Scalar.cpp
Location:line 276, column 9
Description:Address of stack memory associated with local variable 'ldbl_val' returned to caller

Annotated Source Code

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