Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 5020f958d8fd310cec0b3bea42cae66578247ee6 / . / lldb / source / Core / Scalar.cpp
blob: eaf0bc502b8066b6daead4f36587a75c66e32f18 [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]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
Jim Ingham40af72e2010-06-15 19:49:27 +0000[diff] [blame]14#include "lldb/Interpreter/Args.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]15#include "lldb/Core/Error.h"
16#include "lldb/Core/Stream.h"
17#include "lldb/Core/DataExtractor.h"
Greg Clayton7fb56d02011-02-01 01:31:41 +0000[diff] [blame]18#include "lldb/Host/Endian.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]19
Greg Claytondcad5022011-12-29 01:26:56 +0000[diff] [blame]20#include "Plugins/Process/Utility/InstructionUtils.h"
21
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]22using namespace lldb;
23using namespace lldb_private;
24
25//----------------------------------------------------------------------
26// Promote to max type currently follows the ANSI C rule for type
27// promotion in expressions.
28//----------------------------------------------------------------------
29static Scalar::Type
30PromoteToMaxType
31(
32 const Scalar& lhs, // The const left hand side object
33 const Scalar& rhs, // The const right hand side object
34 Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
35 const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
36 const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
37)
38{
39 Scalar result;
40 // Initialize the promoted values for both the right and left hand side values
41 // to be the objects themselves. If no promotion is needed (both right and left
42 // have the same type), then the temp_value will not get used.
43 promoted_lhs_ptr = &lhs;
44 promoted_rhs_ptr = &rhs;
45 // Extract the types of both the right and left hand side values
46 Scalar::Type lhs_type = lhs.GetType();
47 Scalar::Type rhs_type = rhs.GetType();
48
49 if (lhs_type > rhs_type)
50 {
51 // Right hand side need to be promoted
52 temp_value = rhs; // Copy right hand side into the temp value
53 if (temp_value.Promote(lhs_type)) // Promote it
54 promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
55 }
56 else if (lhs_type < rhs_type)
57 {
58 // Left hand side need to be promoted
59 temp_value = lhs; // Copy left hand side value into the temp value
60 if (temp_value.Promote(rhs_type)) // Promote it
61 promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
62 }
63
64 // Make sure our type promotion worked as exptected
65 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
66 return promoted_lhs_ptr->GetType(); // Return the resulting max type
67
68 // Return the void type (zero) if we fail to promote either of the values.
69 return Scalar::e_void;
70}
71
72
73//----------------------------------------------------------------------
74// Scalar constructor
75//----------------------------------------------------------------------
76Scalar::Scalar() :
77 m_type(e_void),
78 m_data()
79{
80}
81
82//----------------------------------------------------------------------
83// Scalar copy constructor
84//----------------------------------------------------------------------
85Scalar::Scalar(const Scalar& rhs) :
86 m_type(rhs.m_type),
87 m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union??
88{
89}
90
91//Scalar::Scalar(const RegisterValue& reg) :
92// m_type(e_void),
93// m_data()
94//{
95// switch (reg.info.encoding)
96// {
97// case eEncodingUint: // unsigned integer
98// switch (reg.info.byte_size)
99// {
100// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
101// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
102// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
103// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
104// break;
105// }
106// break;
107//
108// case eEncodingSint: // signed integer
109// switch (reg.info.byte_size)
110// {
111// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
112// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
113// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
114// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
115// break;
116// }
117// break;
118//
119// case eEncodingIEEE754: // float
120// switch (reg.info.byte_size)
121// {
122// case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
123// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
124// break;
125// }
126// break;
127// case eEncodingVector: // vector registers
128// break;
129// }
130//}
131
132bool
133Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
134{
135 size_t byte_size = GetByteSize();
136 if (byte_size > 0)
137 {
138 if (limit_byte_size < byte_size)
139 {
Greg Clayton7fb56d02011-02-01 01:31:41 +0000[diff] [blame]140 if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]141 {
142 // On little endian systems if we want fewer bytes from the
143 // current type we just specify fewer bytes since the LSByte
144 // is first...
Greg Clayton7fb56d02011-02-01 01:31:41 +0000[diff] [blame]145 data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]146 }
Greg Clayton7fb56d02011-02-01 01:31:41 +0000[diff] [blame]147 else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]148 {
149 // On big endian systems if we want fewer bytes from the
150 // current type have to advance our initial byte pointer and
151 // trim down the number of bytes since the MSByte is first
Greg Clayton7fb56d02011-02-01 01:31:41 +0000[diff] [blame]152 data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]153 }
154 }
155 else
156 {
157 // We want all of the data
Greg Clayton7fb56d02011-02-01 01:31:41 +0000[diff] [blame]158 data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]159 }
160 return true;
161 }
162 data.Clear();
163 return false;
164}
165
166size_t
167Scalar::GetByteSize() const
168{
169 switch (m_type)
170 {
171 default:
172 case e_void:
173 break;
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);
183 }
184 return 0;
185}
186
187bool
188Scalar::IsZero() const
189{
190 switch (m_type)
191 {
192 default:
193 case e_void:
194 break;
195 case e_sint: return m_data.sint == 0;
196 case e_uint: return m_data.uint == 0;
197 case e_slong: return m_data.slong == 0;
198 case e_ulong: return m_data.ulong == 0;
199 case e_slonglong: return m_data.slonglong == 0;
200 case e_ulonglong: return m_data.ulonglong == 0;
201 case e_float: return m_data.flt == 0.0f;
202 case e_double: return m_data.dbl == 0.0;
203 case e_long_double: return m_data.ldbl == 0.0;
204 }
205 return false;
206}
207
208void
209Scalar::GetValue (Stream *s, bool show_type) const
210{
211 if (show_type)
212 s->Printf("(%s) ", GetTypeAsCString());
213
214 switch (m_type)
215 {
216 case e_void:
217 default:
218 break;
219 case e_sint: s->Printf("%i", m_data.sint); break;
220 case e_uint: s->Printf("0x%8.8x", m_data.uint); break;
221 case e_slong: s->Printf("%li", m_data.slong); break;
222 case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break;
223 case e_slonglong: s->Printf("%lli", m_data.slonglong); break;
224 case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break;
225 case e_float: s->Printf("%f", m_data.flt); break;
226 case e_double: s->Printf("%g", m_data.dbl); break;
227 case e_long_double: s->Printf("%Lg", m_data.ldbl); break;
228 }
229}
230
231const char *
232Scalar::GetTypeAsCString() const
233{
234 switch (m_type)
235 {
236 default:
237 break;
238 case e_void: return "void";
239 case e_sint: return "int";
240 case e_uint: return "unsigned int";
241 case e_slong: return "long";
242 case e_ulong: return "unsigned long";
243 case e_slonglong: return "long long";
244 case e_ulonglong: return "unsigned long long";
245 case e_float: return "float";
246 case e_double: return "double";
247 case e_long_double: return "long double";
248 }
249 return "<invalid Scalar type>";
250}
251
252
253
254//----------------------------------------------------------------------
255// Scalar copy constructor
256//----------------------------------------------------------------------
257Scalar&
258Scalar::operator=(const Scalar& rhs)
259{
260 if (this != &rhs)
261 {
262 m_type = rhs.m_type;
263 ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
264 }
265 return *this;
266}
267
268Scalar&
269Scalar::operator= (const int v)
270{
271 m_type = e_sint;
272 m_data.sint = v;
273 return *this;
274}
275
276
277Scalar&
278Scalar::operator= (unsigned int v)
279{
280 m_type = e_uint;
281 m_data.uint = v;
282 return *this;
283}
284
285Scalar&
286Scalar::operator= (long v)
287{
288 m_type = e_slong;
289 m_data.slong = v;
290 return *this;
291}
292
293Scalar&
294Scalar::operator= (unsigned long v)
295{
296 m_type = e_ulong;
297 m_data.ulong = v;
298 return *this;
299}
300
301Scalar&
302Scalar::operator= (long long v)
303{
304 m_type = e_slonglong;
305 m_data.slonglong = v;
306 return *this;
307}
308
309Scalar&
310Scalar::operator= (unsigned long long v)
311{
312 m_type = e_ulonglong;
313 m_data.ulonglong = v;
314 return *this;
315}
316
317Scalar&
318Scalar::operator= (float v)
319{
320 m_type = e_float;
321 m_data.flt = v;
322 return *this;
323}
324
325Scalar&
326Scalar::operator= (double v)
327{
328 m_type = e_double;
329 m_data.dbl = v;
330 return *this;
331}
332
333Scalar&
334Scalar::operator= (long double v)
335{
336 m_type = e_long_double;
337 m_data.ldbl = v;
338 return *this;
339}
340
341//----------------------------------------------------------------------
342// Destructor
343//----------------------------------------------------------------------
344Scalar::~Scalar()
345{
346}
347
348bool
349Scalar::Promote(Scalar::Type type)
350{
351 bool success = false;
352 switch (m_type)
353 {
354 case e_void:
355 break;
356
357 case e_sint:
358 switch (type)
359 {
360 default:
361 case e_void: break;
362 case e_sint: success = true; break;
363 case e_uint: m_data.uint = m_data.sint; success = true; break;
364 case e_slong: m_data.slong = m_data.sint; success = true; break;
365 case e_ulong: m_data.ulong = m_data.sint; success = true; break;
366 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
367 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
368 case e_float: m_data.flt = m_data.sint; success = true; break;
369 case e_double: m_data.dbl = m_data.sint; success = true; break;
370 case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
371 }
372 break;
373
374 case e_uint:
375 switch (type)
376 {
377 default:
378 case e_void:
379 case e_sint: break;
380 case e_uint: success = true; break;
381 case e_slong: m_data.slong = m_data.uint; success = true; break;
382 case e_ulong: m_data.ulong = m_data.uint; success = true; break;
383 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
384 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
385 case e_float: m_data.flt = m_data.uint; success = true; break;
386 case e_double: m_data.dbl = m_data.uint; success = true; break;
387 case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
388 }
389 break;
390
391 case e_slong:
392 switch (type)
393 {
394 default:
395 case e_void:
396 case e_sint:
397 case e_uint: break;
398 case e_slong: success = true; break;
399 case e_ulong: m_data.ulong = m_data.slong; success = true; break;
400 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
401 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
402 case e_float: m_data.flt = m_data.slong; success = true; break;
403 case e_double: m_data.dbl = m_data.slong; success = true; break;
404 case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
405 }
406 break;
407
408 case e_ulong:
409 switch (type)
410 {
411 default:
412 case e_void:
413 case e_sint:
414 case e_uint:
415 case e_slong: break;
416 case e_ulong: success = true; break;
417 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
418 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
419 case e_float: m_data.flt = m_data.ulong; success = true; break;
420 case e_double: m_data.dbl = m_data.ulong; success = true; break;
421 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
422 }
423 break;
424
425 case e_slonglong:
426 switch (type)
427 {
428 default:
429 case e_void:
430 case e_sint:
431 case e_uint:
432 case e_slong:
433 case e_ulong: break;
434 case e_slonglong: success = true; break;
435 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
436 case e_float: m_data.flt = m_data.slonglong; success = true; break;
437 case e_double: m_data.dbl = m_data.slonglong; success = true; break;
438 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
439 }
440 break;
441
442 case e_ulonglong:
443 switch (type)
444 {
445 default:
446 case e_void:
447 case e_sint:
448 case e_uint:
449 case e_slong:
450 case e_ulong:
451 case e_slonglong: break;
452 case e_ulonglong: success = true; break;
453 case e_float: m_data.flt = m_data.ulonglong; success = true; break;
454 case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
455 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
456 }
457 break;
458
459 case e_float:
460 switch (type)
461 {
462 default:
463 case e_void:
464 case e_sint:
465 case e_uint:
466 case e_slong:
467 case e_ulong:
468 case e_slonglong:
469 case e_ulonglong: break;
470 case e_float: success = true; break;
471 case e_double: m_data.dbl = m_data.flt; success = true; break;
472 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
473 }
474 break;
475
476 case e_double:
477 switch (type)
478 {
479 default:
480 case e_void:
481 case e_sint:
482 case e_uint:
483 case e_slong:
484 case e_ulong:
485 case e_slonglong:
486 case e_ulonglong:
487 case e_float: break;
488 case e_double: success = true; break;
489 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
490 }
491 break;
492
493 case e_long_double:
494 switch (type)
495 {
496 default:
497 case e_void:
498 case e_sint:
499 case e_uint:
500 case e_slong:
501 case e_ulong:
502 case e_slonglong:
503 case e_ulonglong:
504 case e_float:
505 case e_double: break;
506 case e_long_double: success = true; break;
507 }
508 break;
509 }
510
511 if (success)
512 m_type = type;
513 return success;
514}
515
516const char *
517Scalar::GetValueTypeAsCString (Scalar::Type type)
518{
519 switch (type)
520 {
521 default: break;
522 case e_void: return "void";
523 case e_sint: return "int";
524 case e_uint: return "unsigned int";
525 case e_slong: return "long";
526 case e_ulong: return "unsigned long";
527 case e_slonglong: return "long long";
528 case e_ulonglong: return "unsigned long long";
529 case e_float: return "float";
530 case e_double: return "double";
531 case e_long_double: return "long double";
532 }
533 return "???";
534}
535
536
537Scalar::Type
538Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
539{
540 if (byte_size <= sizeof(int))
541 return e_sint;
542 if (byte_size <= sizeof(long))
543 return e_slong;
544 if (byte_size <= sizeof(long long))
545 return e_slonglong;
546 return e_void;
547}
548
549Scalar::Type
550Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
551{
552 if (byte_size <= sizeof(unsigned int))
553 return e_uint;
554 if (byte_size <= sizeof(unsigned long))
555 return e_ulong;
556 if (byte_size <= sizeof(unsigned long long))
557 return e_ulonglong;
558 return e_void;
559}
560
561Scalar::Type
562Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
563{
564 if (byte_size == sizeof(float))
565 return e_float;
566 if (byte_size == sizeof(double))
567 return e_double;
568 if (byte_size == sizeof(long double))
569 return e_long_double;
570 return e_void;
571}
572
573bool
574Scalar::Cast(Scalar::Type type)
575{
576 bool success = false;
577 switch (m_type)
578 {
579 case e_void:
580 break;
581
582 case e_sint:
583 switch (type)
584 {
585 default:
586 case e_void: break;
587 case e_sint: success = true; break;
588 case e_uint: m_data.uint = m_data.sint; success = true; break;
589 case e_slong: m_data.slong = m_data.sint; success = true; break;
590 case e_ulong: m_data.ulong = m_data.sint; success = true; break;
591 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
592 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
593 case e_float: m_data.flt = m_data.sint; success = true; break;
594 case e_double: m_data.dbl = m_data.sint; success = true; break;
595 case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
596 }
597 break;
598
599 case e_uint:
600 switch (type)
601 {
602 default:
603 case e_void:
604 case e_sint: m_data.sint = m_data.uint; success = true; break;
605 case e_uint: success = true; break;
606 case e_slong: m_data.slong = m_data.uint; success = true; break;
607 case e_ulong: m_data.ulong = m_data.uint; success = true; break;
608 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
609 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
610 case e_float: m_data.flt = m_data.uint; success = true; break;
611 case e_double: m_data.dbl = m_data.uint; success = true; break;
612 case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
613 }
614 break;
615
616 case e_slong:
617 switch (type)
618 {
619 default:
620 case e_void:
621 case e_sint: m_data.sint = m_data.slong; success = true; break;
622 case e_uint: m_data.uint = m_data.slong; success = true; break;
623 case e_slong: success = true; break;
624 case e_ulong: m_data.ulong = m_data.slong; success = true; break;
625 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
626 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
627 case e_float: m_data.flt = m_data.slong; success = true; break;
628 case e_double: m_data.dbl = m_data.slong; success = true; break;
629 case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
630 }
631 break;
632
633 case e_ulong:
634 switch (type)
635 {
636 default:
637 case e_void:
638 case e_sint: m_data.sint = m_data.ulong; success = true; break;
639 case e_uint: m_data.uint = m_data.ulong; success = true; break;
640 case e_slong: m_data.slong = m_data.ulong; success = true; break;
641 case e_ulong: success = true; break;
642 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
643 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
644 case e_float: m_data.flt = m_data.ulong; success = true; break;
645 case e_double: m_data.dbl = m_data.ulong; success = true; break;
646 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
647 }
648 break;
649
650 case e_slonglong:
651 switch (type)
652 {
653 default:
654 case e_void:
655 case e_sint: m_data.sint = m_data.slonglong; success = true; break;
656 case e_uint: m_data.uint = m_data.slonglong; success = true; break;
657 case e_slong: m_data.slong = m_data.slonglong; success = true; break;
658 case e_ulong: m_data.ulong = m_data.slonglong; success = true; break;
659 case e_slonglong: success = true; break;
660 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
661 case e_float: m_data.flt = m_data.slonglong; success = true; break;
662 case e_double: m_data.dbl = m_data.slonglong; success = true; break;
663 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
664 }
665 break;
666
667 case e_ulonglong:
668 switch (type)
669 {
670 default:
671 case e_void:
672 case e_sint: m_data.sint = m_data.ulonglong; success = true; break;
673 case e_uint: m_data.uint = m_data.ulonglong; success = true; break;
674 case e_slong: m_data.slong = m_data.ulonglong; success = true; break;
675 case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break;
676 case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break;
677 case e_ulonglong: success = true; break;
678 case e_float: m_data.flt = m_data.ulonglong; success = true; break;
679 case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
680 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
681 }
682 break;
683
684 case e_float:
685 switch (type)
686 {
687 default:
688 case e_void:
689 case e_sint: m_data.sint = m_data.flt; success = true; break;
690 case e_uint: m_data.uint = m_data.flt; success = true; break;
691 case e_slong: m_data.slong = m_data.flt; success = true; break;
692 case e_ulong: m_data.ulong = m_data.flt; success = true; break;
693 case e_slonglong: m_data.slonglong = m_data.flt; success = true; break;
694 case e_ulonglong: m_data.ulonglong = m_data.flt; success = true; break;
695 case e_float: success = true; break;
696 case e_double: m_data.dbl = m_data.flt; success = true; break;
697 case e_long_double: m_data.ldbl = m_data.flt; success = true; break;
698 }
699 break;
700
701 case e_double:
702 switch (type)
703 {
704 default:
705 case e_void:
706 case e_sint: m_data.sint = m_data.dbl; success = true; break;
707 case e_uint: m_data.uint = m_data.dbl; success = true; break;
708 case e_slong: m_data.slong = m_data.dbl; success = true; break;
709 case e_ulong: m_data.ulong = m_data.dbl; success = true; break;
710 case e_slonglong: m_data.slonglong = m_data.dbl; success = true; break;
711 case e_ulonglong: m_data.ulonglong = m_data.dbl; success = true; break;
712 case e_float: m_data.flt = m_data.dbl; success = true; break;
713 case e_double: success = true; break;
714 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
715 }
716 break;
717
718 case e_long_double:
719 switch (type)
720 {
721 default:
722 case e_void:
723 case e_sint: m_data.sint = m_data.ldbl; success = true; break;
724 case e_uint: m_data.uint = m_data.ldbl; success = true; break;
725 case e_slong: m_data.slong = m_data.ldbl; success = true; break;
726 case e_ulong: m_data.ulong = m_data.ldbl; success = true; break;
727 case e_slonglong: m_data.slonglong = m_data.ldbl; success = true; break;
728 case e_ulonglong: m_data.ulonglong = m_data.ldbl; success = true; break;
729 case e_float: m_data.flt = m_data.ldbl; success = true; break;
730 case e_double: m_data.dbl = m_data.ldbl; success = true; break;
731 case e_long_double: success = true; break;
732 }
733 break;
734 }
735
736 if (success)
737 m_type = type;
738 return success;
739}
740
741int
742Scalar::SInt(int fail_value) const
743{
744 switch (m_type)
745 {
746 default:
747 case e_void: break;
748 case e_sint: return m_data.sint;
749 case e_uint: return (int)m_data.uint;
750 case e_slong: return (int)m_data.slong;
751 case e_ulong: return (int)m_data.ulong;
752 case e_slonglong: return (int)m_data.slonglong;
753 case e_ulonglong: return (int)m_data.ulonglong;
754 case e_float: return (int)m_data.flt;
755 case e_double: return (int)m_data.dbl;
756 case e_long_double: return (int)m_data.ldbl;
757 }
758 return fail_value;
759}
760
761unsigned int
762Scalar::UInt(unsigned int fail_value) const
763{
764 switch (m_type)
765 {
766 default:
767 case e_void: break;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]768 case e_sint: return (unsigned int)m_data.sint;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]769 case e_uint: return (unsigned int)m_data.uint;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]770 case e_slong: return (unsigned int)m_data.slong;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]771 case e_ulong: return (unsigned int)m_data.ulong;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]772 case e_slonglong: return (unsigned int)m_data.slonglong;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]773 case e_ulonglong: return (unsigned int)m_data.ulonglong;
774 case e_float: return (unsigned int)m_data.flt;
775 case e_double: return (unsigned int)m_data.dbl;
776 case e_long_double: return (unsigned int)m_data.ldbl;
777 }
778 return fail_value;
779}
780
781
782long
783Scalar::SLong(long fail_value) const
784{
785 switch (m_type)
786 {
787 default:
788 case e_void: break;
789 case e_sint: return (long)m_data.sint;
790 case e_uint: return (long)m_data.uint;
791 case e_slong: return (long)m_data.slong;
792 case e_ulong: return (long)m_data.ulong;
793 case e_slonglong: return (long)m_data.slonglong;
794 case e_ulonglong: return (long)m_data.ulonglong;
795 case e_float: return (long)m_data.flt;
796 case e_double: return (long)m_data.dbl;
797 case e_long_double: return (long)m_data.ldbl;
798 }
799 return fail_value;
800}
801
802
803
804unsigned long
805Scalar::ULong(unsigned long fail_value) const
806{
807 switch (m_type)
808 {
809 default:
810 case e_void: break;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]811 case e_sint: return (unsigned long)m_data.sint;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]812 case e_uint: return (unsigned long)m_data.uint;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]813 case e_slong: return (unsigned long)m_data.slong;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]814 case e_ulong: return (unsigned long)m_data.ulong;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]815 case e_slonglong: return (unsigned long)m_data.slonglong;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]816 case e_ulonglong: return (unsigned long)m_data.ulonglong;
817 case e_float: return (unsigned long)m_data.flt;
818 case e_double: return (unsigned long)m_data.dbl;
819 case e_long_double: return (unsigned long)m_data.ldbl;
820 }
821 return fail_value;
822}
823
824uint64_t
825Scalar::GetRawBits64(uint64_t fail_value) const
826{
827 switch (m_type)
828 {
829 default:
830 case e_void:
831 break;
832
833 case e_sint:
834 case e_uint:
835 return m_data.uint;
836
837 case e_slong:
838 case e_ulong:
839 return m_data.ulong;
840
841 case e_slonglong:
842 case e_ulonglong:
843 return m_data.ulonglong;
844
845 case e_float:
846 if (sizeof(m_data.flt) == sizeof(int))
847 return m_data.uint;
848 else if (sizeof(m_data.flt) == sizeof(unsigned long))
849 return m_data.ulong;
850 else if (sizeof(m_data.flt) == sizeof(unsigned long long))
851 return m_data.ulonglong;
852 break;
853
854 case e_double:
855 if (sizeof(m_data.dbl) == sizeof(int))
856 return m_data.uint;
857 else if (sizeof(m_data.dbl) == sizeof(unsigned long))
858 return m_data.ulong;
859 else if (sizeof(m_data.dbl) == sizeof(unsigned long long))
860 return m_data.ulonglong;
861 break;
862
863 case e_long_double:
864 if (sizeof(m_data.ldbl) == sizeof(int))
865 return m_data.uint;
866 else if (sizeof(m_data.ldbl) == sizeof(unsigned long))
867 return m_data.ulong;
868 else if (sizeof(m_data.ldbl) == sizeof(unsigned long long))
869 return m_data.ulonglong;
870 break;
871 }
872 return fail_value;
873}
874
875
876
877long long
878Scalar::SLongLong(long long fail_value) const
879{
880 switch (m_type)
881 {
882 default:
883 case e_void: break;
884 case e_sint: return (long long)m_data.sint;
885 case e_uint: return (long long)m_data.uint;
886 case e_slong: return (long long)m_data.slong;
887 case e_ulong: return (long long)m_data.ulong;
888 case e_slonglong: return (long long)m_data.slonglong;
889 case e_ulonglong: return (long long)m_data.ulonglong;
890 case e_float: return (long long)m_data.flt;
891 case e_double: return (long long)m_data.dbl;
892 case e_long_double: return (long long)m_data.ldbl;
893 }
894 return fail_value;
895}
896
897
898unsigned long long
899Scalar::ULongLong(unsigned long long fail_value) const
900{
901 switch (m_type)
902 {
903 default:
904 case e_void: break;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]905 case e_sint: return (unsigned long long)m_data.sint;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]906 case e_uint: return (unsigned long long)m_data.uint;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]907 case e_slong: return (unsigned long long)m_data.slong;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]908 case e_ulong: return (unsigned long long)m_data.ulong;
Enrico Granata5020f952012-10-24 21:42:49 +0000[diff] [blame^]909 case e_slonglong: return (unsigned long long)m_data.slonglong;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]910 case e_ulonglong: return (unsigned long long)m_data.ulonglong;
911 case e_float: return (unsigned long long)m_data.flt;
912 case e_double: return (unsigned long long)m_data.dbl;
913 case e_long_double: return (unsigned long long)m_data.ldbl;
914 }
915 return fail_value;
916}
917
918
919float
920Scalar::Float(float fail_value) const
921{
922 switch (m_type)
923 {
924 default:
925 case e_void: break;
926 case e_sint: return (float)m_data.sint;
927 case e_uint: return (float)m_data.uint;
928 case e_slong: return (float)m_data.slong;
929 case e_ulong: return (float)m_data.ulong;
930 case e_slonglong: return (float)m_data.slonglong;
931 case e_ulonglong: return (float)m_data.ulonglong;
932 case e_float: return (float)m_data.flt;
933 case e_double: return (float)m_data.dbl;
934 case e_long_double: return (float)m_data.ldbl;
935 }
936 return fail_value;
937}
938
939
940double
941Scalar::Double(double fail_value) const
942{
943 switch (m_type)
944 {
945 default:
946 case e_void: break;
947 case e_sint: return (double)m_data.sint;
948 case e_uint: return (double)m_data.uint;
949 case e_slong: return (double)m_data.slong;
950 case e_ulong: return (double)m_data.ulong;
951 case e_slonglong: return (double)m_data.slonglong;
952 case e_ulonglong: return (double)m_data.ulonglong;
953 case e_float: return (double)m_data.flt;
954 case e_double: return (double)m_data.dbl;
955 case e_long_double: return (double)m_data.ldbl;
956 }
957 return fail_value;
958}
959
960
961long double
962Scalar::LongDouble(long double fail_value) const
963{
964 switch (m_type)
965 {
966 default:
967 case e_void: break;
968 case e_sint: return (long double)m_data.sint;
969 case e_uint: return (long double)m_data.uint;
970 case e_slong: return (long double)m_data.slong;
971 case e_ulong: return (long double)m_data.ulong;
972 case e_slonglong: return (long double)m_data.slonglong;
973 case e_ulonglong: return (long double)m_data.ulonglong;
974 case e_float: return (long double)m_data.flt;
975 case e_double: return (long double)m_data.dbl;
976 case e_long_double: return (long double)m_data.ldbl;
977 }
978 return fail_value;
979}
980
981
982Scalar&
983Scalar::operator+= (const Scalar& rhs)
984{
985 Scalar temp_value;
986 const Scalar* a;
987 const Scalar* b;
988 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
989 {
990 switch (m_type)
991 {
992 default:
993 case e_void: break;
994 case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break;
995 case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break;
996 case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break;
997 case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
998 case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
999 case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
1000 case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break;
1001 case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
1002 case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
1003 }
1004 }
1005 return *this;
1006}
1007
1008Scalar&
1009Scalar::operator<<= (const Scalar& rhs)
1010{
1011 switch (m_type)
1012 {
1013 default:
1014 case e_void:
1015 case e_float:
1016 case e_double:
1017 case e_long_double:
1018 m_type = e_void;
1019 break;
1020
1021 case e_sint:
1022 switch (rhs.m_type)
1023 {
1024 default:
1025 case e_void:
1026 case e_float:
1027 case e_double:
1028 case e_long_double:
1029 m_type = e_void;
1030 break;
1031 case e_sint: m_data.sint <<= rhs.m_data.sint; break;
1032 case e_uint: m_data.sint <<= rhs.m_data.uint; break;
1033 case e_slong: m_data.sint <<= rhs.m_data.slong; break;
1034 case e_ulong: m_data.sint <<= rhs.m_data.ulong; break;
1035 case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break;
1036 case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break;
1037 }
1038 break;
1039
1040 case e_uint:
1041 switch (rhs.m_type)
1042 {
1043 default:
1044 case e_void:
1045 case e_float:
1046 case e_double:
1047 case e_long_double:
1048 m_type = e_void;
1049 break;
1050 case e_sint: m_data.uint <<= rhs.m_data.sint; break;
1051 case e_uint: m_data.uint <<= rhs.m_data.uint; break;
1052 case e_slong: m_data.uint <<= rhs.m_data.slong; break;
1053 case e_ulong: m_data.uint <<= rhs.m_data.ulong; break;
1054 case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break;
1055 case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break;
1056 }
1057 break;
1058
1059 case e_slong:
1060 switch (rhs.m_type)
1061 {
1062 default:
1063 case e_void:
1064 case e_float:
1065 case e_double:
1066 case e_long_double:
1067 m_type = e_void;
1068 break;
1069 case e_sint: m_data.slong <<= rhs.m_data.sint; break;
1070 case e_uint: m_data.slong <<= rhs.m_data.uint; break;
1071 case e_slong: m_data.slong <<= rhs.m_data.slong; break;
1072 case e_ulong: m_data.slong <<= rhs.m_data.ulong; break;
1073 case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break;
1074 case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break;
1075 }
1076 break;
1077
1078 case e_ulong:
1079 switch (rhs.m_type)
1080 {
1081 default:
1082 case e_void:
1083 case e_float:
1084 case e_double:
1085 case e_long_double:
1086 m_type = e_void;
1087 break;
1088 case e_sint: m_data.ulong <<= rhs.m_data.sint; break;
1089 case e_uint: m_data.ulong <<= rhs.m_data.uint; break;
1090 case e_slong: m_data.ulong <<= rhs.m_data.slong; break;
1091 case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break;
1092 case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break;
1093 case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break;
1094 }
1095 break;
1096 case e_slonglong:
1097 switch (rhs.m_type)
1098 {
1099 default:
1100 case e_void:
1101 case e_float:
1102 case e_double:
1103 case e_long_double:
1104 m_type = e_void;
1105 break;
1106 case e_sint: m_data.slonglong <<= rhs.m_data.sint; break;
1107 case e_uint: m_data.slonglong <<= rhs.m_data.uint; break;
1108 case e_slong: m_data.slonglong <<= rhs.m_data.slong; break;
1109 case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break;
1110 case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break;
1111 case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break;
1112 }
1113 break;
1114
1115 case e_ulonglong:
1116 switch (rhs.m_type)
1117 {
1118 default:
1119 case e_void:
1120 case e_float:
1121 case e_double:
1122 case e_long_double:
1123 m_type = e_void;
1124 break;
1125 case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break;
1126 case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break;
1127 case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break;
1128 case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break;
1129 case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break;
1130 case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break;
1131 }
1132 break;
1133 }
1134 return *this;
1135}
1136
1137bool
1138Scalar::ShiftRightLogical(const Scalar& rhs)
1139{
1140 switch (m_type)
1141 {
1142 default:
1143 case e_void:
1144 case e_float:
1145 case e_double:
1146 case e_long_double:
1147 m_type = e_void;
1148 break;
1149
1150 case e_sint:
1151 case e_uint:
1152 switch (rhs.m_type)
1153 {
1154 default:
1155 case e_void:
1156 case e_float:
1157 case e_double:
1158 case e_long_double:
1159 m_type = e_void;
1160 break;
1161 case e_sint: m_data.uint >>= rhs.m_data.sint; break;
1162 case e_uint: m_data.uint >>= rhs.m_data.uint; break;
1163 case e_slong: m_data.uint >>= rhs.m_data.slong; break;
1164 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
1165 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
1166 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
1167 }
1168 break;
1169
1170 case e_slong:
1171 case e_ulong:
1172 switch (rhs.m_type)
1173 {
1174 default:
1175 case e_void:
1176 case e_float:
1177 case e_double:
1178 case e_long_double:
1179 m_type = e_void;
1180 break;
1181 case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
1182 case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
1183 case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
1184 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
1185 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
1186 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
1187 }
1188 break;
1189
1190 case e_slonglong:
1191 case e_ulonglong:
1192 switch (rhs.m_type)
1193 {
1194 default:
1195 case e_void:
1196 case e_float:
1197 case e_double:
1198 case e_long_double:
1199 m_type = e_void;
1200 break;
1201 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
1202 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
1203 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
1204 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
1205 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
1206 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
1207 }
1208 break;
1209 }
1210 return m_type != e_void;
1211}
1212
1213
1214Scalar&
1215Scalar::operator>>= (const Scalar& rhs)
1216{
1217 switch (m_type)
1218 {
1219 default:
1220 case e_void:
1221 case e_float:
1222 case e_double:
1223 case e_long_double:
1224 m_type = e_void;
1225 break;
1226
1227 case e_sint:
1228 switch (rhs.m_type)
1229 {
1230 default:
1231 case e_void:
1232 case e_float:
1233 case e_double:
1234 case e_long_double:
1235 m_type = e_void;
1236 break;
1237 case e_sint: m_data.sint >>= rhs.m_data.sint; break;
1238 case e_uint: m_data.sint >>= rhs.m_data.uint; break;
1239 case e_slong: m_data.sint >>= rhs.m_data.slong; break;
1240 case e_ulong: m_data.sint >>= rhs.m_data.ulong; break;
1241 case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break;
1242 case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break;
1243 }
1244 break;
1245
1246 case e_uint:
1247 switch (rhs.m_type)
1248 {
1249 default:
1250 case e_void:
1251 case e_float:
1252 case e_double:
1253 case e_long_double:
1254 m_type = e_void;
1255 break;
1256 case e_sint: m_data.uint >>= rhs.m_data.sint; break;
1257 case e_uint: m_data.uint >>= rhs.m_data.uint; break;
1258 case e_slong: m_data.uint >>= rhs.m_data.slong; break;
1259 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
1260 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
1261 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
1262 }
1263 break;
1264
1265 case e_slong:
1266 switch (rhs.m_type)
1267 {
1268 default:
1269 case e_void:
1270 case e_float:
1271 case e_double:
1272 case e_long_double:
1273 m_type = e_void;
1274 break;
1275 case e_sint: m_data.slong >>= rhs.m_data.sint; break;
1276 case e_uint: m_data.slong >>= rhs.m_data.uint; break;
1277 case e_slong: m_data.slong >>= rhs.m_data.slong; break;
1278 case e_ulong: m_data.slong >>= rhs.m_data.ulong; break;
1279 case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break;
1280 case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break;
1281 }
1282 break;
1283
1284 case e_ulong:
1285 switch (rhs.m_type)
1286 {
1287 default:
1288 case e_void:
1289 case e_float:
1290 case e_double:
1291 case e_long_double:
1292 m_type = e_void;
1293 break;
1294 case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
1295 case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
1296 case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
1297 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
1298 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
1299 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
1300 }
1301 break;
1302 case e_slonglong:
1303 switch (rhs.m_type)
1304 {
1305 default:
1306 case e_void:
1307 case e_float:
1308 case e_double:
1309 case e_long_double:
1310 m_type = e_void;
1311 break;
1312 case e_sint: m_data.slonglong >>= rhs.m_data.sint; break;
1313 case e_uint: m_data.slonglong >>= rhs.m_data.uint; break;
1314 case e_slong: m_data.slonglong >>= rhs.m_data.slong; break;
1315 case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break;
1316 case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break;
1317 case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break;
1318 }
1319 break;
1320
1321 case e_ulonglong:
1322 switch (rhs.m_type)
1323 {
1324 default:
1325 case e_void:
1326 case e_float:
1327 case e_double:
1328 case e_long_double:
1329 m_type = e_void;
1330 break;
1331 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
1332 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
1333 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
1334 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
1335 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
1336 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
1337 }
1338 break;
1339 }
1340 return *this;
1341}
1342
1343
1344Scalar&
1345Scalar::operator&= (const Scalar& rhs)
1346{
1347 switch (m_type)
1348 {
1349 default:
1350 case e_void:
1351 case e_float:
1352 case e_double:
1353 case e_long_double:
1354 m_type = e_void;
1355 break;
1356
1357 case e_sint:
1358 switch (rhs.m_type)
1359 {
1360 default:
1361 case e_void:
1362 case e_float:
1363 case e_double:
1364 case e_long_double:
1365 m_type = e_void;
1366 break;
1367 case e_sint: m_data.sint &= rhs.m_data.sint; break;
1368 case e_uint: m_data.sint &= rhs.m_data.uint; break;
1369 case e_slong: m_data.sint &= rhs.m_data.slong; break;
1370 case e_ulong: m_data.sint &= rhs.m_data.ulong; break;
1371 case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break;
1372 case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break;
1373 }
1374 break;
1375
1376 case e_uint:
1377 switch (rhs.m_type)
1378 {
1379 default:
1380 case e_void:
1381 case e_float:
1382 case e_double:
1383 case e_long_double:
1384 m_type = e_void;
1385 break;
1386 case e_sint: m_data.uint &= rhs.m_data.sint; break;
1387 case e_uint: m_data.uint &= rhs.m_data.uint; break;
1388 case e_slong: m_data.uint &= rhs.m_data.slong; break;
1389 case e_ulong: m_data.uint &= rhs.m_data.ulong; break;
1390 case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break;
1391 case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break;
1392 }
1393 break;
1394
1395 case e_slong:
1396 switch (rhs.m_type)
1397 {
1398 default:
1399 case e_void:
1400 case e_float:
1401 case e_double:
1402 case e_long_double:
1403 m_type = e_void;
1404 break;
1405 case e_sint: m_data.slong &= rhs.m_data.sint; break;
1406 case e_uint: m_data.slong &= rhs.m_data.uint; break;
1407 case e_slong: m_data.slong &= rhs.m_data.slong; break;
1408 case e_ulong: m_data.slong &= rhs.m_data.ulong; break;
1409 case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break;
1410 case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break;
1411 }
1412 break;
1413
1414 case e_ulong:
1415 switch (rhs.m_type)
1416 {
1417 default:
1418 case e_void:
1419 case e_float:
1420 case e_double:
1421 case e_long_double:
1422 m_type = e_void;
1423 break;
1424 case e_sint: m_data.ulong &= rhs.m_data.sint; break;
1425 case e_uint: m_data.ulong &= rhs.m_data.uint; break;
1426 case e_slong: m_data.ulong &= rhs.m_data.slong; break;
1427 case e_ulong: m_data.ulong &= rhs.m_data.ulong; break;
1428 case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break;
1429 case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break;
1430 }
1431 break;
1432 case e_slonglong:
1433 switch (rhs.m_type)
1434 {
1435 default:
1436 case e_void:
1437 case e_float:
1438 case e_double:
1439 case e_long_double:
1440 m_type = e_void;
1441 break;
1442 case e_sint: m_data.slonglong &= rhs.m_data.sint; break;
1443 case e_uint: m_data.slonglong &= rhs.m_data.uint; break;
1444 case e_slong: m_data.slonglong &= rhs.m_data.slong; break;
1445 case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break;
1446 case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break;
1447 case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break;
1448 }
1449 break;
1450
1451 case e_ulonglong:
1452 switch (rhs.m_type)
1453 {
1454 default:
1455 case e_void:
1456 case e_float:
1457 case e_double:
1458 case e_long_double:
1459 m_type = e_void;
1460 break;
1461 case e_sint: m_data.ulonglong &= rhs.m_data.sint; break;
1462 case e_uint: m_data.ulonglong &= rhs.m_data.uint; break;
1463 case e_slong: m_data.ulonglong &= rhs.m_data.slong; break;
1464 case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break;
1465 case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break;
1466 case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break;
1467 }
1468 break;
1469 }
1470 return *this;
1471}
1472
1473
1474
1475bool
1476Scalar::AbsoluteValue()
1477{
1478 switch (m_type)
1479 {
1480 default:
1481 case e_void:
1482 break;
1483
1484 case e_sint:
1485 if (m_data.sint < 0)
1486 m_data.sint = -m_data.sint;
1487 return true;
1488
1489 case e_slong:
1490 if (m_data.slong < 0)
1491 m_data.slong = -m_data.slong;
1492 return true;
1493
1494 case e_slonglong:
1495 if (m_data.slonglong < 0)
1496 m_data.slonglong = -m_data.slonglong;
1497 return true;
1498
1499 case e_uint:
1500 case e_ulong:
1501 case e_ulonglong: return true;
1502 case e_float: m_data.flt = fabsf(m_data.flt); return true;
1503 case e_double: m_data.dbl = fabs(m_data.dbl); return true;
1504 case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true;
1505 }
1506 return false;
1507}
1508
1509
1510bool
1511Scalar::UnaryNegate()
1512{
1513 switch (m_type)
1514 {
1515 default:
1516 case e_void: break;
1517 case e_sint: m_data.sint = -m_data.sint; return true;
1518 case e_uint: m_data.uint = -m_data.uint; return true;
1519 case e_slong: m_data.slong = -m_data.slong; return true;
1520 case e_ulong: m_data.ulong = -m_data.ulong; return true;
1521 case e_slonglong: m_data.slonglong = -m_data.slonglong; return true;
1522 case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true;
1523 case e_float: m_data.flt = -m_data.flt; return true;
1524 case e_double: m_data.dbl = -m_data.dbl; return true;
1525 case e_long_double: m_data.ldbl = -m_data.ldbl; return true;
1526 }
1527 return false;
1528}
1529
1530bool
1531Scalar::OnesComplement()
1532{
1533 switch (m_type)
1534 {
1535 case e_sint: m_data.sint = ~m_data.sint; return true;
1536 case e_uint: m_data.uint = ~m_data.uint; return true;
1537 case e_slong: m_data.slong = ~m_data.slong; return true;
1538 case e_ulong: m_data.ulong = ~m_data.ulong; return true;
1539 case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true;
1540 case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true;
1541
1542 default:
1543 case e_void:
1544 case e_float:
1545 case e_double:
1546 case e_long_double:
1547 break;
1548 }
1549 return false;
1550}
1551
1552
1553const Scalar
1554lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
1555{
1556 Scalar result;
1557 Scalar temp_value;
1558 const Scalar* a;
1559 const Scalar* b;
1560 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1561 {
1562 switch (result.m_type)
1563 {
1564 default:
1565 case Scalar::e_void: break;
1566 case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break;
1567 case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break;
1568 case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break;
1569 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
1570 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
1571 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
1572 case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break;
1573 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
1574 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
1575 }
1576 }
1577 return result;
1578}
1579
1580
1581const Scalar
1582lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
1583{
1584 Scalar result;
1585 Scalar temp_value;
1586 const Scalar* a;
1587 const Scalar* b;
1588 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1589 {
1590 switch (result.m_type)
1591 {
1592 default:
1593 case Scalar::e_void: break;
1594 case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break;
1595 case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break;
1596 case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break;
1597 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break;
1598 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break;
1599 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break;
1600 case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break;
1601 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break;
1602 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break;
1603 }
1604 }
1605 return result;
1606}
1607
1608const Scalar
1609lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
1610{
1611 Scalar result;
1612 Scalar temp_value;
1613 const Scalar* a;
1614 const Scalar* b;
1615 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1616 {
1617 switch (result.m_type)
1618 {
1619 default:
1620 case Scalar::e_void: break;
1621
1622 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;
1623 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;
1624 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;
1625 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;
1626 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;
1627 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;
1628 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;
1629 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;
1630 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;
1631 }
1632 }
1633 // For division only, the only way it should make it here is if a promotion failed,
1634 // or if we are trying to do a divide by zero.
1635 result.m_type = Scalar::e_void;
1636 return result;
1637}
1638
1639const Scalar
1640lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
1641{
1642 Scalar result;
1643 Scalar temp_value;
1644 const Scalar* a;
1645 const Scalar* b;
1646 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1647 {
1648 switch (result.m_type)
1649 {
1650 default:
1651 case Scalar::e_void: break;
1652 case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break;
1653 case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break;
1654 case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break;
1655 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break;
1656 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break;
1657 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break;
1658 case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break;
1659 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break;
1660 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break;
1661 }
1662 }
1663 return result;
1664}
1665
1666const Scalar
1667lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
1668{
1669 Scalar result;
1670 Scalar temp_value;
1671 const Scalar* a;
1672 const Scalar* b;
1673 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1674 {
1675 switch (result.m_type)
1676 {
1677 case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break;
1678 case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break;
1679 case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break;
1680 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break;
1681 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break;
1682 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break;
1683
1684 default:
1685 case Scalar::e_void:
1686 case Scalar::e_float:
1687 case Scalar::e_double:
1688 case Scalar::e_long_double:
1689 // No bitwise AND on floats, doubles of long doubles
1690 result.m_type = Scalar::e_void;
1691 break;
1692 }
1693 }
1694 return result;
1695}
1696
1697const Scalar
1698lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
1699{
1700 Scalar result;
1701 Scalar temp_value;
1702 const Scalar* a;
1703 const Scalar* b;
1704 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1705 {
1706 switch (result.m_type)
1707 {
1708 case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break;
1709 case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break;
1710 case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break;
1711 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break;
1712 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break;
1713 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break;
1714
1715 default:
1716 case Scalar::e_void:
1717 case Scalar::e_float:
1718 case Scalar::e_double:
1719 case Scalar::e_long_double:
1720 // No bitwise AND on floats, doubles of long doubles
1721 result.m_type = Scalar::e_void;
1722 break;
1723 }
1724 }
1725 return result;
1726}
1727
1728const Scalar
1729lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
1730{
1731 Scalar result;
1732 Scalar temp_value;
1733 const Scalar* a;
1734 const Scalar* b;
1735 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1736 {
1737 switch (result.m_type)
1738 {
1739 case Scalar::e_sint: result.m_data.sint = a->m_data.sint % b->m_data.sint; break;
1740 case Scalar::e_uint: result.m_data.uint = a->m_data.uint % b->m_data.uint; break;
1741 case Scalar::e_slong: result.m_data.slong = a->m_data.slong % b->m_data.slong; break;
1742 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong % b->m_data.ulong; break;
1743 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong % b->m_data.slonglong; break;
1744 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong % b->m_data.ulonglong; break;
1745
1746 default:
1747 case Scalar::e_void:
1748 case Scalar::e_float:
1749 case Scalar::e_double:
1750 case Scalar::e_long_double:
1751 // No bitwise AND on floats, doubles of long doubles
1752 result.m_type = Scalar::e_void;
1753 break;
1754 }
1755 }
1756 return result;
1757}
1758
1759const Scalar
1760lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
1761{
1762 Scalar result;
1763 Scalar temp_value;
1764 const Scalar* a;
1765 const Scalar* b;
1766 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1767 {
1768 switch (result.m_type)
1769 {
1770 case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break;
1771 case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break;
1772 case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break;
1773 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break;
1774 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break;
1775 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break;
1776
1777 default:
1778 case Scalar::e_void:
1779 case Scalar::e_float:
1780 case Scalar::e_double:
1781 case Scalar::e_long_double:
1782 // No bitwise AND on floats, doubles of long doubles
1783 result.m_type = Scalar::e_void;
1784 break;
1785 }
1786 }
1787 return result;
1788}
1789
1790// Return the raw unsigned integer without any casting or conversion
1791unsigned int
1792Scalar::RawUInt () const
1793{
1794 return m_data.uint;
1795}
1796
1797// Return the raw unsigned long without any casting or conversion
1798unsigned long
1799Scalar::RawULong () const
1800{
1801 return m_data.ulong;
1802}
1803
1804// Return the raw unsigned long long without any casting or conversion
1805unsigned long long
1806Scalar::RawULongLong () const
1807{
1808 return m_data.ulonglong;
1809}
1810
1811
1812Error
1813Scalar::SetValueFromCString (const char *value_str, Encoding encoding, uint32_t byte_size)
1814{
1815 Error error;
Johnny Chen84462772011-08-11 19:12:10 +0000[diff] [blame]1816 if (value_str == NULL || value_str[0] == '\0')
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1817 {
1818 error.SetErrorString ("Invalid c-string value string.");
1819 return error;
1820 }
1821 bool success = false;
1822 switch (encoding)
1823 {
1824 default:
1825 case eEncodingInvalid:
1826 error.SetErrorString ("Invalid encoding.");
1827 break;
1828
1829 case eEncodingUint:
1830 if (byte_size <= sizeof (unsigned long long))
1831 {
1832 uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
1833 if (!success)
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1834 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1835 else if (!UIntValueIsValidForSize (uval64, byte_size))
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1836 error.SetErrorStringWithFormat ("value 0x%llx is too large to fit in a %u byte unsigned integer value", uval64, byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1837 else
1838 {
1839 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
1840 switch (m_type)
1841 {
1842 case e_uint: m_data.uint = uval64; break;
1843 case e_ulong: m_data.ulong = uval64; break;
1844 case e_ulonglong: m_data.ulonglong = uval64; break;
1845 default:
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1846 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1847 break;
1848 }
1849 }
1850 }
1851 else
1852 {
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1853 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1854 return error;
1855 }
1856 break;
1857
1858 case eEncodingSint:
1859 if (byte_size <= sizeof (long long))
1860 {
1861 uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
1862 if (!success)
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1863 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1864 else if (!SIntValueIsValidForSize (sval64, byte_size))
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1865 error.SetErrorStringWithFormat ("value 0x%llx is too large to fit in a %u byte signed integer value", sval64, byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1866 else
1867 {
1868 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
1869 switch (m_type)
1870 {
1871 case e_sint: m_data.sint = sval64; break;
1872 case e_slong: m_data.slong = sval64; break;
1873 case e_slonglong: m_data.slonglong = sval64; break;
1874 default:
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1875 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1876 break;
1877 }
1878 }
1879 }
1880 else
1881 {
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1882 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1883 return error;
1884 }
1885 break;
1886
1887 case eEncodingIEEE754:
1888 if (byte_size == sizeof (float))
1889 {
1890 if (::sscanf (value_str, "%f", &m_data.flt) == 1)
1891 m_type = e_float;
1892 else
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1893 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1894 }
1895 else if (byte_size == sizeof (double))
1896 {
1897 if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
1898 m_type = e_double;
1899 else
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1900 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1901 }
1902 else if (byte_size == sizeof (long double))
1903 {
1904 if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
1905 m_type = e_long_double;
1906 else
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1907 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1908 }
1909 else
1910 {
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1911 error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1912 return error;
1913 }
1914 break;
1915
1916 case eEncodingVector:
Greg Clayton86edbf42011-10-26 00:56:27 +0000[diff] [blame]1917 error.SetErrorString ("vector encoding unsupported.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1918 break;
1919 }
1920 if (error.Fail())
1921 m_type = e_void;
1922
1923 return error;
1924}
1925
1926bool
Greg Claytone3769382011-05-19 00:17:26 +0000[diff] [blame]1927Scalar::SignExtend (uint32_t sign_bit_pos)
1928{
1929 const uint32_t max_bit_pos = GetByteSize() * 8;
1930
1931 if (sign_bit_pos < max_bit_pos)
1932 {
1933 switch (m_type)
1934 {
1935 default:
1936 case Scalar::e_void:
1937 case Scalar::e_float:
1938 case Scalar::e_double:
1939 case Scalar::e_long_double:
1940 return false;
1941
1942 case Scalar::e_sint:
1943 case Scalar::e_uint:
1944 if (max_bit_pos == sign_bit_pos)
1945 return true;
1946 else if (sign_bit_pos < (max_bit_pos-1))
1947 {
1948 unsigned int sign_bit = 1u << sign_bit_pos;
1949 if (m_data.uint & sign_bit)
1950 {
1951 const unsigned int mask = ~(sign_bit) + 1u;
1952 m_data.uint |= mask;
1953 }
1954 return true;
1955 }
1956 break;
1957
1958 case Scalar::e_slong:
1959 case Scalar::e_ulong:
1960 if (max_bit_pos == sign_bit_pos)
1961 return true;
1962 else if (sign_bit_pos < (max_bit_pos-1))
1963 {
1964 unsigned long sign_bit = 1ul << sign_bit_pos;
Greg Clayton316b4602011-05-19 00:55:50 +0000[diff] [blame]1965 if (m_data.ulong & sign_bit)
Greg Claytone3769382011-05-19 00:17:26 +0000[diff] [blame]1966 {
1967 const unsigned long mask = ~(sign_bit) + 1ul;
Greg Clayton316b4602011-05-19 00:55:50 +0000[diff] [blame]1968 m_data.ulong |= mask;
Greg Claytone3769382011-05-19 00:17:26 +0000[diff] [blame]1969 }
1970 return true;
1971 }
1972 break;
1973
1974 case Scalar::e_slonglong:
1975 case Scalar::e_ulonglong:
1976 if (max_bit_pos == sign_bit_pos)
1977 return true;
1978 else if (sign_bit_pos < (max_bit_pos-1))
1979 {
1980 unsigned long long sign_bit = 1ull << sign_bit_pos;
Greg Clayton316b4602011-05-19 00:55:50 +0000[diff] [blame]1981 if (m_data.ulonglong & sign_bit)
Greg Claytone3769382011-05-19 00:17:26 +0000[diff] [blame]1982 {
1983 const unsigned long long mask = ~(sign_bit) + 1ull;
Greg Clayton316b4602011-05-19 00:55:50 +0000[diff] [blame]1984 m_data.ulonglong |= mask;
Greg Claytone3769382011-05-19 00:17:26 +0000[diff] [blame]1985 }
1986 return true;
1987 }
1988 break;
1989 }
1990 }
1991 return false;
1992}
1993
Greg Claytonf3ef3d22011-05-22 22:46:53 +0000[diff] [blame]1994uint32_t
1995Scalar::GetAsMemoryData (void *dst,
1996 uint32_t dst_len,
1997 lldb::ByteOrder dst_byte_order,
1998 Error &error) const
1999{
2000 // Get a data extractor that points to the native scalar data
2001 DataExtractor data;
2002 if (!GetData(data))
2003 {
2004 error.SetErrorString ("invalid scalar value");
2005 return 0;
2006 }
2007
2008 const size_t src_len = data.GetByteSize();
2009
2010 // Prepare a memory buffer that contains some or all of the register value
2011 const uint32_t bytes_copied = data.CopyByteOrderedData (0, // src offset
2012 src_len, // src length
2013 dst, // dst buffer
2014 dst_len, // dst length
2015 dst_byte_order); // dst byte order
2016 if (bytes_copied == 0)
2017 error.SetErrorString ("failed to copy data");
2018
2019 return bytes_copied;
2020}
2021
Greg Claytone3769382011-05-19 00:17:26 +0000[diff] [blame]2022bool
Greg Claytondcad5022011-12-29 01:26:56 +0000[diff] [blame]2023Scalar::ExtractBitfield (uint32_t bit_size,
2024 uint32_t bit_offset)
2025{
2026 if (bit_size == 0)
2027 return true;
2028
2029 uint32_t msbit = bit_offset + bit_size - 1;
2030 uint32_t lsbit = bit_offset;
2031 switch (m_type)
2032 {
2033 default:
2034 case Scalar::e_void:
2035 break;
2036
2037 case e_float:
2038 if (sizeof(m_data.flt) == sizeof(int))
2039 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2040 else if (sizeof(m_data.flt) == sizeof(unsigned long))
2041 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2042 else if (sizeof(m_data.flt) == sizeof(unsigned long long))
2043 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2044 else
2045 return false;
2046 return true;
2047
2048 case e_double:
2049 if (sizeof(m_data.dbl) == sizeof(int))
2050 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2051 else if (sizeof(m_data.dbl) == sizeof(unsigned long))
2052 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2053 else if (sizeof(m_data.dbl) == sizeof(unsigned long long))
2054 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2055 else
2056 return false;
2057 return true;
2058
2059 case e_long_double:
2060 if (sizeof(m_data.ldbl) == sizeof(int))
2061 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2062 else if (sizeof(m_data.ldbl) == sizeof(unsigned long))
2063 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2064 else if (sizeof(m_data.ldbl) == sizeof(unsigned long long))
2065 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2066 else
2067 return false;
2068 return true;
2069
2070 case Scalar::e_sint:
2071 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2072 return true;
2073
2074 case Scalar::e_uint:
2075 m_data.uint = UnsignedBits (m_data.uint, msbit, lsbit);
2076 return true;
2077
2078 case Scalar::e_slong:
2079 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2080 return true;
2081
2082 case Scalar::e_ulong:
2083 m_data.ulong = SignedBits (m_data.ulong, msbit, lsbit);
2084 return true;
2085
2086 case Scalar::e_slonglong:
2087 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2088 return true;
2089
2090 case Scalar::e_ulonglong:
2091 m_data.ulonglong = SignedBits (m_data.ulonglong, msbit, lsbit);
2092 return true;
2093 }
2094 return false;
2095}
2096
2097
2098
2099
2100
2101bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]2102lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
2103{
2104 // If either entry is void then we can just compare the types
2105 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2106 return lhs.m_type == rhs.m_type;
2107
2108 Scalar temp_value;
2109 const Scalar* a;
2110 const Scalar* b;
2111 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2112 {
2113 default:
2114 case Scalar::e_void: break;
2115 case Scalar::e_sint: return a->m_data.sint == b->m_data.sint;
2116 case Scalar::e_uint: return a->m_data.uint == b->m_data.uint;
2117 case Scalar::e_slong: return a->m_data.slong == b->m_data.slong;
2118 case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong;
2119 case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong;
2120 case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong;
2121 case Scalar::e_float: return a->m_data.flt == b->m_data.flt;
2122 case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl;
2123 case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl;
2124 }
2125 return false;
2126}
2127
2128bool
2129lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
2130{
2131 // If either entry is void then we can just compare the types
2132 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2133 return lhs.m_type != rhs.m_type;
2134
2135 Scalar temp_value; // A temp value that might get a copy of either promoted value
2136 const Scalar* a;
2137 const Scalar* b;
2138 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2139 {
2140 default:
2141 case Scalar::e_void: break;
2142 case Scalar::e_sint: return a->m_data.sint != b->m_data.sint;
2143 case Scalar::e_uint: return a->m_data.uint != b->m_data.uint;
2144 case Scalar::e_slong: return a->m_data.slong != b->m_data.slong;
2145 case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong;
2146 case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong;
2147 case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong;
2148 case Scalar::e_float: return a->m_data.flt != b->m_data.flt;
2149 case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl;
2150 case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl;
2151 }
2152 return true;
2153}
2154
2155bool
2156lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
2157{
2158 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2159 return false;
2160
2161 Scalar temp_value;
2162 const Scalar* a;
2163 const Scalar* b;
2164 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2165 {
2166 default:
2167 case Scalar::e_void: break;
2168 case Scalar::e_sint: return a->m_data.sint < b->m_data.sint;
2169 case Scalar::e_uint: return a->m_data.uint < b->m_data.uint;
2170 case Scalar::e_slong: return a->m_data.slong < b->m_data.slong;
2171 case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong;
2172 case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong;
2173 case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong;
2174 case Scalar::e_float: return a->m_data.flt < b->m_data.flt;
2175 case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl;
2176 case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl;
2177 }
2178 return false;
2179}
2180
2181bool
2182lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
2183{
2184 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2185 return false;
2186
2187 Scalar temp_value;
2188 const Scalar* a;
2189 const Scalar* b;
2190 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2191 {
2192 default:
2193 case Scalar::e_void: break;
2194 case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint;
2195 case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint;
2196 case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong;
2197 case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong;
2198 case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong;
2199 case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong;
2200 case Scalar::e_float: return a->m_data.flt <= b->m_data.flt;
2201 case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl;
2202 case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl;
2203 }
2204 return false;
2205}
2206
2207
2208bool
2209lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
2210{
2211 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2212 return false;
2213
2214 Scalar temp_value;
2215 const Scalar* a;
2216 const Scalar* b;
2217 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2218 {
2219 default:
2220 case Scalar::e_void: break;
2221 case Scalar::e_sint: return a->m_data.sint > b->m_data.sint;
2222 case Scalar::e_uint: return a->m_data.uint > b->m_data.uint;
2223 case Scalar::e_slong: return a->m_data.slong > b->m_data.slong;
2224 case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong;
2225 case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong;
2226 case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong;
2227 case Scalar::e_float: return a->m_data.flt > b->m_data.flt;
2228 case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl;
2229 case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl;
2230 }
2231 return false;
2232}
2233
2234bool
2235lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
2236{
2237 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2238 return false;
2239
2240 Scalar temp_value;
2241 const Scalar* a;
2242 const Scalar* b;
2243 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2244 {
2245 default:
2246 case Scalar::e_void: break;
2247 case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint;
2248 case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint;
2249 case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong;
2250 case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong;
2251 case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong;
2252 case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong;
2253 case Scalar::e_float: return a->m_data.flt >= b->m_data.flt;
2254 case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl;
2255 case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl;
2256 }
2257 return false;
2258}
2259
2260
2261
2262