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