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