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(sint_t)) 527 return e_sint; 528 if (byte_size <= sizeof(slong_t)) 529 return e_slong; 530 if (byte_size <= sizeof(slonglong_t)) 531 return e_slonglong; 532 return e_void; 533} 534 535Scalar::Type 536Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size) 537{ 538 if (byte_size <= sizeof(uint_t)) 539 return e_uint; 540 if (byte_size <= sizeof(ulong_t)) 541 return e_ulong; 542 if (byte_size <= sizeof(ulonglong_t)) 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_t)) 551 return e_float; 552 if (byte_size == sizeof(double_t)) 553 return e_double; 554 if (byte_size == sizeof(long_double_t)) 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 = (sint_t)m_data.slong; success = true; break; 605 case e_uint: m_data.uint = (uint_t)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 = (sint_t)m_data.ulong; success = true; break; 621 case e_uint: m_data.uint = (uint_t)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 = (sint_t)m_data.slonglong; success = true; break; 637 case e_uint: m_data.uint = (uint_t)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 = (sint_t)m_data.ulonglong; success = true; break; 653 case e_uint: m_data.uint = (uint_t)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 = (sint_t)m_data.flt; success = true; break; 669 case e_uint: m_data.uint = (uint_t)m_data.flt; success = true; break; 670 case e_slong: m_data.slong = (slong_t)m_data.flt; success = true; break; 671 case e_ulong: m_data.ulong = (ulong_t)m_data.flt; success = true; break; 672 case e_slonglong: m_data.slonglong = (slonglong_t)m_data.flt; success = true; break; 673 case e_ulonglong: m_data.ulonglong = (ulonglong_t)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 = (sint_t)m_data.dbl; success = true; break; 685 case e_uint: m_data.uint = (uint_t)m_data.dbl; success = true; break; 686 case e_slong: m_data.slong = (slong_t)m_data.dbl; success = true; break; 687 case e_ulong: m_data.ulong = (ulong_t)m_data.dbl; success = true; break; 688 case e_slonglong: m_data.slonglong = (slonglong_t)m_data.dbl; success = true; break; 689 case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.dbl; success = true; break; 690 case e_float: m_data.flt = (float_t)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 = (sint_t)m_data.ldbl; success = true; break; 701 case e_uint: m_data.uint = (uint_t)m_data.ldbl; success = true; break; 702 case e_slong: m_data.slong = (slong_t)m_data.ldbl; success = true; break; 703 case e_ulong: m_data.ulong = (ulong_t)m_data.ldbl; success = true; break; 704 case e_slonglong: m_data.slonglong = (slonglong_t)m_data.ldbl; success = true; break; 705 case e_ulonglong: m_data.ulonglong = (ulonglong_t)m_data.ldbl; success = true; break; 706 case e_float: m_data.flt = (float_t)m_data.ldbl; success = true; break; 707 case e_double: m_data.dbl = (double_t)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 718bool 719Scalar::MakeSigned () 720{ 721 bool success = false; 722 723 switch (m_type) 724 { 725 case e_void: break; 726 case e_sint: success = true; break; 727 case e_uint: m_type = e_sint; success = true; break; 728 case e_slong: success = true; break; 729 case e_ulong: m_type = e_slong; success = true; break; 730 case e_slonglong: success = true; break; 731 case e_ulonglong: m_type = e_slonglong; success = true; break; 732 case e_float: success = true; break; 733 case e_double: success = true; break; 734 case e_long_double: success = true; break; 735 } 736 737 return success; 738} 739 740int 741Scalar::SInt(int fail_value) const 742{ 743 switch (m_type) 744 { 745 case e_void: break; 746 case e_sint: return m_data.sint; 747 case e_uint: return (int)m_data.uint; 748 case e_slong: return (int)m_data.slong; 749 case e_ulong: return (int)m_data.ulong; 750 case e_slonglong: return (int)m_data.slonglong; 751 case e_ulonglong: return (int)m_data.ulonglong; 752 case e_float: return (int)m_data.flt; 753 case e_double: return (int)m_data.dbl; 754 case e_long_double: return (int)m_data.ldbl; 755 } 756 return fail_value; 757} 758 759unsigned int 760Scalar::UInt(unsigned int fail_value) const 761{ 762 switch (m_type) 763 { 764 case e_void: break; 765 case e_sint: return (unsigned int)m_data.sint; 766 case e_uint: return (unsigned int)m_data.uint; 767 case e_slong: return (unsigned int)m_data.slong; 768 case e_ulong: return (unsigned int)m_data.ulong; 769 case e_slonglong: return (unsigned int)m_data.slonglong; 770 case e_ulonglong: return (unsigned int)m_data.ulonglong; 771 case e_float: return (unsigned int)m_data.flt; 772 case e_double: return (unsigned int)m_data.dbl; 773 case e_long_double: return (unsigned int)m_data.ldbl; 774 } 775 return fail_value; 776} 777 778 779long 780Scalar::SLong(long fail_value) const 781{ 782 switch (m_type) 783 { 784 case e_void: break; 785 case e_sint: return (long)m_data.sint; 786 case e_uint: return (long)m_data.uint; 787 case e_slong: return (long)m_data.slong; 788 case e_ulong: return (long)m_data.ulong; 789 case e_slonglong: return (long)m_data.slonglong; 790 case e_ulonglong: return (long)m_data.ulonglong; 791 case e_float: return (long)m_data.flt; 792 case e_double: return (long)m_data.dbl; 793 case e_long_double: return (long)m_data.ldbl; 794 } 795 return fail_value; 796} 797 798 799 800unsigned long 801Scalar::ULong(unsigned long fail_value) const 802{ 803 switch (m_type) 804 { 805 case e_void: break; 806 case e_sint: return (unsigned long)m_data.sint; 807 case e_uint: return (unsigned long)m_data.uint; 808 case e_slong: return (unsigned long)m_data.slong; 809 case e_ulong: return (unsigned long)m_data.ulong; 810 case e_slonglong: return (unsigned long)m_data.slonglong; 811 case e_ulonglong: return (unsigned long)m_data.ulonglong; 812 case e_float: return (unsigned long)m_data.flt; 813 case e_double: return (unsigned long)m_data.dbl; 814 case e_long_double: return (unsigned long)m_data.ldbl; 815 } 816 return fail_value; 817} 818 819uint64_t 820Scalar::GetRawBits64(uint64_t fail_value) const 821{ 822 switch (m_type) 823 { 824 case e_void: 825 break; 826 827 case e_sint: 828 case e_uint: 829 return m_data.uint; 830 831 case e_slong: 832 case e_ulong: 833 return m_data.ulong; 834 835 case e_slonglong: 836 case e_ulonglong: 837 return m_data.ulonglong; 838 839 case e_float: 840 if (sizeof(m_data.flt) == sizeof(m_data.uint)) 841 return m_data.uint; 842 else if (sizeof(m_data.flt) == sizeof(m_data.ulong)) 843 return m_data.ulong; 844 else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong)) 845 return m_data.ulonglong; 846 break; 847 848 case e_double: 849 if (sizeof(m_data.dbl) == sizeof(m_data.uint)) 850 return m_data.uint; 851 else if (sizeof(m_data.dbl) == sizeof(m_data.ulong)) 852 return m_data.ulong; 853 else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong)) 854 return m_data.ulonglong; 855 break; 856 857 case e_long_double: 858 if (sizeof(m_data.ldbl) == sizeof(m_data.uint)) 859 return m_data.uint; 860 else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong)) 861 return m_data.ulong; 862 else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong)) 863 return m_data.ulonglong; 864 break; 865 } 866 return fail_value; 867} 868 869 870 871long long 872Scalar::SLongLong(long long fail_value) const 873{ 874 switch (m_type) 875 { 876 case e_void: break; 877 case e_sint: return (long long)m_data.sint; 878 case e_uint: return (long long)m_data.uint; 879 case e_slong: return (long long)m_data.slong; 880 case e_ulong: return (long long)m_data.ulong; 881 case e_slonglong: return (long long)m_data.slonglong; 882 case e_ulonglong: return (long long)m_data.ulonglong; 883 case e_float: return (long long)m_data.flt; 884 case e_double: return (long long)m_data.dbl; 885 case e_long_double: return (long long)m_data.ldbl; 886 } 887 return fail_value; 888} 889 890 891unsigned long long 892Scalar::ULongLong(unsigned long long fail_value) const 893{ 894 switch (m_type) 895 { 896 case e_void: break; 897 case e_sint: return (unsigned long long)m_data.sint; 898 case e_uint: return (unsigned long long)m_data.uint; 899 case e_slong: return (unsigned long long)m_data.slong; 900 case e_ulong: return (unsigned long long)m_data.ulong; 901 case e_slonglong: return (unsigned long long)m_data.slonglong; 902 case e_ulonglong: return (unsigned long long)m_data.ulonglong; 903 case e_float: return (unsigned long long)m_data.flt; 904 case e_double: return (unsigned long long)m_data.dbl; 905 case e_long_double: return (unsigned long long)m_data.ldbl; 906 } 907 return fail_value; 908} 909 910 911float 912Scalar::Float(float fail_value) const 913{ 914 switch (m_type) 915 { 916 case e_void: break; 917 case e_sint: return (float)m_data.sint; 918 case e_uint: return (float)m_data.uint; 919 case e_slong: return (float)m_data.slong; 920 case e_ulong: return (float)m_data.ulong; 921 case e_slonglong: return (float)m_data.slonglong; 922 case e_ulonglong: return (float)m_data.ulonglong; 923 case e_float: return (float)m_data.flt; 924 case e_double: return (float)m_data.dbl; 925 case e_long_double: return (float)m_data.ldbl; 926 } 927 return fail_value; 928} 929 930 931double 932Scalar::Double(double fail_value) const 933{ 934 switch (m_type) 935 { 936 case e_void: break; 937 case e_sint: return (double)m_data.sint; 938 case e_uint: return (double)m_data.uint; 939 case e_slong: return (double)m_data.slong; 940 case e_ulong: return (double)m_data.ulong; 941 case e_slonglong: return (double)m_data.slonglong; 942 case e_ulonglong: return (double)m_data.ulonglong; 943 case e_float: return (double)m_data.flt; 944 case e_double: return (double)m_data.dbl; 945 case e_long_double: return (double)m_data.ldbl; 946 } 947 return fail_value; 948} 949 950 951long double 952Scalar::LongDouble(long double fail_value) const 953{ 954 switch (m_type) 955 { 956 case e_void: break; 957 case e_sint: return (long double)m_data.sint; 958 case e_uint: return (long double)m_data.uint; 959 case e_slong: return (long double)m_data.slong; 960 case e_ulong: return (long double)m_data.ulong; 961 case e_slonglong: return (long double)m_data.slonglong; 962 case e_ulonglong: return (long double)m_data.ulonglong; 963 case e_float: return (long double)m_data.flt; 964 case e_double: return (long double)m_data.dbl; 965 case e_long_double: return (long double)m_data.ldbl; 966 } 967 return fail_value; 968} 969 970 971Scalar& 972Scalar::operator+= (const Scalar& rhs) 973{ 974 Scalar temp_value; 975 const Scalar* a; 976 const Scalar* b; 977 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void) 978 { 979 switch (m_type) 980 { 981 case e_void: break; 982 case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break; 983 case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break; 984 case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break; 985 case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; 986 case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; 987 case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; 988 case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break; 989 case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; 990 case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; 991 } 992 } 993 return *this; 994} 995 996Scalar& 997Scalar::operator<<= (const Scalar& rhs) 998{ 999 switch (m_type) 1000 { 1001 case e_void: 1002 case e_float: 1003 case e_double: 1004 case e_long_double: 1005 m_type = e_void; 1006 break; 1007 1008 case e_sint: 1009 switch (rhs.m_type) 1010 { 1011 case e_void: 1012 case e_float: 1013 case e_double: 1014 case e_long_double: 1015 m_type = e_void; 1016 break; 1017 case e_sint: m_data.sint <<= rhs.m_data.sint; break; 1018 case e_uint: m_data.sint <<= rhs.m_data.uint; break; 1019 case e_slong: m_data.sint <<= rhs.m_data.slong; break; 1020 case e_ulong: m_data.sint <<= rhs.m_data.ulong; break; 1021 case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break; 1022 case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break; 1023 } 1024 break; 1025 1026 case e_uint: 1027 switch (rhs.m_type) 1028 { 1029 case e_void: 1030 case e_float: 1031 case e_double: 1032 case e_long_double: 1033 m_type = e_void; 1034 break; 1035 case e_sint: m_data.uint <<= rhs.m_data.sint; break; 1036 case e_uint: m_data.uint <<= rhs.m_data.uint; break; 1037 case e_slong: m_data.uint <<= rhs.m_data.slong; break; 1038 case e_ulong: m_data.uint <<= rhs.m_data.ulong; break; 1039 case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break; 1040 case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break; 1041 } 1042 break; 1043 1044 case e_slong: 1045 switch (rhs.m_type) 1046 { 1047 case e_void: 1048 case e_float: 1049 case e_double: 1050 case e_long_double: 1051 m_type = e_void; 1052 break; 1053 case e_sint: m_data.slong <<= rhs.m_data.sint; break; 1054 case e_uint: m_data.slong <<= rhs.m_data.uint; break; 1055 case e_slong: m_data.slong <<= rhs.m_data.slong; break; 1056 case e_ulong: m_data.slong <<= rhs.m_data.ulong; break; 1057 case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break; 1058 case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break; 1059 } 1060 break; 1061 1062 case e_ulong: 1063 switch (rhs.m_type) 1064 { 1065 case e_void: 1066 case e_float: 1067 case e_double: 1068 case e_long_double: 1069 m_type = e_void; 1070 break; 1071 case e_sint: m_data.ulong <<= rhs.m_data.sint; break; 1072 case e_uint: m_data.ulong <<= rhs.m_data.uint; break; 1073 case e_slong: m_data.ulong <<= rhs.m_data.slong; break; 1074 case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break; 1075 case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break; 1076 case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break; 1077 } 1078 break; 1079 case e_slonglong: 1080 switch (rhs.m_type) 1081 { 1082 case e_void: 1083 case e_float: 1084 case e_double: 1085 case e_long_double: 1086 m_type = e_void; 1087 break; 1088 case e_sint: m_data.slonglong <<= rhs.m_data.sint; break; 1089 case e_uint: m_data.slonglong <<= rhs.m_data.uint; break; 1090 case e_slong: m_data.slonglong <<= rhs.m_data.slong; break; 1091 case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break; 1092 case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break; 1093 case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break; 1094 } 1095 break; 1096 1097 case e_ulonglong: 1098 switch (rhs.m_type) 1099 { 1100 case e_void: 1101 case e_float: 1102 case e_double: 1103 case e_long_double: 1104 m_type = e_void; 1105 break; 1106 case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break; 1107 case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break; 1108 case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break; 1109 case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break; 1110 case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break; 1111 case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break; 1112 } 1113 break; 1114 } 1115 return *this; 1116} 1117 1118bool 1119Scalar::ShiftRightLogical(const Scalar& rhs) 1120{ 1121 switch (m_type) 1122 { 1123 case e_void: 1124 case e_float: 1125 case e_double: 1126 case e_long_double: 1127 m_type = e_void; 1128 break; 1129 1130 case e_sint: 1131 case e_uint: 1132 switch (rhs.m_type) 1133 { 1134 case e_void: 1135 case e_float: 1136 case e_double: 1137 case e_long_double: 1138 m_type = e_void; 1139 break; 1140 case e_sint: m_data.uint >>= rhs.m_data.sint; break; 1141 case e_uint: m_data.uint >>= rhs.m_data.uint; break; 1142 case e_slong: m_data.uint >>= rhs.m_data.slong; break; 1143 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; 1144 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; 1145 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; 1146 } 1147 break; 1148 1149 case e_slong: 1150 case e_ulong: 1151 switch (rhs.m_type) 1152 { 1153 case e_void: 1154 case e_float: 1155 case e_double: 1156 case e_long_double: 1157 m_type = e_void; 1158 break; 1159 case e_sint: m_data.ulong >>= rhs.m_data.sint; break; 1160 case e_uint: m_data.ulong >>= rhs.m_data.uint; break; 1161 case e_slong: m_data.ulong >>= rhs.m_data.slong; break; 1162 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; 1163 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; 1164 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; 1165 } 1166 break; 1167 1168 case e_slonglong: 1169 case e_ulonglong: 1170 switch (rhs.m_type) 1171 { 1172 case e_void: 1173 case e_float: 1174 case e_double: 1175 case e_long_double: 1176 m_type = e_void; 1177 break; 1178 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; 1179 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; 1180 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; 1181 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; 1182 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; 1183 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; 1184 } 1185 break; 1186 } 1187 return m_type != e_void; 1188} 1189 1190 1191Scalar& 1192Scalar::operator>>= (const Scalar& rhs) 1193{ 1194 switch (m_type) 1195 { 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 1203 case e_sint: 1204 switch (rhs.m_type) 1205 { 1206 case e_void: 1207 case e_float: 1208 case e_double: 1209 case e_long_double: 1210 m_type = e_void; 1211 break; 1212 case e_sint: m_data.sint >>= rhs.m_data.sint; break; 1213 case e_uint: m_data.sint >>= rhs.m_data.uint; break; 1214 case e_slong: m_data.sint >>= rhs.m_data.slong; break; 1215 case e_ulong: m_data.sint >>= rhs.m_data.ulong; break; 1216 case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break; 1217 case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break; 1218 } 1219 break; 1220 1221 case e_uint: 1222 switch (rhs.m_type) 1223 { 1224 case e_void: 1225 case e_float: 1226 case e_double: 1227 case e_long_double: 1228 m_type = e_void; 1229 break; 1230 case e_sint: m_data.uint >>= rhs.m_data.sint; break; 1231 case e_uint: m_data.uint >>= rhs.m_data.uint; break; 1232 case e_slong: m_data.uint >>= rhs.m_data.slong; break; 1233 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break; 1234 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break; 1235 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break; 1236 } 1237 break; 1238 1239 case e_slong: 1240 switch (rhs.m_type) 1241 { 1242 case e_void: 1243 case e_float: 1244 case e_double: 1245 case e_long_double: 1246 m_type = e_void; 1247 break; 1248 case e_sint: m_data.slong >>= rhs.m_data.sint; break; 1249 case e_uint: m_data.slong >>= rhs.m_data.uint; break; 1250 case e_slong: m_data.slong >>= rhs.m_data.slong; break; 1251 case e_ulong: m_data.slong >>= rhs.m_data.ulong; break; 1252 case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break; 1253 case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break; 1254 } 1255 break; 1256 1257 case e_ulong: 1258 switch (rhs.m_type) 1259 { 1260 case e_void: 1261 case e_float: 1262 case e_double: 1263 case e_long_double: 1264 m_type = e_void; 1265 break; 1266 case e_sint: m_data.ulong >>= rhs.m_data.sint; break; 1267 case e_uint: m_data.ulong >>= rhs.m_data.uint; break; 1268 case e_slong: m_data.ulong >>= rhs.m_data.slong; break; 1269 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break; 1270 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break; 1271 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break; 1272 } 1273 break; 1274 case e_slonglong: 1275 switch (rhs.m_type) 1276 { 1277 case e_void: 1278 case e_float: 1279 case e_double: 1280 case e_long_double: 1281 m_type = e_void; 1282 break; 1283 case e_sint: m_data.slonglong >>= rhs.m_data.sint; break; 1284 case e_uint: m_data.slonglong >>= rhs.m_data.uint; break; 1285 case e_slong: m_data.slonglong >>= rhs.m_data.slong; break; 1286 case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break; 1287 case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break; 1288 case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break; 1289 } 1290 break; 1291 1292 case e_ulonglong: 1293 switch (rhs.m_type) 1294 { 1295 case e_void: 1296 case e_float: 1297 case e_double: 1298 case e_long_double: 1299 m_type = e_void; 1300 break; 1301 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break; 1302 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break; 1303 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break; 1304 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break; 1305 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break; 1306 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break; 1307 } 1308 break; 1309 } 1310 return *this; 1311} 1312 1313 1314Scalar& 1315Scalar::operator&= (const Scalar& rhs) 1316{ 1317 switch (m_type) 1318 { 1319 case e_void: 1320 case e_float: 1321 case e_double: 1322 case e_long_double: 1323 m_type = e_void; 1324 break; 1325 1326 case e_sint: 1327 switch (rhs.m_type) 1328 { 1329 case e_void: 1330 case e_float: 1331 case e_double: 1332 case e_long_double: 1333 m_type = e_void; 1334 break; 1335 case e_sint: m_data.sint &= rhs.m_data.sint; break; 1336 case e_uint: m_data.sint &= rhs.m_data.uint; break; 1337 case e_slong: m_data.sint &= rhs.m_data.slong; break; 1338 case e_ulong: m_data.sint &= rhs.m_data.ulong; break; 1339 case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break; 1340 case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break; 1341 } 1342 break; 1343 1344 case e_uint: 1345 switch (rhs.m_type) 1346 { 1347 case e_void: 1348 case e_float: 1349 case e_double: 1350 case e_long_double: 1351 m_type = e_void; 1352 break; 1353 case e_sint: m_data.uint &= rhs.m_data.sint; break; 1354 case e_uint: m_data.uint &= rhs.m_data.uint; break; 1355 case e_slong: m_data.uint &= rhs.m_data.slong; break; 1356 case e_ulong: m_data.uint &= rhs.m_data.ulong; break; 1357 case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break; 1358 case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break; 1359 } 1360 break; 1361 1362 case e_slong: 1363 switch (rhs.m_type) 1364 { 1365 case e_void: 1366 case e_float: 1367 case e_double: 1368 case e_long_double: 1369 m_type = e_void; 1370 break; 1371 case e_sint: m_data.slong &= rhs.m_data.sint; break; 1372 case e_uint: m_data.slong &= rhs.m_data.uint; break; 1373 case e_slong: m_data.slong &= rhs.m_data.slong; break; 1374 case e_ulong: m_data.slong &= rhs.m_data.ulong; break; 1375 case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break; 1376 case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break; 1377 } 1378 break; 1379 1380 case e_ulong: 1381 switch (rhs.m_type) 1382 { 1383 case e_void: 1384 case e_float: 1385 case e_double: 1386 case e_long_double: 1387 m_type = e_void; 1388 break; 1389 case e_sint: m_data.ulong &= rhs.m_data.sint; break; 1390 case e_uint: m_data.ulong &= rhs.m_data.uint; break; 1391 case e_slong: m_data.ulong &= rhs.m_data.slong; break; 1392 case e_ulong: m_data.ulong &= rhs.m_data.ulong; break; 1393 case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break; 1394 case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break; 1395 } 1396 break; 1397 case e_slonglong: 1398 switch (rhs.m_type) 1399 { 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.slonglong &= rhs.m_data.sint; break; 1407 case e_uint: m_data.slonglong &= rhs.m_data.uint; break; 1408 case e_slong: m_data.slonglong &= rhs.m_data.slong; break; 1409 case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break; 1410 case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break; 1411 case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break; 1412 } 1413 break; 1414 1415 case e_ulonglong: 1416 switch (rhs.m_type) 1417 { 1418 case e_void: 1419 case e_float: 1420 case e_double: 1421 case e_long_double: 1422 m_type = e_void; 1423 break; 1424 case e_sint: m_data.ulonglong &= rhs.m_data.sint; break; 1425 case e_uint: m_data.ulonglong &= rhs.m_data.uint; break; 1426 case e_slong: m_data.ulonglong &= rhs.m_data.slong; break; 1427 case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break; 1428 case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break; 1429 case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break; 1430 } 1431 break; 1432 } 1433 return *this; 1434} 1435 1436 1437 1438bool 1439Scalar::AbsoluteValue() 1440{ 1441 switch (m_type) 1442 { 1443 case e_void: 1444 break; 1445 1446 case e_sint: 1447 if (m_data.sint < 0) 1448 m_data.sint = -m_data.sint; 1449 return true; 1450 1451 case e_slong: 1452 if (m_data.slong < 0) 1453 m_data.slong = -m_data.slong; 1454 return true; 1455 1456 case e_slonglong: 1457 if (m_data.slonglong < 0) 1458 m_data.slonglong = -m_data.slonglong; 1459 return true; 1460 1461 case e_uint: 1462 case e_ulong: 1463 case e_ulonglong: return true; 1464 case e_float: m_data.flt = fabsf(m_data.flt); return true; 1465 case e_double: m_data.dbl = fabs(m_data.dbl); return true; 1466 case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true; 1467 } 1468 return false; 1469} 1470 1471 1472bool 1473Scalar::UnaryNegate() 1474{ 1475 switch (m_type) 1476 { 1477 case e_void: break; 1478 case e_sint: m_data.sint = -m_data.sint; return true; 1479 case e_uint: m_data.uint = -m_data.uint; return true; 1480 case e_slong: m_data.slong = -m_data.slong; return true; 1481 case e_ulong: m_data.ulong = -m_data.ulong; return true; 1482 case e_slonglong: m_data.slonglong = -m_data.slonglong; return true; 1483 case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true; 1484 case e_float: m_data.flt = -m_data.flt; return true; 1485 case e_double: m_data.dbl = -m_data.dbl; return true; 1486 case e_long_double: m_data.ldbl = -m_data.ldbl; return true; 1487 } 1488 return false; 1489} 1490 1491bool 1492Scalar::OnesComplement() 1493{ 1494 switch (m_type) 1495 { 1496 case e_sint: m_data.sint = ~m_data.sint; return true; 1497 case e_uint: m_data.uint = ~m_data.uint; return true; 1498 case e_slong: m_data.slong = ~m_data.slong; return true; 1499 case e_ulong: m_data.ulong = ~m_data.ulong; return true; 1500 case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true; 1501 case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true; 1502 1503 case e_void: 1504 case e_float: 1505 case e_double: 1506 case e_long_double: 1507 break; 1508 } 1509 return false; 1510} 1511 1512 1513const Scalar 1514lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs) 1515{ 1516 Scalar result; 1517 Scalar temp_value; 1518 const Scalar* a; 1519 const Scalar* b; 1520 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1521 { 1522 switch (result.m_type) 1523 { 1524 case Scalar::e_void: break; 1525 case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break; 1526 case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break; 1527 case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break; 1528 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break; 1529 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break; 1530 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break; 1531 case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break; 1532 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break; 1533 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break; 1534 } 1535 } 1536 return result; 1537} 1538 1539 1540const Scalar 1541lldb_private::operator- (const Scalar& lhs, const Scalar& rhs) 1542{ 1543 Scalar result; 1544 Scalar temp_value; 1545 const Scalar* a; 1546 const Scalar* b; 1547 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1548 { 1549 switch (result.m_type) 1550 { 1551 case Scalar::e_void: break; 1552 case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break; 1553 case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break; 1554 case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break; 1555 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break; 1556 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break; 1557 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break; 1558 case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break; 1559 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break; 1560 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break; 1561 } 1562 } 1563 return result; 1564} 1565 1566const Scalar 1567lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs) 1568{ 1569 Scalar result; 1570 Scalar temp_value; 1571 const Scalar* a; 1572 const Scalar* b; 1573 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1574 { 1575 switch (result.m_type) 1576 { 1577 case Scalar::e_void: break; 1578 1579 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; 1580 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; 1581 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; 1582 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; 1583 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; 1584 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; 1585 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; 1586 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; 1587 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; 1588 } 1589 } 1590 // For division only, the only way it should make it here is if a promotion failed, 1591 // or if we are trying to do a divide by zero. 1592 result.m_type = Scalar::e_void; 1593 return result; 1594} 1595 1596const Scalar 1597lldb_private::operator* (const Scalar& lhs, const Scalar& rhs) 1598{ 1599 Scalar result; 1600 Scalar temp_value; 1601 const Scalar* a; 1602 const Scalar* b; 1603 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1604 { 1605 switch (result.m_type) 1606 { 1607 case Scalar::e_void: break; 1608 case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break; 1609 case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break; 1610 case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break; 1611 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break; 1612 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break; 1613 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break; 1614 case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break; 1615 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break; 1616 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break; 1617 } 1618 } 1619 return result; 1620} 1621 1622const Scalar 1623lldb_private::operator& (const Scalar& lhs, const Scalar& rhs) 1624{ 1625 Scalar result; 1626 Scalar temp_value; 1627 const Scalar* a; 1628 const Scalar* b; 1629 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1630 { 1631 switch (result.m_type) 1632 { 1633 case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break; 1634 case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break; 1635 case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break; 1636 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break; 1637 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break; 1638 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break; 1639 1640 case Scalar::e_void: 1641 case Scalar::e_float: 1642 case Scalar::e_double: 1643 case Scalar::e_long_double: 1644 // No bitwise AND on floats, doubles of long doubles 1645 result.m_type = Scalar::e_void; 1646 break; 1647 } 1648 } 1649 return result; 1650} 1651 1652const Scalar 1653lldb_private::operator| (const Scalar& lhs, const Scalar& rhs) 1654{ 1655 Scalar result; 1656 Scalar temp_value; 1657 const Scalar* a; 1658 const Scalar* b; 1659 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1660 { 1661 switch (result.m_type) 1662 { 1663 case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break; 1664 case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break; 1665 case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break; 1666 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break; 1667 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break; 1668 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break; 1669 1670 case Scalar::e_void: 1671 case Scalar::e_float: 1672 case Scalar::e_double: 1673 case Scalar::e_long_double: 1674 // No bitwise AND on floats, doubles of long doubles 1675 result.m_type = Scalar::e_void; 1676 break; 1677 } 1678 } 1679 return result; 1680} 1681 1682const Scalar 1683lldb_private::operator% (const Scalar& lhs, const Scalar& rhs) 1684{ 1685 Scalar result; 1686 Scalar temp_value; 1687 const Scalar* a; 1688 const Scalar* b; 1689 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1690 { 1691 switch (result.m_type) 1692 { 1693 default: break; 1694 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; 1695 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; 1696 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; 1697 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; 1698 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; 1699 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; 1700 } 1701 } 1702 result.m_type = Scalar::e_void; 1703 return result; 1704} 1705 1706const Scalar 1707lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs) 1708{ 1709 Scalar result; 1710 Scalar temp_value; 1711 const Scalar* a; 1712 const Scalar* b; 1713 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void) 1714 { 1715 switch (result.m_type) 1716 { 1717 case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break; 1718 case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break; 1719 case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break; 1720 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break; 1721 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break; 1722 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break; 1723 1724 case Scalar::e_void: 1725 case Scalar::e_float: 1726 case Scalar::e_double: 1727 case Scalar::e_long_double: 1728 // No bitwise AND on floats, doubles of long doubles 1729 result.m_type = Scalar::e_void; 1730 break; 1731 } 1732 } 1733 return result; 1734} 1735 1736const Scalar 1737lldb_private::operator<< (const Scalar& lhs, const Scalar &rhs) 1738{ 1739 Scalar result = lhs; 1740 result <<= rhs; 1741 return result; 1742} 1743 1744const Scalar 1745lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs) 1746{ 1747 Scalar result = lhs; 1748 result >>= rhs; 1749 return result; 1750} 1751 1752// Return the raw unsigned integer without any casting or conversion 1753unsigned int 1754Scalar::RawUInt () const 1755{ 1756 return m_data.uint; 1757} 1758 1759// Return the raw unsigned long without any casting or conversion 1760unsigned long 1761Scalar::RawULong () const 1762{ 1763 return m_data.ulong; 1764} 1765 1766// Return the raw unsigned long long without any casting or conversion 1767unsigned long long 1768Scalar::RawULongLong () const 1769{ 1770 return m_data.ulonglong; 1771} 1772 1773 1774Error 1775Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size) 1776{ 1777 Error error; 1778 if (value_str == NULL || value_str[0] == '\0') 1779 { 1780 error.SetErrorString ("Invalid c-string value string."); 1781 return error; 1782 } 1783 bool success = false; 1784 switch (encoding) 1785 { 1786 case eEncodingInvalid: 1787 error.SetErrorString ("Invalid encoding."); 1788 break; 1789 1790 case eEncodingUint: 1791 if (byte_size <= sizeof (unsigned long long)) 1792 { 1793 uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success); 1794 if (!success) 1795 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str); 1796 else if (!UIntValueIsValidForSize (uval64, byte_size)) 1797 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte unsigned integer value", uval64, byte_size); 1798 else 1799 { 1800 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size); 1801 switch (m_type) 1802 { 1803 case e_uint: m_data.uint = (uint_t)uval64; break; 1804 case e_ulong: m_data.ulong = (ulong_t)uval64; break; 1805 case e_ulonglong: m_data.ulonglong = (ulonglong_t)uval64; break; 1806 default: 1807 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size); 1808 break; 1809 } 1810 } 1811 } 1812 else 1813 { 1814 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size); 1815 return error; 1816 } 1817 break; 1818 1819 case eEncodingSint: 1820 if (byte_size <= sizeof (long long)) 1821 { 1822 uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success); 1823 if (!success) 1824 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str); 1825 else if (!SIntValueIsValidForSize (sval64, byte_size)) 1826 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte signed integer value", sval64, byte_size); 1827 else 1828 { 1829 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size); 1830 switch (m_type) 1831 { 1832 case e_sint: m_data.sint = (sint_t)sval64; break; 1833 case e_slong: m_data.slong = (slong_t)sval64; break; 1834 case e_slonglong: m_data.slonglong = (slonglong_t)sval64; break; 1835 default: 1836 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size); 1837 break; 1838 } 1839 } 1840 } 1841 else 1842 { 1843 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size); 1844 return error; 1845 } 1846 break; 1847 1848 case eEncodingIEEE754: 1849 if (byte_size == sizeof (float)) 1850 { 1851 if (::sscanf (value_str, "%f", &m_data.flt) == 1) 1852 m_type = e_float; 1853 else 1854 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1855 } 1856 else if (byte_size == sizeof (double)) 1857 { 1858 if (::sscanf (value_str, "%lf", &m_data.dbl) == 1) 1859 m_type = e_double; 1860 else 1861 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1862 } 1863 else if (byte_size == sizeof (long double)) 1864 { 1865 if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1) 1866 m_type = e_long_double; 1867 else 1868 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str); 1869 } 1870 else 1871 { 1872 error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size); 1873 return error; 1874 } 1875 break; 1876 1877 case eEncodingVector: 1878 error.SetErrorString ("vector encoding unsupported."); 1879 break; 1880 } 1881 if (error.Fail()) 1882 m_type = e_void; 1883 1884 return error; 1885} 1886 1887Error 1888Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size) 1889{ 1890 Error error; 1891 1892 switch (encoding) 1893 { 1894 case lldb::eEncodingInvalid: 1895 error.SetErrorString ("invalid encoding"); 1896 break; 1897 case lldb::eEncodingVector: 1898 error.SetErrorString ("vector encoding unsupported"); 1899 break; 1900 case lldb::eEncodingUint: 1901 { 1902 lldb::offset_t offset; 1903 1904 switch (byte_size) 1905 { 1906 case 1: operator=((uint8_t)data.GetU8(&offset)); break; 1907 case 2: operator=((uint16_t)data.GetU16(&offset)); break; 1908 case 4: operator=((uint32_t)data.GetU32(&offset)); break; 1909 case 8: operator=((uint64_t)data.GetU64(&offset)); break; 1910 default: 1911 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size); 1912 break; 1913 } 1914 } 1915 break; 1916 case lldb::eEncodingSint: 1917 { 1918 lldb::offset_t offset; 1919 1920 switch (byte_size) 1921 { 1922 case 1: operator=((int8_t)data.GetU8(&offset)); break; 1923 case 2: operator=((int16_t)data.GetU16(&offset)); break; 1924 case 4: operator=((int32_t)data.GetU32(&offset)); break; 1925 case 8: operator=((int64_t)data.GetU64(&offset)); break; 1926 default: 1927 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size); 1928 break; 1929 } 1930 } 1931 break; 1932 case lldb::eEncodingIEEE754: 1933 { 1934 lldb::offset_t offset; 1935 1936 if (byte_size == sizeof (float)) 1937 operator=((float)data.GetFloat(&offset)); 1938 else if (byte_size == sizeof (double)) 1939 operator=((double)data.GetDouble(&offset)); 1940 else if (byte_size == sizeof (long double)) 1941 operator=((long double)data.GetLongDouble(&offset)); 1942 else 1943 error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size); 1944 } 1945 break; 1946 } 1947 1948 return error; 1949} 1950 1951bool 1952Scalar::SignExtend (uint32_t sign_bit_pos) 1953{ 1954 const uint32_t max_bit_pos = GetByteSize() * 8; 1955 1956 if (sign_bit_pos < max_bit_pos) 1957 { 1958 switch (m_type) 1959 { 1960 case Scalar::e_void: 1961 case Scalar::e_float: 1962 case Scalar::e_double: 1963 case Scalar::e_long_double: 1964 return false; 1965 1966 case Scalar::e_sint: 1967 case Scalar::e_uint: 1968 if (max_bit_pos == sign_bit_pos) 1969 return true; 1970 else if (sign_bit_pos < (max_bit_pos-1)) 1971 { 1972 unsigned int sign_bit = 1u << sign_bit_pos; 1973 if (m_data.uint & sign_bit) 1974 { 1975 const unsigned int mask = ~(sign_bit) + 1u; 1976 m_data.uint |= mask; 1977 } 1978 return true; 1979 } 1980 break; 1981 1982 case Scalar::e_slong: 1983 case Scalar::e_ulong: 1984 if (max_bit_pos == sign_bit_pos) 1985 return true; 1986 else if (sign_bit_pos < (max_bit_pos-1)) 1987 { 1988 unsigned long sign_bit = 1ul << sign_bit_pos; 1989 if (m_data.ulong & sign_bit) 1990 { 1991 const unsigned long mask = ~(sign_bit) + 1ul; 1992 m_data.ulong |= mask; 1993 } 1994 return true; 1995 } 1996 break; 1997 1998 case Scalar::e_slonglong: 1999 case Scalar::e_ulonglong: 2000 if (max_bit_pos == sign_bit_pos) 2001 return true; 2002 else if (sign_bit_pos < (max_bit_pos-1)) 2003 { 2004 unsigned long long sign_bit = 1ull << sign_bit_pos; 2005 if (m_data.ulonglong & sign_bit) 2006 { 2007 const unsigned long long mask = ~(sign_bit) + 1ull; 2008 m_data.ulonglong |= mask; 2009 } 2010 return true; 2011 } 2012 break; 2013 } 2014 } 2015 return false; 2016} 2017 2018size_t 2019Scalar::GetAsMemoryData (void *dst, 2020 size_t dst_len, 2021 lldb::ByteOrder dst_byte_order, 2022 Error &error) const 2023{ 2024 // Get a data extractor that points to the native scalar data 2025 DataExtractor data; 2026 if (!GetData(data)) 2027 { 2028 error.SetErrorString ("invalid scalar value"); 2029 return 0; 2030 } 2031 2032 const size_t src_len = data.GetByteSize(); 2033 2034 // Prepare a memory buffer that contains some or all of the register value 2035 const size_t bytes_copied = data.CopyByteOrderedData (0, // src offset 2036 src_len, // src length 2037 dst, // dst buffer 2038 dst_len, // dst length 2039 dst_byte_order); // dst byte order 2040 if (bytes_copied == 0) 2041 error.SetErrorString ("failed to copy data"); 2042 2043 return bytes_copied; 2044} 2045 2046bool 2047Scalar::ExtractBitfield (uint32_t bit_size, 2048 uint32_t bit_offset) 2049{ 2050 if (bit_size == 0) 2051 return true; 2052 2053 uint32_t msbit = bit_offset + bit_size - 1; 2054 uint32_t lsbit = bit_offset; 2055 switch (m_type) 2056 { 2057 case Scalar::e_void: 2058 break; 2059 2060 case e_float: 2061 if (sizeof(m_data.flt) == sizeof(sint_t)) 2062 m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit); 2063 else if (sizeof(m_data.flt) == sizeof(ulong_t)) 2064 m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit); 2065 else if (sizeof(m_data.flt) == sizeof(ulonglong_t)) 2066 m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit); 2067 else 2068 return false; 2069 return true; 2070 2071 case e_double: 2072 if (sizeof(m_data.dbl) == sizeof(sint_t)) 2073 m_data.sint = SignedBits (m_data.sint, msbit, lsbit); 2074 else if (sizeof(m_data.dbl) == sizeof(ulong_t)) 2075 m_data.slong = SignedBits (m_data.slong, msbit, lsbit); 2076 else if (sizeof(m_data.dbl) == sizeof(ulonglong_t)) 2077 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit); 2078 else 2079 return false; 2080 return true; 2081 2082 case e_long_double: 2083 if (sizeof(m_data.ldbl) == sizeof(sint_t)) 2084 m_data.sint = SignedBits (m_data.sint, msbit, lsbit); 2085 else if (sizeof(m_data.ldbl) == sizeof(ulong_t)) 2086 m_data.slong = SignedBits (m_data.slong, msbit, lsbit); 2087 else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t)) 2088 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit); 2089 else 2090 return false; 2091 return true; 2092 2093 case Scalar::e_sint: 2094 m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit); 2095 return true; 2096 2097 case Scalar::e_uint: 2098 m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit); 2099 return true; 2100 2101 case Scalar::e_slong: 2102 m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit); 2103 return true; 2104 2105 case Scalar::e_ulong: 2106 m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit); 2107 return true; 2108 2109 case Scalar::e_slonglong: 2110 m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit); 2111 return true; 2112 2113 case Scalar::e_ulonglong: 2114 m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit); 2115 return true; 2116 } 2117 return false; 2118} 2119 2120 2121 2122 2123 2124bool 2125lldb_private::operator== (const Scalar& lhs, const Scalar& rhs) 2126{ 2127 // If either entry is void then we can just compare the types 2128 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2129 return lhs.m_type == rhs.m_type; 2130 2131 Scalar temp_value; 2132 const Scalar* a; 2133 const Scalar* b; 2134 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2135 { 2136 case Scalar::e_void: break; 2137 case Scalar::e_sint: return a->m_data.sint == b->m_data.sint; 2138 case Scalar::e_uint: return a->m_data.uint == b->m_data.uint; 2139 case Scalar::e_slong: return a->m_data.slong == b->m_data.slong; 2140 case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong; 2141 case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong; 2142 case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong; 2143 case Scalar::e_float: return a->m_data.flt == b->m_data.flt; 2144 case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl; 2145 case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl; 2146 } 2147 return false; 2148} 2149 2150bool 2151lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs) 2152{ 2153 // If either entry is void then we can just compare the types 2154 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2155 return lhs.m_type != rhs.m_type; 2156 2157 Scalar temp_value; // A temp value that might get a copy of either promoted value 2158 const Scalar* a; 2159 const Scalar* b; 2160 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2161 { 2162 case Scalar::e_void: break; 2163 case Scalar::e_sint: return a->m_data.sint != b->m_data.sint; 2164 case Scalar::e_uint: return a->m_data.uint != b->m_data.uint; 2165 case Scalar::e_slong: return a->m_data.slong != b->m_data.slong; 2166 case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong; 2167 case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong; 2168 case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong; 2169 case Scalar::e_float: return a->m_data.flt != b->m_data.flt; 2170 case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl; 2171 case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl; 2172 } 2173 return true; 2174} 2175 2176bool 2177lldb_private::operator< (const Scalar& lhs, const Scalar& rhs) 2178{ 2179 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2180 return false; 2181 2182 Scalar temp_value; 2183 const Scalar* a; 2184 const Scalar* b; 2185 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2186 { 2187 case Scalar::e_void: break; 2188 case Scalar::e_sint: return a->m_data.sint < b->m_data.sint; 2189 case Scalar::e_uint: return a->m_data.uint < b->m_data.uint; 2190 case Scalar::e_slong: return a->m_data.slong < b->m_data.slong; 2191 case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong; 2192 case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong; 2193 case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong; 2194 case Scalar::e_float: return a->m_data.flt < b->m_data.flt; 2195 case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl; 2196 case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl; 2197 } 2198 return false; 2199} 2200 2201bool 2202lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs) 2203{ 2204 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2205 return false; 2206 2207 Scalar temp_value; 2208 const Scalar* a; 2209 const Scalar* b; 2210 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2211 { 2212 case Scalar::e_void: break; 2213 case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint; 2214 case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint; 2215 case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong; 2216 case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong; 2217 case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong; 2218 case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong; 2219 case Scalar::e_float: return a->m_data.flt <= b->m_data.flt; 2220 case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl; 2221 case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl; 2222 } 2223 return false; 2224} 2225 2226 2227bool 2228lldb_private::operator> (const Scalar& lhs, const Scalar& rhs) 2229{ 2230 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2231 return false; 2232 2233 Scalar temp_value; 2234 const Scalar* a; 2235 const Scalar* b; 2236 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2237 { 2238 case Scalar::e_void: break; 2239 case Scalar::e_sint: return a->m_data.sint > b->m_data.sint; 2240 case Scalar::e_uint: return a->m_data.uint > b->m_data.uint; 2241 case Scalar::e_slong: return a->m_data.slong > b->m_data.slong; 2242 case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong; 2243 case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong; 2244 case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong; 2245 case Scalar::e_float: return a->m_data.flt > b->m_data.flt; 2246 case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl; 2247 case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl; 2248 } 2249 return false; 2250} 2251 2252bool 2253lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs) 2254{ 2255 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2256 return false; 2257 2258 Scalar temp_value; 2259 const Scalar* a; 2260 const Scalar* b; 2261 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) 2262 { 2263 case Scalar::e_void: break; 2264 case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint; 2265 case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint; 2266 case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong; 2267 case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong; 2268 case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong; 2269 case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong; 2270 case Scalar::e_float: return a->m_data.flt >= b->m_data.flt; 2271 case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl; 2272 case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl; 2273 } 2274 return false; 2275} 2276 2277 2278 2279 2280