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