Scalar.cpp revision 671dd558650c457d54f124a58db91b0e26802399
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 14#include "lldb/Interpreter/Args.h" 15#include "lldb/Core/Error.h" 16#include "lldb/Core/Stream.h" 17#include "lldb/Core/DataExtractor.h" 18#include "lldb/Host/Endian.h" 19 20#include "Plugins/Process/Utility/InstructionUtils.h" 21 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 { 140 if (lldb::endian::InlHostByteOrder() == eByteOrderLittle) 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... 145 data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder()); 146 } 147 else if (lldb::endian::InlHostByteOrder() == eByteOrderBig) 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 152 data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder()); 153 } 154 } 155 else 156 { 157 // We want all of the data 158 data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder()); 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; 768 case e_sint: return (unsigned int)m_data.sint; 769 case e_uint: return (unsigned int)m_data.uint; 770 case e_slong: return (unsigned int)m_data.slong; 771 case e_ulong: return (unsigned int)m_data.ulong; 772 case e_slonglong: return (unsigned int)m_data.slonglong; 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; 811 case e_sint: return (unsigned long)m_data.sint; 812 case e_uint: return (unsigned long)m_data.uint; 813 case e_slong: return (unsigned long)m_data.slong; 814 case e_ulong: return (unsigned long)m_data.ulong; 815 case e_slonglong: return (unsigned long)m_data.slonglong; 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; 905 case e_sint: return (unsigned long long)m_data.sint; 906 case e_uint: return (unsigned long long)m_data.uint; 907 case e_slong: return (unsigned long long)m_data.slong; 908 case e_ulong: return (unsigned long long)m_data.ulong; 909 case e_slonglong: return (unsigned long long)m_data.slonglong; 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; 1816 if (value_str == NULL || value_str[0] == '\0') 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) 1834 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str); 1835 else if (!UIntValueIsValidForSize (uval64, byte_size)) 1836 error.SetErrorStringWithFormat ("value 0x%llx is too large to fit in a %u byte unsigned integer value", uval64, byte_size); 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: 1846 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size); 1847 break; 1848 } 1849 } 1850 } 1851 else 1852 { 1853 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %u", byte_size); 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) 1863 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str); 1864 else if (!SIntValueIsValidForSize (sval64, byte_size)) 1865 error.SetErrorStringWithFormat ("value 0x%llx is too large to fit in a %u byte signed integer value", sval64, byte_size); 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: 1875 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size); 1876 break; 1877 } 1878 } 1879 } 1880 else 1881 { 1882 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %u", byte_size); 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 1893 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 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 1900 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 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 1907 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1908 } 1909 else 1910 { 1911 error.SetErrorStringWithFormat ("unsupported float byte size: %u", byte_size); 1912 return error; 1913 } 1914 break; 1915 1916 case eEncodingVector: 1917 error.SetErrorString ("vector encoding unsupported."); 1918 break; 1919 } 1920 if (error.Fail()) 1921 m_type = e_void; 1922 1923 return error; 1924} 1925 1926bool 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; 1965 if (m_data.ulong & sign_bit) 1966 { 1967 const unsigned long mask = ~(sign_bit) + 1ul; 1968 m_data.ulong |= mask; 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; 1981 if (m_data.ulonglong & sign_bit) 1982 { 1983 const unsigned long long mask = ~(sign_bit) + 1ull; 1984 m_data.ulonglong |= mask; 1985 } 1986 return true; 1987 } 1988 break; 1989 } 1990 } 1991 return false; 1992} 1993 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 2022bool 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 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 2263