1 //===-- Scalar.cpp --------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Utility/Scalar.h" 10 #include "lldb/Utility/DataBufferHeap.h" 11 #include "lldb/Utility/DataExtractor.h" 12 #include "lldb/Utility/Endian.h" 13 #include "lldb/Utility/Status.h" 14 #include "lldb/Utility/Stream.h" 15 #include "lldb/Utility/StreamString.h" 16 #include "lldb/lldb-types.h" 17 18 #include "llvm/ADT/SmallString.h" 19 20 #include <cinttypes> 21 #include <cstdio> 22 23 using namespace lldb; 24 using namespace lldb_private; 25 26 // Promote to max type currently follows the ANSI C rule for type promotion in 27 // expressions. 28 static Scalar::Type PromoteToMaxType( 29 const Scalar &lhs, // The const left hand side object 30 const Scalar &rhs, // The const right hand side object 31 Scalar &temp_value, // A modifiable temp value than can be used to hold 32 // either the promoted lhs or rhs object 33 const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly 34 // promoted value of lhs (at most one of 35 // lhs/rhs will get promoted) 36 const Scalar *&promoted_rhs_ptr // Pointer to the resulting possibly 37 // promoted value of rhs (at most one of 38 // lhs/rhs will get promoted) 39 ) { 40 Scalar result; 41 // Initialize the promoted values for both the right and left hand side 42 // values to be the objects themselves. If no promotion is needed (both right 43 // and left 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 // Right hand side need to be promoted 52 temp_value = rhs; // Copy right hand side into the temp value 53 if (temp_value.Promote(lhs_type)) // Promote it 54 promoted_rhs_ptr = 55 &temp_value; // Update the pointer for the promoted right hand side 56 } else if (lhs_type < rhs_type) { 57 // Left hand side need to be promoted 58 temp_value = lhs; // Copy left hand side value into the temp value 59 if (temp_value.Promote(rhs_type)) // Promote it 60 promoted_lhs_ptr = 61 &temp_value; // Update the pointer for the promoted left hand side 62 } 63 64 // Make sure our type promotion worked as expected 65 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType()) 66 return promoted_lhs_ptr->GetType(); // Return the resulting max type 67 68 // Return the void type (zero) if we fail to promote either of the values. 69 return Scalar::e_void; 70 } 71 72 Scalar::Scalar() : m_type(e_void), m_float(static_cast<float>(0)) {} 73 74 bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const { 75 size_t byte_size = GetByteSize(); 76 if (byte_size == 0) { 77 data.Clear(); 78 return false; 79 } 80 auto buffer_up = std::make_unique<DataBufferHeap>(byte_size, 0); 81 GetBytes(buffer_up->GetData()); 82 lldb::offset_t offset = 0; 83 84 if (limit_byte_size < byte_size) { 85 if (endian::InlHostByteOrder() == eByteOrderLittle) { 86 // On little endian systems if we want fewer bytes from the current 87 // type we just specify fewer bytes since the LSByte is first... 88 byte_size = limit_byte_size; 89 } else if (endian::InlHostByteOrder() == eByteOrderBig) { 90 // On big endian systems if we want fewer bytes from the current type 91 // have to advance our initial byte pointer and trim down the number of 92 // bytes since the MSByte is first 93 offset = byte_size - limit_byte_size; 94 byte_size = limit_byte_size; 95 } 96 } 97 98 data.SetData(std::move(buffer_up), offset, byte_size); 99 data.SetByteOrder(endian::InlHostByteOrder()); 100 return true; 101 } 102 103 void Scalar::GetBytes(llvm::MutableArrayRef<uint8_t> storage) const { 104 assert(storage.size() >= GetByteSize()); 105 106 switch (m_type) { 107 case e_void: 108 break; 109 case e_sint: 110 case e_uint: 111 case e_slong: 112 case e_ulong: 113 case e_slonglong: 114 case e_ulonglong: 115 case e_sint128: 116 case e_uint128: 117 case e_sint256: 118 case e_uint256: 119 case e_sint512: 120 case e_uint512: 121 StoreIntToMemory(m_integer, storage.data(), 122 (m_integer.getBitWidth() + 7) / 8); 123 break; 124 case e_float: { 125 float val = m_float.convertToFloat(); 126 memcpy(storage.data(), &val, sizeof(val)); 127 break; 128 } 129 case e_double: { 130 double val = m_float.convertToDouble(); 131 memcpy(storage.data(), &val, sizeof(double)); 132 break; 133 } 134 case e_long_double: { 135 llvm::APInt val = m_float.bitcastToAPInt(); 136 StoreIntToMemory(val, storage.data(), storage.size()); 137 break; 138 } 139 } 140 } 141 142 size_t Scalar::GetByteSize() const { 143 switch (m_type) { 144 case e_void: 145 break; 146 case e_sint: 147 case e_uint: 148 case e_slong: 149 case e_ulong: 150 case e_slonglong: 151 case e_ulonglong: 152 case e_sint128: 153 case e_uint128: 154 case e_sint256: 155 case e_uint256: 156 case e_sint512: 157 case e_uint512: 158 return (m_integer.getBitWidth() / 8); 159 case e_float: 160 return sizeof(float_t); 161 case e_double: 162 return sizeof(double_t); 163 case e_long_double: 164 return sizeof(long_double_t); 165 } 166 return 0; 167 } 168 169 bool Scalar::IsZero() const { 170 llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8); 171 switch (m_type) { 172 case e_void: 173 break; 174 case e_sint: 175 case e_uint: 176 case e_slong: 177 case e_ulong: 178 case e_slonglong: 179 case e_ulonglong: 180 case e_sint128: 181 case e_uint128: 182 case e_sint256: 183 case e_uint256: 184 case e_uint512: 185 case e_sint512: 186 return llvm::APInt::isSameValue(zero_int, m_integer); 187 case e_float: 188 case e_double: 189 case e_long_double: 190 return m_float.isZero(); 191 } 192 return false; 193 } 194 195 void Scalar::GetValue(Stream *s, bool show_type) const { 196 if (show_type) 197 s->Printf("(%s) ", GetTypeAsCString()); 198 199 switch (m_type) { 200 case e_void: 201 break; 202 case e_sint: 203 case e_slong: 204 case e_slonglong: 205 case e_sint128: 206 case e_sint256: 207 case e_sint512: 208 s->PutCString(m_integer.toString(10, true)); 209 break; 210 case e_uint: 211 case e_ulong: 212 case e_ulonglong: 213 case e_uint128: 214 case e_uint256: 215 case e_uint512: 216 s->PutCString(m_integer.toString(10, false)); 217 break; 218 case e_float: 219 case e_double: 220 case e_long_double: 221 llvm::SmallString<24> string; 222 m_float.toString(string); 223 s->Printf("%s", string.c_str()); 224 break; 225 } 226 } 227 228 const char *Scalar::GetTypeAsCString() const { 229 switch (m_type) { 230 case e_void: 231 return "void"; 232 case e_sint: 233 return "int"; 234 case e_uint: 235 return "unsigned int"; 236 case e_slong: 237 return "long"; 238 case e_ulong: 239 return "unsigned long"; 240 case e_slonglong: 241 return "long long"; 242 case e_ulonglong: 243 return "unsigned long long"; 244 case e_sint128: 245 return "int128_t"; 246 case e_uint128: 247 return "unsigned int128_t"; 248 case e_sint256: 249 return "int256_t"; 250 case e_uint256: 251 return "unsigned int256_t"; 252 case e_sint512: 253 return "int512_t"; 254 case e_uint512: 255 return "unsigned int512_t"; 256 case e_float: 257 return "float"; 258 case e_double: 259 return "double"; 260 case e_long_double: 261 return "long double"; 262 } 263 return "<invalid Scalar type>"; 264 } 265 266 Scalar::~Scalar() = default; 267 268 Scalar::Type Scalar::GetBestTypeForBitSize(size_t bit_size, bool sign) { 269 // Scalar types are always host types, hence the sizeof(). 270 if (sign) { 271 if (bit_size <= sizeof(int)*8) return Scalar::e_sint; 272 if (bit_size <= sizeof(long)*8) return Scalar::e_slong; 273 if (bit_size <= sizeof(long long)*8) return Scalar::e_slonglong; 274 if (bit_size <= 128) return Scalar::e_sint128; 275 if (bit_size <= 256) return Scalar::e_sint256; 276 if (bit_size <= 512) return Scalar::e_sint512; 277 } else { 278 if (bit_size <= sizeof(unsigned int)*8) return Scalar::e_uint; 279 if (bit_size <= sizeof(unsigned long)*8) return Scalar::e_ulong; 280 if (bit_size <= sizeof(unsigned long long)*8) return Scalar::e_ulonglong; 281 if (bit_size <= 128) return Scalar::e_uint128; 282 if (bit_size <= 256) return Scalar::e_uint256; 283 if (bit_size <= 512) return Scalar::e_uint512; 284 } 285 return Scalar::e_void; 286 } 287 288 void Scalar::TruncOrExtendTo(uint16_t bits, bool sign) { 289 m_integer = sign ? m_integer.sextOrTrunc(bits) : m_integer.zextOrTrunc(bits); 290 m_type = GetBestTypeForBitSize(bits, sign); 291 } 292 293 bool Scalar::Promote(Scalar::Type type) { 294 bool success = false; 295 switch (m_type) { 296 case e_void: 297 break; 298 299 case e_sint: 300 switch (type) { 301 case e_void: 302 break; 303 case e_sint: 304 success = true; 305 break; 306 case e_uint: 307 m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8); 308 success = true; 309 break; 310 311 case e_slong: 312 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8); 313 success = true; 314 break; 315 316 case e_ulong: 317 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8); 318 success = true; 319 break; 320 321 case e_slonglong: 322 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); 323 success = true; 324 break; 325 326 case e_ulonglong: 327 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8); 328 success = true; 329 break; 330 331 case e_sint128: 332 case e_uint128: 333 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); 334 success = true; 335 break; 336 337 case e_sint256: 338 case e_uint256: 339 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); 340 success = true; 341 break; 342 343 case e_sint512: 344 case e_uint512: 345 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512); 346 success = true; 347 break; 348 349 case e_float: 350 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 351 m_float.convertFromAPInt(m_integer, true, 352 llvm::APFloat::rmNearestTiesToEven); 353 success = true; 354 break; 355 356 case e_double: 357 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 358 m_float.convertFromAPInt(m_integer, true, 359 llvm::APFloat::rmNearestTiesToEven); 360 success = true; 361 break; 362 363 case e_long_double: 364 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 365 m_float.convertFromAPInt(m_integer, true, 366 llvm::APFloat::rmNearestTiesToEven); 367 success = true; 368 break; 369 } 370 break; 371 372 case e_uint: 373 switch (type) { 374 case e_void: 375 case e_sint: 376 break; 377 case e_uint: 378 success = true; 379 break; 380 case e_slong: 381 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8); 382 success = true; 383 break; 384 385 case e_ulong: 386 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8); 387 success = true; 388 break; 389 390 case e_slonglong: 391 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8); 392 success = true; 393 break; 394 395 case e_ulonglong: 396 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); 397 success = true; 398 break; 399 400 case e_sint128: 401 case e_uint128: 402 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); 403 success = true; 404 break; 405 406 case e_sint256: 407 case e_uint256: 408 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); 409 success = true; 410 break; 411 412 case e_sint512: 413 case e_uint512: 414 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512); 415 success = true; 416 break; 417 418 case e_float: 419 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 420 m_float.convertFromAPInt(m_integer, false, 421 llvm::APFloat::rmNearestTiesToEven); 422 success = true; 423 break; 424 425 case e_double: 426 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 427 m_float.convertFromAPInt(m_integer, false, 428 llvm::APFloat::rmNearestTiesToEven); 429 success = true; 430 break; 431 432 case e_long_double: 433 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 434 m_float.convertFromAPInt(m_integer, false, 435 llvm::APFloat::rmNearestTiesToEven); 436 success = true; 437 break; 438 } 439 break; 440 441 case e_slong: 442 switch (type) { 443 case e_void: 444 case e_sint: 445 case e_uint: 446 break; 447 case e_slong: 448 success = true; 449 break; 450 case e_ulong: 451 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8); 452 success = true; 453 break; 454 455 case e_slonglong: 456 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8); 457 success = true; 458 break; 459 460 case e_ulonglong: 461 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8); 462 success = true; 463 break; 464 465 case e_sint128: 466 case e_uint128: 467 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); 468 success = true; 469 break; 470 471 case e_sint256: 472 case e_uint256: 473 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); 474 success = true; 475 break; 476 477 case e_sint512: 478 case e_uint512: 479 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512); 480 success = true; 481 break; 482 483 case e_float: 484 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 485 m_float.convertFromAPInt(m_integer, true, 486 llvm::APFloat::rmNearestTiesToEven); 487 success = true; 488 break; 489 490 case e_double: 491 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 492 m_float.convertFromAPInt(m_integer, true, 493 llvm::APFloat::rmNearestTiesToEven); 494 success = true; 495 break; 496 497 case e_long_double: 498 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 499 m_float.convertFromAPInt(m_integer, true, 500 llvm::APFloat::rmNearestTiesToEven); 501 success = true; 502 break; 503 } 504 break; 505 506 case e_ulong: 507 switch (type) { 508 case e_void: 509 case e_sint: 510 case e_uint: 511 case e_slong: 512 break; 513 case e_ulong: 514 success = true; 515 break; 516 case e_slonglong: 517 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8); 518 success = true; 519 break; 520 521 case e_ulonglong: 522 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8); 523 success = true; 524 break; 525 526 case e_sint128: 527 case e_uint128: 528 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); 529 success = true; 530 break; 531 532 case e_sint256: 533 case e_uint256: 534 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); 535 success = true; 536 break; 537 538 case e_sint512: 539 case e_uint512: 540 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512); 541 success = true; 542 break; 543 544 case e_float: 545 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 546 m_float.convertFromAPInt(m_integer, false, 547 llvm::APFloat::rmNearestTiesToEven); 548 success = true; 549 break; 550 551 case e_double: 552 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 553 m_float.convertFromAPInt(m_integer, false, 554 llvm::APFloat::rmNearestTiesToEven); 555 success = true; 556 break; 557 558 case e_long_double: 559 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 560 m_float.convertFromAPInt(m_integer, false, 561 llvm::APFloat::rmNearestTiesToEven); 562 success = true; 563 break; 564 } 565 break; 566 567 case e_slonglong: 568 switch (type) { 569 case e_void: 570 case e_sint: 571 case e_uint: 572 case e_slong: 573 case e_ulong: 574 break; 575 case e_slonglong: 576 success = true; 577 break; 578 case e_ulonglong: 579 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8); 580 success = true; 581 break; 582 583 case e_sint128: 584 case e_uint128: 585 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); 586 success = true; 587 break; 588 589 case e_sint256: 590 case e_uint256: 591 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); 592 success = true; 593 break; 594 595 case e_sint512: 596 case e_uint512: 597 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512); 598 success = true; 599 break; 600 601 case e_float: 602 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 603 m_float.convertFromAPInt(m_integer, true, 604 llvm::APFloat::rmNearestTiesToEven); 605 success = true; 606 break; 607 608 case e_double: 609 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 610 m_float.convertFromAPInt(m_integer, true, 611 llvm::APFloat::rmNearestTiesToEven); 612 success = true; 613 break; 614 615 case e_long_double: 616 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 617 m_float.convertFromAPInt(m_integer, true, 618 llvm::APFloat::rmNearestTiesToEven); 619 success = true; 620 break; 621 } 622 break; 623 624 case e_ulonglong: 625 switch (type) { 626 case e_void: 627 case e_sint: 628 case e_uint: 629 case e_slong: 630 case e_ulong: 631 case e_slonglong: 632 break; 633 case e_ulonglong: 634 success = true; 635 break; 636 case e_sint128: 637 case e_uint128: 638 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128); 639 success = true; 640 break; 641 642 case e_sint256: 643 case e_uint256: 644 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); 645 success = true; 646 break; 647 648 case e_sint512: 649 case e_uint512: 650 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512); 651 success = true; 652 break; 653 654 case e_float: 655 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 656 m_float.convertFromAPInt(m_integer, false, 657 llvm::APFloat::rmNearestTiesToEven); 658 success = true; 659 break; 660 661 case e_double: 662 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 663 m_float.convertFromAPInt(m_integer, false, 664 llvm::APFloat::rmNearestTiesToEven); 665 success = true; 666 break; 667 668 case e_long_double: 669 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 670 m_float.convertFromAPInt(m_integer, false, 671 llvm::APFloat::rmNearestTiesToEven); 672 success = true; 673 break; 674 } 675 break; 676 677 case e_sint128: 678 switch (type) { 679 case e_void: 680 case e_sint: 681 case e_uint: 682 case e_slong: 683 case e_ulong: 684 case e_slonglong: 685 case e_ulonglong: 686 break; 687 case e_sint128: 688 success = true; 689 break; 690 case e_uint128: 691 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128); 692 success = true; 693 break; 694 695 case e_sint256: 696 case e_uint256: 697 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); 698 success = true; 699 break; 700 701 case e_sint512: 702 case e_uint512: 703 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512); 704 success = true; 705 break; 706 707 case e_float: 708 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 709 m_float.convertFromAPInt(m_integer, true, 710 llvm::APFloat::rmNearestTiesToEven); 711 success = true; 712 break; 713 714 case e_double: 715 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 716 m_float.convertFromAPInt(m_integer, true, 717 llvm::APFloat::rmNearestTiesToEven); 718 success = true; 719 break; 720 721 case e_long_double: 722 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 723 m_float.convertFromAPInt(m_integer, true, 724 llvm::APFloat::rmNearestTiesToEven); 725 success = true; 726 break; 727 } 728 break; 729 730 case e_uint128: 731 switch (type) { 732 case e_void: 733 case e_sint: 734 case e_uint: 735 case e_slong: 736 case e_ulong: 737 case e_slonglong: 738 case e_ulonglong: 739 case e_sint128: 740 break; 741 case e_uint128: 742 success = true; 743 break; 744 case e_sint256: 745 case e_uint256: 746 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256); 747 success = true; 748 break; 749 750 case e_sint512: 751 case e_uint512: 752 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512); 753 success = true; 754 break; 755 756 case e_float: 757 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 758 m_float.convertFromAPInt(m_integer, false, 759 llvm::APFloat::rmNearestTiesToEven); 760 success = true; 761 break; 762 763 case e_double: 764 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 765 m_float.convertFromAPInt(m_integer, false, 766 llvm::APFloat::rmNearestTiesToEven); 767 success = true; 768 break; 769 770 case e_long_double: 771 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 772 m_float.convertFromAPInt(m_integer, false, 773 llvm::APFloat::rmNearestTiesToEven); 774 success = true; 775 break; 776 } 777 break; 778 779 case e_sint256: 780 switch (type) { 781 case e_void: 782 case e_sint: 783 case e_uint: 784 case e_slong: 785 case e_ulong: 786 case e_slonglong: 787 case e_ulonglong: 788 case e_sint128: 789 case e_uint128: 790 break; 791 case e_sint256: 792 success = true; 793 break; 794 case e_uint256: 795 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256); 796 success = true; 797 break; 798 799 case e_sint512: 800 case e_uint512: 801 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512); 802 success = true; 803 break; 804 805 case e_float: 806 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 807 m_float.convertFromAPInt(m_integer, true, 808 llvm::APFloat::rmNearestTiesToEven); 809 success = true; 810 break; 811 812 case e_double: 813 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 814 m_float.convertFromAPInt(m_integer, true, 815 llvm::APFloat::rmNearestTiesToEven); 816 success = true; 817 break; 818 819 case e_long_double: 820 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 821 m_float.convertFromAPInt(m_integer, true, 822 llvm::APFloat::rmNearestTiesToEven); 823 success = true; 824 break; 825 } 826 break; 827 828 case e_uint256: 829 switch (type) { 830 case e_void: 831 case e_sint: 832 case e_uint: 833 case e_slong: 834 case e_ulong: 835 case e_slonglong: 836 case e_ulonglong: 837 case e_sint128: 838 case e_uint128: 839 case e_sint256: 840 break; 841 case e_uint256: 842 success = true; 843 break; 844 845 case e_sint512: 846 case e_uint512: 847 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512); 848 success = true; 849 break; 850 851 case e_float: 852 m_float = llvm::APFloat(llvm::APFloat::IEEEsingle()); 853 m_float.convertFromAPInt(m_integer, false, 854 llvm::APFloat::rmNearestTiesToEven); 855 success = true; 856 break; 857 858 case e_double: 859 m_float = llvm::APFloat(llvm::APFloat::IEEEdouble()); 860 m_float.convertFromAPInt(m_integer, false, 861 llvm::APFloat::rmNearestTiesToEven); 862 success = true; 863 break; 864 865 case e_long_double: 866 m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended()); 867 m_float.convertFromAPInt(m_integer, false, 868 llvm::APFloat::rmNearestTiesToEven); 869 success = true; 870 break; 871 } 872 break; 873 874 case e_sint512: 875 case e_uint512: 876 lldbassert(false && "unimplemented"); 877 break; 878 879 case e_float: 880 switch (type) { 881 case e_void: 882 case e_sint: 883 case e_uint: 884 case e_slong: 885 case e_ulong: 886 case e_slonglong: 887 case e_ulonglong: 888 case e_sint128: 889 case e_uint128: 890 case e_sint256: 891 case e_uint256: 892 case e_uint512: 893 case e_sint512: 894 break; 895 case e_float: 896 success = true; 897 break; 898 case e_double: 899 m_float = llvm::APFloat(static_cast<double_t>(m_float.convertToFloat())); 900 success = true; 901 break; 902 903 case e_long_double: { 904 bool ignore; 905 m_float.convert(llvm::APFloat::x87DoubleExtended(), 906 llvm::APFloat::rmNearestTiesToEven, &ignore); 907 success = true; 908 break; 909 } 910 } 911 break; 912 913 case e_double: 914 switch (type) { 915 case e_void: 916 case e_sint: 917 case e_uint: 918 case e_slong: 919 case e_ulong: 920 case e_slonglong: 921 case e_ulonglong: 922 case e_sint128: 923 case e_uint128: 924 case e_sint256: 925 case e_uint256: 926 case e_sint512: 927 case e_uint512: 928 case e_float: 929 break; 930 case e_double: 931 success = true; 932 break; 933 case e_long_double: { 934 bool ignore; 935 m_float.convert(llvm::APFloat::x87DoubleExtended(), 936 llvm::APFloat::rmNearestTiesToEven, &ignore); 937 success = true; 938 break; 939 } 940 } 941 break; 942 943 case e_long_double: 944 switch (type) { 945 case e_void: 946 case e_sint: 947 case e_uint: 948 case e_slong: 949 case e_ulong: 950 case e_slonglong: 951 case e_ulonglong: 952 case e_sint128: 953 case e_uint128: 954 case e_sint256: 955 case e_uint256: 956 case e_sint512: 957 case e_uint512: 958 case e_float: 959 case e_double: 960 break; 961 case e_long_double: 962 success = true; 963 break; 964 } 965 break; 966 } 967 968 if (success) 969 m_type = type; 970 return success; 971 } 972 973 const char *Scalar::GetValueTypeAsCString(Scalar::Type type) { 974 switch (type) { 975 case e_void: 976 return "void"; 977 case e_sint: 978 return "int"; 979 case e_uint: 980 return "unsigned int"; 981 case e_slong: 982 return "long"; 983 case e_ulong: 984 return "unsigned long"; 985 case e_slonglong: 986 return "long long"; 987 case e_ulonglong: 988 return "unsigned long long"; 989 case e_float: 990 return "float"; 991 case e_double: 992 return "double"; 993 case e_long_double: 994 return "long double"; 995 case e_sint128: 996 return "int128_t"; 997 case e_uint128: 998 return "uint128_t"; 999 case e_sint256: 1000 return "int256_t"; 1001 case e_uint256: 1002 return "uint256_t"; 1003 case e_sint512: 1004 return "int512_t"; 1005 case e_uint512: 1006 return "uint512_t"; 1007 } 1008 return "???"; 1009 } 1010 1011 Scalar::Type 1012 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) { 1013 if (byte_size <= sizeof(sint_t)) 1014 return e_sint; 1015 if (byte_size <= sizeof(slong_t)) 1016 return e_slong; 1017 if (byte_size <= sizeof(slonglong_t)) 1018 return e_slonglong; 1019 return e_void; 1020 } 1021 1022 Scalar::Type 1023 Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) { 1024 if (byte_size <= sizeof(uint_t)) 1025 return e_uint; 1026 if (byte_size <= sizeof(ulong_t)) 1027 return e_ulong; 1028 if (byte_size <= sizeof(ulonglong_t)) 1029 return e_ulonglong; 1030 return e_void; 1031 } 1032 1033 Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) { 1034 if (byte_size == sizeof(float_t)) 1035 return e_float; 1036 if (byte_size == sizeof(double_t)) 1037 return e_double; 1038 if (byte_size == sizeof(long_double_t)) 1039 return e_long_double; 1040 return e_void; 1041 } 1042 1043 bool Scalar::MakeSigned() { 1044 bool success = false; 1045 1046 switch (m_type) { 1047 case e_void: 1048 break; 1049 case e_sint: 1050 success = true; 1051 break; 1052 case e_uint: 1053 m_type = e_sint; 1054 success = true; 1055 break; 1056 case e_slong: 1057 success = true; 1058 break; 1059 case e_ulong: 1060 m_type = e_slong; 1061 success = true; 1062 break; 1063 case e_slonglong: 1064 success = true; 1065 break; 1066 case e_ulonglong: 1067 m_type = e_slonglong; 1068 success = true; 1069 break; 1070 case e_sint128: 1071 success = true; 1072 break; 1073 case e_uint128: 1074 m_type = e_sint128; 1075 success = true; 1076 break; 1077 case e_sint256: 1078 success = true; 1079 break; 1080 case e_uint256: 1081 m_type = e_sint256; 1082 success = true; 1083 break; 1084 case e_sint512: 1085 success = true; 1086 break; 1087 case e_uint512: 1088 m_type = e_sint512; 1089 success = true; 1090 break; 1091 case e_float: 1092 success = true; 1093 break; 1094 case e_double: 1095 success = true; 1096 break; 1097 case e_long_double: 1098 success = true; 1099 break; 1100 } 1101 1102 return success; 1103 } 1104 1105 bool Scalar::MakeUnsigned() { 1106 bool success = false; 1107 1108 switch (m_type) { 1109 case e_void: 1110 break; 1111 case e_sint: 1112 m_type = e_uint; 1113 success = true; 1114 break; 1115 case e_uint: 1116 success = true; 1117 break; 1118 case e_slong: 1119 m_type = e_ulong; 1120 success = true; 1121 break; 1122 case e_ulong: 1123 success = true; 1124 break; 1125 case e_slonglong: 1126 m_type = e_ulonglong; 1127 success = true; 1128 break; 1129 case e_ulonglong: 1130 success = true; 1131 break; 1132 case e_sint128: 1133 m_type = e_uint128; 1134 success = true; 1135 break; 1136 case e_uint128: 1137 success = true; 1138 break; 1139 case e_sint256: 1140 m_type = e_uint256; 1141 success = true; 1142 break; 1143 case e_uint256: 1144 success = true; 1145 break; 1146 case e_sint512: 1147 m_type = e_uint512; 1148 success = true; 1149 break; 1150 case e_uint512: 1151 success = true; 1152 break; 1153 case e_float: 1154 success = true; 1155 break; 1156 case e_double: 1157 success = true; 1158 break; 1159 case e_long_double: 1160 success = true; 1161 break; 1162 } 1163 1164 return success; 1165 } 1166 1167 signed char Scalar::SChar(char fail_value) const { 1168 switch (m_type) { 1169 case e_void: 1170 break; 1171 case e_sint: 1172 case e_uint: 1173 case e_slong: 1174 case e_ulong: 1175 case e_slonglong: 1176 case e_ulonglong: 1177 case e_sint128: 1178 case e_uint128: 1179 case e_sint256: 1180 case e_uint256: 1181 case e_sint512: 1182 case e_uint512: 1183 return static_cast<schar_t>( 1184 (m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue()); 1185 case e_float: 1186 return static_cast<schar_t>(m_float.convertToFloat()); 1187 case e_double: 1188 return static_cast<schar_t>(m_float.convertToDouble()); 1189 case e_long_double: 1190 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1191 return static_cast<schar_t>( 1192 (ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue()); 1193 } 1194 return fail_value; 1195 } 1196 1197 unsigned char Scalar::UChar(unsigned char fail_value) const { 1198 switch (m_type) { 1199 case e_void: 1200 break; 1201 case e_sint: 1202 case e_uint: 1203 case e_slong: 1204 case e_ulong: 1205 case e_slonglong: 1206 case e_ulonglong: 1207 case e_sint128: 1208 case e_uint128: 1209 case e_sint256: 1210 case e_uint256: 1211 case e_sint512: 1212 case e_uint512: 1213 return static_cast<uchar_t>( 1214 (m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue()); 1215 case e_float: 1216 return static_cast<uchar_t>(m_float.convertToFloat()); 1217 case e_double: 1218 return static_cast<uchar_t>(m_float.convertToDouble()); 1219 case e_long_double: 1220 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1221 return static_cast<uchar_t>( 1222 (ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue()); 1223 } 1224 return fail_value; 1225 } 1226 1227 short Scalar::SShort(short fail_value) const { 1228 switch (m_type) { 1229 case e_void: 1230 break; 1231 case e_sint: 1232 case e_uint: 1233 case e_slong: 1234 case e_ulong: 1235 case e_slonglong: 1236 case e_ulonglong: 1237 case e_sint128: 1238 case e_uint128: 1239 case e_sint256: 1240 case e_uint256: 1241 case e_sint512: 1242 case e_uint512: 1243 return static_cast<sshort_t>( 1244 (m_integer.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue()); 1245 case e_float: 1246 return static_cast<sshort_t>(m_float.convertToFloat()); 1247 case e_double: 1248 return static_cast<sshort_t>(m_float.convertToDouble()); 1249 case e_long_double: 1250 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1251 return static_cast<sshort_t>( 1252 (ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8)).getSExtValue()); 1253 } 1254 return fail_value; 1255 } 1256 1257 unsigned short Scalar::UShort(unsigned short fail_value) const { 1258 switch (m_type) { 1259 case e_void: 1260 break; 1261 case e_sint: 1262 case e_uint: 1263 case e_slong: 1264 case e_ulong: 1265 case e_slonglong: 1266 case e_ulonglong: 1267 case e_sint128: 1268 case e_uint128: 1269 case e_sint256: 1270 case e_uint256: 1271 case e_sint512: 1272 case e_uint512: 1273 return static_cast<ushort_t>( 1274 (m_integer.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue()); 1275 case e_float: 1276 return static_cast<ushort_t>(m_float.convertToFloat()); 1277 case e_double: 1278 return static_cast<ushort_t>(m_float.convertToDouble()); 1279 case e_long_double: 1280 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1281 return static_cast<ushort_t>( 1282 (ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8)).getZExtValue()); 1283 } 1284 return fail_value; 1285 } 1286 1287 int Scalar::SInt(int fail_value) const { 1288 switch (m_type) { 1289 case e_void: 1290 break; 1291 case e_sint: 1292 case e_uint: 1293 case e_slong: 1294 case e_ulong: 1295 case e_slonglong: 1296 case e_ulonglong: 1297 case e_sint128: 1298 case e_uint128: 1299 case e_sint256: 1300 case e_uint256: 1301 case e_sint512: 1302 case e_uint512: 1303 return static_cast<sint_t>( 1304 (m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue()); 1305 case e_float: 1306 return static_cast<sint_t>(m_float.convertToFloat()); 1307 case e_double: 1308 return static_cast<sint_t>(m_float.convertToDouble()); 1309 case e_long_double: 1310 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1311 return static_cast<sint_t>( 1312 (ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue()); 1313 } 1314 return fail_value; 1315 } 1316 1317 unsigned int Scalar::UInt(unsigned int fail_value) const { 1318 switch (m_type) { 1319 case e_void: 1320 break; 1321 case e_sint: 1322 case e_uint: 1323 case e_slong: 1324 case e_ulong: 1325 case e_slonglong: 1326 case e_ulonglong: 1327 case e_sint128: 1328 case e_uint128: 1329 case e_sint256: 1330 case e_uint256: 1331 case e_sint512: 1332 case e_uint512: 1333 return static_cast<uint_t>( 1334 (m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue()); 1335 case e_float: 1336 return static_cast<uint_t>(m_float.convertToFloat()); 1337 case e_double: 1338 return static_cast<uint_t>(m_float.convertToDouble()); 1339 case e_long_double: 1340 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1341 return static_cast<uint_t>( 1342 (ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue()); 1343 } 1344 return fail_value; 1345 } 1346 1347 long Scalar::SLong(long fail_value) const { 1348 switch (m_type) { 1349 case e_void: 1350 break; 1351 case e_sint: 1352 case e_uint: 1353 case e_slong: 1354 case e_ulong: 1355 case e_slonglong: 1356 case e_ulonglong: 1357 case e_sint128: 1358 case e_uint128: 1359 case e_sint256: 1360 case e_uint256: 1361 case e_sint512: 1362 case e_uint512: 1363 return static_cast<slong_t>( 1364 (m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue()); 1365 case e_float: 1366 return static_cast<slong_t>(m_float.convertToFloat()); 1367 case e_double: 1368 return static_cast<slong_t>(m_float.convertToDouble()); 1369 case e_long_double: 1370 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1371 return static_cast<slong_t>( 1372 (ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue()); 1373 } 1374 return fail_value; 1375 } 1376 1377 unsigned long Scalar::ULong(unsigned long fail_value) const { 1378 switch (m_type) { 1379 case e_void: 1380 break; 1381 case e_sint: 1382 case e_uint: 1383 case e_slong: 1384 case e_ulong: 1385 case e_slonglong: 1386 case e_ulonglong: 1387 case e_sint128: 1388 case e_uint128: 1389 case e_sint256: 1390 case e_uint256: 1391 case e_sint512: 1392 case e_uint512: 1393 return static_cast<ulong_t>( 1394 (m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue()); 1395 case e_float: 1396 return static_cast<ulong_t>(m_float.convertToFloat()); 1397 case e_double: 1398 return static_cast<ulong_t>(m_float.convertToDouble()); 1399 case e_long_double: 1400 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1401 return static_cast<ulong_t>( 1402 (ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue()); 1403 } 1404 return fail_value; 1405 } 1406 1407 long long Scalar::SLongLong(long long fail_value) const { 1408 switch (m_type) { 1409 case e_void: 1410 break; 1411 case e_sint: 1412 case e_uint: 1413 case e_slong: 1414 case e_ulong: 1415 case e_slonglong: 1416 case e_ulonglong: 1417 case e_sint128: 1418 case e_uint128: 1419 case e_sint256: 1420 case e_uint256: 1421 case e_sint512: 1422 case e_uint512: 1423 return static_cast<slonglong_t>( 1424 (m_integer.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue()); 1425 case e_float: 1426 return static_cast<slonglong_t>(m_float.convertToFloat()); 1427 case e_double: 1428 return static_cast<slonglong_t>(m_float.convertToDouble()); 1429 case e_long_double: 1430 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1431 return static_cast<slonglong_t>( 1432 (ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8)).getSExtValue()); 1433 } 1434 return fail_value; 1435 } 1436 1437 unsigned long long Scalar::ULongLong(unsigned long long fail_value) const { 1438 switch (m_type) { 1439 case e_void: 1440 break; 1441 case e_sint: 1442 case e_uint: 1443 case e_slong: 1444 case e_ulong: 1445 case e_slonglong: 1446 case e_ulonglong: 1447 case e_sint128: 1448 case e_uint128: 1449 case e_sint256: 1450 case e_uint256: 1451 case e_sint512: 1452 case e_uint512: 1453 return static_cast<ulonglong_t>( 1454 (m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue()); 1455 case e_float: 1456 return static_cast<ulonglong_t>(m_float.convertToFloat()); 1457 case e_double: { 1458 double d_val = m_float.convertToDouble(); 1459 llvm::APInt rounded_double = 1460 llvm::APIntOps::RoundDoubleToAPInt(d_val, sizeof(ulonglong_t) * 8); 1461 return static_cast<ulonglong_t>( 1462 (rounded_double.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue()); 1463 } 1464 case e_long_double: 1465 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1466 return static_cast<ulonglong_t>( 1467 (ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8)).getZExtValue()); 1468 } 1469 return fail_value; 1470 } 1471 1472 llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const { 1473 switch (m_type) { 1474 case e_void: 1475 break; 1476 case e_sint: 1477 case e_uint: 1478 case e_slong: 1479 case e_ulong: 1480 case e_slonglong: 1481 case e_ulonglong: 1482 case e_sint128: 1483 case e_uint128: 1484 case e_sint256: 1485 case e_uint256: 1486 case e_sint512: 1487 case e_uint512: 1488 return m_integer; 1489 case e_float: 1490 case e_double: 1491 case e_long_double: 1492 return m_float.bitcastToAPInt(); 1493 } 1494 return fail_value; 1495 } 1496 1497 llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const { 1498 switch (m_type) { 1499 case e_void: 1500 break; 1501 case e_sint: 1502 case e_uint: 1503 case e_slong: 1504 case e_ulong: 1505 case e_slonglong: 1506 case e_ulonglong: 1507 case e_sint128: 1508 case e_uint128: 1509 case e_sint256: 1510 case e_uint256: 1511 case e_sint512: 1512 case e_uint512: 1513 return m_integer; 1514 case e_float: 1515 case e_double: 1516 case e_long_double: 1517 return m_float.bitcastToAPInt(); 1518 } 1519 return fail_value; 1520 } 1521 1522 float Scalar::Float(float fail_value) const { 1523 switch (m_type) { 1524 case e_void: 1525 break; 1526 case e_sint: 1527 case e_uint: 1528 case e_slong: 1529 case e_ulong: 1530 case e_slonglong: 1531 case e_ulonglong: 1532 case e_sint128: 1533 case e_uint128: 1534 case e_sint256: 1535 case e_uint256: 1536 case e_sint512: 1537 case e_uint512: 1538 return llvm::APIntOps::RoundAPIntToFloat(m_integer); 1539 case e_float: 1540 return m_float.convertToFloat(); 1541 case e_double: 1542 return static_cast<float_t>(m_float.convertToDouble()); 1543 case e_long_double: 1544 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1545 return ldbl_val.bitsToFloat(); 1546 } 1547 return fail_value; 1548 } 1549 1550 double Scalar::Double(double fail_value) const { 1551 switch (m_type) { 1552 case e_void: 1553 break; 1554 case e_sint: 1555 case e_uint: 1556 case e_slong: 1557 case e_ulong: 1558 case e_slonglong: 1559 case e_ulonglong: 1560 case e_sint128: 1561 case e_uint128: 1562 case e_sint256: 1563 case e_uint256: 1564 case e_sint512: 1565 case e_uint512: 1566 return llvm::APIntOps::RoundAPIntToDouble(m_integer); 1567 case e_float: 1568 return static_cast<double_t>(m_float.convertToFloat()); 1569 case e_double: 1570 return m_float.convertToDouble(); 1571 case e_long_double: 1572 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1573 return ldbl_val.bitsToFloat(); 1574 } 1575 return fail_value; 1576 } 1577 1578 long double Scalar::LongDouble(long double fail_value) const { 1579 switch (m_type) { 1580 case e_void: 1581 break; 1582 case e_sint: 1583 case e_uint: 1584 case e_slong: 1585 case e_ulong: 1586 case e_slonglong: 1587 case e_ulonglong: 1588 case e_sint128: 1589 case e_uint128: 1590 case e_sint256: 1591 case e_uint256: 1592 case e_sint512: 1593 case e_uint512: 1594 return static_cast<long_double_t>( 1595 llvm::APIntOps::RoundAPIntToDouble(m_integer)); 1596 case e_float: 1597 return static_cast<long_double_t>(m_float.convertToFloat()); 1598 case e_double: 1599 return static_cast<long_double_t>(m_float.convertToDouble()); 1600 case e_long_double: 1601 llvm::APInt ldbl_val = m_float.bitcastToAPInt(); 1602 return static_cast<long_double_t>(ldbl_val.bitsToDouble()); 1603 } 1604 return fail_value; 1605 } 1606 1607 Scalar &Scalar::operator+=(const Scalar &rhs) { 1608 Scalar temp_value; 1609 const Scalar *a; 1610 const Scalar *b; 1611 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != 1612 Scalar::e_void) { 1613 switch (m_type) { 1614 case e_void: 1615 break; 1616 case e_sint: 1617 case e_uint: 1618 case e_slong: 1619 case e_ulong: 1620 case e_slonglong: 1621 case e_ulonglong: 1622 case e_sint128: 1623 case e_uint128: 1624 case e_sint256: 1625 case e_uint256: 1626 case e_sint512: 1627 case e_uint512: 1628 m_integer = a->m_integer + b->m_integer; 1629 break; 1630 1631 case e_float: 1632 case e_double: 1633 case e_long_double: 1634 m_float = a->m_float + b->m_float; 1635 break; 1636 } 1637 } 1638 return *this; 1639 } 1640 1641 Scalar &Scalar::operator<<=(const Scalar &rhs) { 1642 switch (m_type) { 1643 case e_void: 1644 case e_float: 1645 case e_double: 1646 case e_long_double: 1647 m_type = e_void; 1648 break; 1649 1650 case e_sint: 1651 case e_uint: 1652 case e_slong: 1653 case e_ulong: 1654 case e_slonglong: 1655 case e_ulonglong: 1656 case e_sint128: 1657 case e_uint128: 1658 case e_sint256: 1659 case e_uint256: 1660 case e_sint512: 1661 case e_uint512: 1662 switch (rhs.m_type) { 1663 case e_void: 1664 case e_float: 1665 case e_double: 1666 case e_long_double: 1667 m_type = e_void; 1668 break; 1669 case e_sint: 1670 case e_uint: 1671 case e_slong: 1672 case e_ulong: 1673 case e_slonglong: 1674 case e_ulonglong: 1675 case e_sint128: 1676 case e_uint128: 1677 case e_sint256: 1678 case e_uint256: 1679 case e_sint512: 1680 case e_uint512: 1681 m_integer = m_integer << rhs.m_integer; 1682 break; 1683 } 1684 break; 1685 } 1686 return *this; 1687 } 1688 1689 bool Scalar::ShiftRightLogical(const Scalar &rhs) { 1690 switch (m_type) { 1691 case e_void: 1692 case e_float: 1693 case e_double: 1694 case e_long_double: 1695 m_type = e_void; 1696 break; 1697 1698 case e_sint: 1699 case e_uint: 1700 case e_slong: 1701 case e_ulong: 1702 case e_slonglong: 1703 case e_ulonglong: 1704 case e_sint128: 1705 case e_uint128: 1706 case e_sint256: 1707 case e_uint256: 1708 case e_sint512: 1709 case e_uint512: 1710 switch (rhs.m_type) { 1711 case e_void: 1712 case e_float: 1713 case e_double: 1714 case e_long_double: 1715 m_type = e_void; 1716 break; 1717 case e_sint: 1718 case e_uint: 1719 case e_slong: 1720 case e_ulong: 1721 case e_slonglong: 1722 case e_ulonglong: 1723 case e_sint128: 1724 case e_uint128: 1725 case e_sint256: 1726 case e_uint256: 1727 case e_sint512: 1728 case e_uint512: 1729 m_integer = m_integer.lshr(rhs.m_integer); 1730 break; 1731 } 1732 break; 1733 } 1734 return m_type != e_void; 1735 } 1736 1737 Scalar &Scalar::operator>>=(const Scalar &rhs) { 1738 switch (m_type) { 1739 case e_void: 1740 case e_float: 1741 case e_double: 1742 case e_long_double: 1743 m_type = e_void; 1744 break; 1745 1746 case e_sint: 1747 case e_uint: 1748 case e_slong: 1749 case e_ulong: 1750 case e_slonglong: 1751 case e_ulonglong: 1752 case e_sint128: 1753 case e_uint128: 1754 case e_sint256: 1755 case e_uint256: 1756 case e_sint512: 1757 case e_uint512: 1758 switch (rhs.m_type) { 1759 case e_void: 1760 case e_float: 1761 case e_double: 1762 case e_long_double: 1763 m_type = e_void; 1764 break; 1765 case e_sint: 1766 case e_uint: 1767 case e_slong: 1768 case e_ulong: 1769 case e_slonglong: 1770 case e_ulonglong: 1771 case e_sint128: 1772 case e_uint128: 1773 case e_sint256: 1774 case e_uint256: 1775 case e_sint512: 1776 case e_uint512: 1777 m_integer = m_integer.ashr(rhs.m_integer); 1778 break; 1779 } 1780 break; 1781 } 1782 return *this; 1783 } 1784 1785 Scalar &Scalar::operator&=(const Scalar &rhs) { 1786 switch (m_type) { 1787 case e_void: 1788 case e_float: 1789 case e_double: 1790 case e_long_double: 1791 m_type = e_void; 1792 break; 1793 1794 case e_sint: 1795 case e_uint: 1796 case e_slong: 1797 case e_ulong: 1798 case e_slonglong: 1799 case e_ulonglong: 1800 case e_sint128: 1801 case e_uint128: 1802 case e_sint256: 1803 case e_uint256: 1804 case e_sint512: 1805 case e_uint512: 1806 switch (rhs.m_type) { 1807 case e_void: 1808 case e_float: 1809 case e_double: 1810 case e_long_double: 1811 m_type = e_void; 1812 break; 1813 case e_sint: 1814 case e_uint: 1815 case e_slong: 1816 case e_ulong: 1817 case e_slonglong: 1818 case e_ulonglong: 1819 case e_sint128: 1820 case e_uint128: 1821 case e_sint256: 1822 case e_uint256: 1823 case e_sint512: 1824 case e_uint512: 1825 m_integer &= rhs.m_integer; 1826 break; 1827 } 1828 break; 1829 } 1830 return *this; 1831 } 1832 1833 bool Scalar::AbsoluteValue() { 1834 switch (m_type) { 1835 case e_void: 1836 break; 1837 1838 case e_sint: 1839 case e_slong: 1840 case e_slonglong: 1841 case e_sint128: 1842 case e_sint256: 1843 case e_sint512: 1844 if (m_integer.isNegative()) 1845 m_integer = -m_integer; 1846 return true; 1847 1848 case e_uint: 1849 case e_ulong: 1850 case e_ulonglong: 1851 return true; 1852 case e_uint128: 1853 case e_uint256: 1854 case e_uint512: 1855 case e_float: 1856 case e_double: 1857 case e_long_double: 1858 m_float.clearSign(); 1859 return true; 1860 } 1861 return false; 1862 } 1863 1864 bool Scalar::UnaryNegate() { 1865 switch (m_type) { 1866 case e_void: 1867 break; 1868 case e_sint: 1869 case e_uint: 1870 case e_slong: 1871 case e_ulong: 1872 case e_slonglong: 1873 case e_ulonglong: 1874 case e_sint128: 1875 case e_uint128: 1876 case e_sint256: 1877 case e_uint256: 1878 case e_sint512: 1879 case e_uint512: 1880 m_integer = -m_integer; 1881 return true; 1882 case e_float: 1883 case e_double: 1884 case e_long_double: 1885 m_float.changeSign(); 1886 return true; 1887 } 1888 return false; 1889 } 1890 1891 bool Scalar::OnesComplement() { 1892 switch (m_type) { 1893 case e_sint: 1894 case e_uint: 1895 case e_slong: 1896 case e_ulong: 1897 case e_slonglong: 1898 case e_ulonglong: 1899 case e_sint128: 1900 case e_uint128: 1901 case e_sint256: 1902 case e_uint256: 1903 case e_sint512: 1904 case e_uint512: 1905 m_integer = ~m_integer; 1906 return true; 1907 1908 case e_void: 1909 case e_float: 1910 case e_double: 1911 case e_long_double: 1912 break; 1913 } 1914 return false; 1915 } 1916 1917 const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) { 1918 Scalar result; 1919 Scalar temp_value; 1920 const Scalar *a; 1921 const Scalar *b; 1922 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 1923 Scalar::e_void) { 1924 switch (result.m_type) { 1925 case Scalar::e_void: 1926 break; 1927 case Scalar::e_sint: 1928 case Scalar::e_uint: 1929 case Scalar::e_slong: 1930 case Scalar::e_ulong: 1931 case Scalar::e_slonglong: 1932 case Scalar::e_ulonglong: 1933 case Scalar::e_sint128: 1934 case Scalar::e_uint128: 1935 case Scalar::e_sint256: 1936 case Scalar::e_uint256: 1937 case Scalar::e_sint512: 1938 case Scalar::e_uint512: 1939 result.m_integer = a->m_integer + b->m_integer; 1940 break; 1941 case Scalar::e_float: 1942 case Scalar::e_double: 1943 case Scalar::e_long_double: 1944 result.m_float = a->m_float + b->m_float; 1945 break; 1946 } 1947 } 1948 return result; 1949 } 1950 1951 const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) { 1952 Scalar result; 1953 Scalar temp_value; 1954 const Scalar *a; 1955 const Scalar *b; 1956 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 1957 Scalar::e_void) { 1958 switch (result.m_type) { 1959 case Scalar::e_void: 1960 break; 1961 case Scalar::e_sint: 1962 case Scalar::e_uint: 1963 case Scalar::e_slong: 1964 case Scalar::e_ulong: 1965 case Scalar::e_slonglong: 1966 case Scalar::e_ulonglong: 1967 case Scalar::e_sint128: 1968 case Scalar::e_uint128: 1969 case Scalar::e_sint256: 1970 case Scalar::e_uint256: 1971 case Scalar::e_sint512: 1972 case Scalar::e_uint512: 1973 result.m_integer = a->m_integer - b->m_integer; 1974 break; 1975 case Scalar::e_float: 1976 case Scalar::e_double: 1977 case Scalar::e_long_double: 1978 result.m_float = a->m_float - b->m_float; 1979 break; 1980 } 1981 } 1982 return result; 1983 } 1984 1985 const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) { 1986 Scalar result; 1987 Scalar temp_value; 1988 const Scalar *a; 1989 const Scalar *b; 1990 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 1991 Scalar::e_void) { 1992 switch (result.m_type) { 1993 case Scalar::e_void: 1994 break; 1995 case Scalar::e_sint: 1996 case Scalar::e_slong: 1997 case Scalar::e_slonglong: 1998 case Scalar::e_sint128: 1999 case Scalar::e_sint256: 2000 case Scalar::e_sint512: 2001 if (b->m_integer != 0) { 2002 result.m_integer = a->m_integer.sdiv(b->m_integer); 2003 return result; 2004 } 2005 break; 2006 case Scalar::e_uint: 2007 case Scalar::e_ulong: 2008 case Scalar::e_ulonglong: 2009 case Scalar::e_uint128: 2010 case Scalar::e_uint256: 2011 case Scalar::e_uint512: 2012 if (b->m_integer != 0) { 2013 result.m_integer = a->m_integer.udiv(b->m_integer); 2014 return result; 2015 } 2016 break; 2017 case Scalar::e_float: 2018 case Scalar::e_double: 2019 case Scalar::e_long_double: 2020 if (!b->m_float.isZero()) { 2021 result.m_float = a->m_float / b->m_float; 2022 return result; 2023 } 2024 break; 2025 } 2026 } 2027 // For division only, the only way it should make it here is if a promotion 2028 // failed, or if we are trying to do a divide by zero. 2029 result.m_type = Scalar::e_void; 2030 return result; 2031 } 2032 2033 const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) { 2034 Scalar result; 2035 Scalar temp_value; 2036 const Scalar *a; 2037 const Scalar *b; 2038 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 2039 Scalar::e_void) { 2040 switch (result.m_type) { 2041 case Scalar::e_void: 2042 break; 2043 case Scalar::e_sint: 2044 case Scalar::e_uint: 2045 case Scalar::e_slong: 2046 case Scalar::e_ulong: 2047 case Scalar::e_slonglong: 2048 case Scalar::e_ulonglong: 2049 case Scalar::e_sint128: 2050 case Scalar::e_uint128: 2051 case Scalar::e_sint256: 2052 case Scalar::e_uint256: 2053 case Scalar::e_sint512: 2054 case Scalar::e_uint512: 2055 result.m_integer = a->m_integer * b->m_integer; 2056 break; 2057 case Scalar::e_float: 2058 case Scalar::e_double: 2059 case Scalar::e_long_double: 2060 result.m_float = a->m_float * b->m_float; 2061 break; 2062 } 2063 } 2064 return result; 2065 } 2066 2067 const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) { 2068 Scalar result; 2069 Scalar temp_value; 2070 const Scalar *a; 2071 const Scalar *b; 2072 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 2073 Scalar::e_void) { 2074 switch (result.m_type) { 2075 case Scalar::e_sint: 2076 case Scalar::e_uint: 2077 case Scalar::e_slong: 2078 case Scalar::e_ulong: 2079 case Scalar::e_slonglong: 2080 case Scalar::e_ulonglong: 2081 case Scalar::e_sint128: 2082 case Scalar::e_uint128: 2083 case Scalar::e_sint256: 2084 case Scalar::e_uint256: 2085 case Scalar::e_sint512: 2086 case Scalar::e_uint512: 2087 result.m_integer = a->m_integer & b->m_integer; 2088 break; 2089 case Scalar::e_void: 2090 case Scalar::e_float: 2091 case Scalar::e_double: 2092 case Scalar::e_long_double: 2093 // No bitwise AND on floats, doubles of long doubles 2094 result.m_type = Scalar::e_void; 2095 break; 2096 } 2097 } 2098 return result; 2099 } 2100 2101 const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) { 2102 Scalar result; 2103 Scalar temp_value; 2104 const Scalar *a; 2105 const Scalar *b; 2106 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 2107 Scalar::e_void) { 2108 switch (result.m_type) { 2109 case Scalar::e_sint: 2110 case Scalar::e_uint: 2111 case Scalar::e_slong: 2112 case Scalar::e_ulong: 2113 case Scalar::e_slonglong: 2114 case Scalar::e_ulonglong: 2115 case Scalar::e_sint128: 2116 case Scalar::e_uint128: 2117 case Scalar::e_sint256: 2118 case Scalar::e_uint256: 2119 case Scalar::e_sint512: 2120 case Scalar::e_uint512: 2121 result.m_integer = a->m_integer | b->m_integer; 2122 break; 2123 2124 case Scalar::e_void: 2125 case Scalar::e_float: 2126 case Scalar::e_double: 2127 case Scalar::e_long_double: 2128 // No bitwise AND on floats, doubles of long doubles 2129 result.m_type = Scalar::e_void; 2130 break; 2131 } 2132 } 2133 return result; 2134 } 2135 2136 const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) { 2137 Scalar result; 2138 Scalar temp_value; 2139 const Scalar *a; 2140 const Scalar *b; 2141 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 2142 Scalar::e_void) { 2143 switch (result.m_type) { 2144 default: 2145 break; 2146 case Scalar::e_void: 2147 break; 2148 case Scalar::e_sint: 2149 case Scalar::e_slong: 2150 case Scalar::e_slonglong: 2151 case Scalar::e_sint128: 2152 case Scalar::e_sint256: 2153 case Scalar::e_sint512: 2154 if (b->m_integer != 0) { 2155 result.m_integer = a->m_integer.srem(b->m_integer); 2156 return result; 2157 } 2158 break; 2159 case Scalar::e_uint: 2160 case Scalar::e_ulong: 2161 case Scalar::e_ulonglong: 2162 case Scalar::e_uint128: 2163 case Scalar::e_uint256: 2164 case Scalar::e_uint512: 2165 if (b->m_integer != 0) { 2166 result.m_integer = a->m_integer.urem(b->m_integer); 2167 return result; 2168 } 2169 break; 2170 } 2171 } 2172 result.m_type = Scalar::e_void; 2173 return result; 2174 } 2175 2176 const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) { 2177 Scalar result; 2178 Scalar temp_value; 2179 const Scalar *a; 2180 const Scalar *b; 2181 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != 2182 Scalar::e_void) { 2183 switch (result.m_type) { 2184 case Scalar::e_sint: 2185 case Scalar::e_uint: 2186 case Scalar::e_slong: 2187 case Scalar::e_ulong: 2188 case Scalar::e_slonglong: 2189 case Scalar::e_ulonglong: 2190 case Scalar::e_sint128: 2191 case Scalar::e_uint128: 2192 case Scalar::e_sint256: 2193 case Scalar::e_uint256: 2194 case Scalar::e_sint512: 2195 case Scalar::e_uint512: 2196 result.m_integer = a->m_integer ^ b->m_integer; 2197 break; 2198 2199 case Scalar::e_void: 2200 case Scalar::e_float: 2201 case Scalar::e_double: 2202 case Scalar::e_long_double: 2203 // No bitwise AND on floats, doubles of long doubles 2204 result.m_type = Scalar::e_void; 2205 break; 2206 } 2207 } 2208 return result; 2209 } 2210 2211 const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) { 2212 Scalar result = lhs; 2213 result <<= rhs; 2214 return result; 2215 } 2216 2217 const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) { 2218 Scalar result = lhs; 2219 result >>= rhs; 2220 return result; 2221 } 2222 2223 Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding, 2224 size_t byte_size) { 2225 Status error; 2226 if (value_str == nullptr || value_str[0] == '\0') { 2227 error.SetErrorString("Invalid c-string value string."); 2228 return error; 2229 } 2230 switch (encoding) { 2231 case eEncodingInvalid: 2232 error.SetErrorString("Invalid encoding."); 2233 break; 2234 2235 case eEncodingUint: 2236 if (byte_size <= sizeof(uint64_t)) { 2237 uint64_t uval64; 2238 if (!llvm::to_integer(value_str, uval64)) 2239 error.SetErrorStringWithFormat( 2240 "'%s' is not a valid unsigned integer string value", value_str); 2241 else if (!UIntValueIsValidForSize(uval64, byte_size)) 2242 error.SetErrorStringWithFormat( 2243 "value 0x%" PRIx64 " is too large to fit in a %" PRIu64 2244 " byte unsigned integer value", 2245 uval64, static_cast<uint64_t>(byte_size)); 2246 else { 2247 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size); 2248 switch (m_type) { 2249 case e_uint: 2250 m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false); 2251 break; 2252 case e_ulong: 2253 m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false); 2254 break; 2255 case e_ulonglong: 2256 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false); 2257 break; 2258 default: 2259 error.SetErrorStringWithFormat( 2260 "unsupported unsigned integer byte size: %" PRIu64 "", 2261 static_cast<uint64_t>(byte_size)); 2262 break; 2263 } 2264 } 2265 } else { 2266 error.SetErrorStringWithFormat( 2267 "unsupported unsigned integer byte size: %" PRIu64 "", 2268 static_cast<uint64_t>(byte_size)); 2269 return error; 2270 } 2271 break; 2272 2273 case eEncodingSint: 2274 if (byte_size <= sizeof(int64_t)) { 2275 int64_t sval64; 2276 if (!llvm::to_integer(value_str, sval64)) 2277 error.SetErrorStringWithFormat( 2278 "'%s' is not a valid signed integer string value", value_str); 2279 else if (!SIntValueIsValidForSize(sval64, byte_size)) 2280 error.SetErrorStringWithFormat( 2281 "value 0x%" PRIx64 " is too large to fit in a %" PRIu64 2282 " byte signed integer value", 2283 sval64, static_cast<uint64_t>(byte_size)); 2284 else { 2285 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size); 2286 switch (m_type) { 2287 case e_sint: 2288 m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true); 2289 break; 2290 case e_slong: 2291 m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true); 2292 break; 2293 case e_slonglong: 2294 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true); 2295 break; 2296 default: 2297 error.SetErrorStringWithFormat( 2298 "unsupported signed integer byte size: %" PRIu64 "", 2299 static_cast<uint64_t>(byte_size)); 2300 break; 2301 } 2302 } 2303 } else { 2304 error.SetErrorStringWithFormat( 2305 "unsupported signed integer byte size: %" PRIu64 "", 2306 static_cast<uint64_t>(byte_size)); 2307 return error; 2308 } 2309 break; 2310 2311 case eEncodingIEEE754: 2312 static float f_val; 2313 static double d_val; 2314 static long double l_val; 2315 if (byte_size == sizeof(float)) { 2316 if (::sscanf(value_str, "%f", &f_val) == 1) { 2317 m_float = llvm::APFloat(f_val); 2318 m_type = e_float; 2319 } else 2320 error.SetErrorStringWithFormat("'%s' is not a valid float string value", 2321 value_str); 2322 } else if (byte_size == sizeof(double)) { 2323 if (::sscanf(value_str, "%lf", &d_val) == 1) { 2324 m_float = llvm::APFloat(d_val); 2325 m_type = e_double; 2326 } else 2327 error.SetErrorStringWithFormat("'%s' is not a valid float string value", 2328 value_str); 2329 } else if (byte_size == sizeof(long double)) { 2330 if (::sscanf(value_str, "%Lf", &l_val) == 1) { 2331 m_float = llvm::APFloat( 2332 llvm::APFloat::x87DoubleExtended(), 2333 llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, 2334 (reinterpret_cast<type128 *>(&l_val))->x)); 2335 m_type = e_long_double; 2336 } else 2337 error.SetErrorStringWithFormat("'%s' is not a valid float string value", 2338 value_str); 2339 } else { 2340 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "", 2341 static_cast<uint64_t>(byte_size)); 2342 return error; 2343 } 2344 break; 2345 2346 case eEncodingVector: 2347 error.SetErrorString("vector encoding unsupported."); 2348 break; 2349 } 2350 if (error.Fail()) 2351 m_type = e_void; 2352 2353 return error; 2354 } 2355 2356 Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding, 2357 size_t byte_size) { 2358 Status error; 2359 2360 type128 int128; 2361 type256 int256; 2362 switch (encoding) { 2363 case lldb::eEncodingInvalid: 2364 error.SetErrorString("invalid encoding"); 2365 break; 2366 case lldb::eEncodingVector: 2367 error.SetErrorString("vector encoding unsupported"); 2368 break; 2369 case lldb::eEncodingUint: { 2370 lldb::offset_t offset = 0; 2371 2372 switch (byte_size) { 2373 case 1: 2374 operator=(data.GetU8(&offset)); 2375 break; 2376 case 2: 2377 operator=(data.GetU16(&offset)); 2378 break; 2379 case 4: 2380 operator=(data.GetU32(&offset)); 2381 break; 2382 case 8: 2383 operator=(data.GetU64(&offset)); 2384 break; 2385 case 16: 2386 if (data.GetByteOrder() == eByteOrderBig) { 2387 int128.x[1] = data.GetU64(&offset); 2388 int128.x[0] = data.GetU64(&offset); 2389 } else { 2390 int128.x[0] = data.GetU64(&offset); 2391 int128.x[1] = data.GetU64(&offset); 2392 } 2393 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x)); 2394 break; 2395 case 32: 2396 if (data.GetByteOrder() == eByteOrderBig) { 2397 int256.x[3] = data.GetU64(&offset); 2398 int256.x[2] = data.GetU64(&offset); 2399 int256.x[1] = data.GetU64(&offset); 2400 int256.x[0] = data.GetU64(&offset); 2401 } else { 2402 int256.x[0] = data.GetU64(&offset); 2403 int256.x[1] = data.GetU64(&offset); 2404 int256.x[2] = data.GetU64(&offset); 2405 int256.x[3] = data.GetU64(&offset); 2406 } 2407 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x)); 2408 break; 2409 default: 2410 error.SetErrorStringWithFormat( 2411 "unsupported unsigned integer byte size: %" PRIu64 "", 2412 static_cast<uint64_t>(byte_size)); 2413 break; 2414 } 2415 } break; 2416 case lldb::eEncodingSint: { 2417 lldb::offset_t offset = 0; 2418 2419 switch (byte_size) { 2420 case 1: 2421 operator=(static_cast<int8_t>(data.GetU8(&offset))); 2422 break; 2423 case 2: 2424 operator=(static_cast<int16_t>(data.GetU16(&offset))); 2425 break; 2426 case 4: 2427 operator=(static_cast<int32_t>(data.GetU32(&offset))); 2428 break; 2429 case 8: 2430 operator=(static_cast<int64_t>(data.GetU64(&offset))); 2431 break; 2432 case 16: 2433 if (data.GetByteOrder() == eByteOrderBig) { 2434 int128.x[1] = data.GetU64(&offset); 2435 int128.x[0] = data.GetU64(&offset); 2436 } else { 2437 int128.x[0] = data.GetU64(&offset); 2438 int128.x[1] = data.GetU64(&offset); 2439 } 2440 operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x)); 2441 break; 2442 case 32: 2443 if (data.GetByteOrder() == eByteOrderBig) { 2444 int256.x[3] = data.GetU64(&offset); 2445 int256.x[2] = data.GetU64(&offset); 2446 int256.x[1] = data.GetU64(&offset); 2447 int256.x[0] = data.GetU64(&offset); 2448 } else { 2449 int256.x[0] = data.GetU64(&offset); 2450 int256.x[1] = data.GetU64(&offset); 2451 int256.x[2] = data.GetU64(&offset); 2452 int256.x[3] = data.GetU64(&offset); 2453 } 2454 operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x)); 2455 break; 2456 default: 2457 error.SetErrorStringWithFormat( 2458 "unsupported signed integer byte size: %" PRIu64 "", 2459 static_cast<uint64_t>(byte_size)); 2460 break; 2461 } 2462 } break; 2463 case lldb::eEncodingIEEE754: { 2464 lldb::offset_t offset = 0; 2465 2466 if (byte_size == sizeof(float)) 2467 operator=(data.GetFloat(&offset)); 2468 else if (byte_size == sizeof(double)) 2469 operator=(data.GetDouble(&offset)); 2470 else if (byte_size == sizeof(long double)) 2471 operator=(data.GetLongDouble(&offset)); 2472 else 2473 error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "", 2474 static_cast<uint64_t>(byte_size)); 2475 } break; 2476 } 2477 2478 return error; 2479 } 2480 2481 bool Scalar::SignExtend(uint32_t sign_bit_pos) { 2482 const uint32_t max_bit_pos = GetByteSize() * 8; 2483 2484 if (sign_bit_pos < max_bit_pos) { 2485 switch (m_type) { 2486 case Scalar::e_void: 2487 case Scalar::e_float: 2488 case Scalar::e_double: 2489 case Scalar::e_long_double: 2490 return false; 2491 2492 case Scalar::e_sint: 2493 case Scalar::e_uint: 2494 case Scalar::e_slong: 2495 case Scalar::e_ulong: 2496 case Scalar::e_slonglong: 2497 case Scalar::e_ulonglong: 2498 case Scalar::e_sint128: 2499 case Scalar::e_uint128: 2500 case Scalar::e_sint256: 2501 case Scalar::e_uint256: 2502 case Scalar::e_sint512: 2503 case Scalar::e_uint512: 2504 if (max_bit_pos == sign_bit_pos) 2505 return true; 2506 else if (sign_bit_pos < (max_bit_pos - 1)) { 2507 llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1); 2508 llvm::APInt bitwize_and = m_integer & sign_bit; 2509 if (bitwize_and.getBoolValue()) { 2510 const llvm::APInt mask = 2511 ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1); 2512 m_integer |= mask; 2513 } 2514 return true; 2515 } 2516 break; 2517 } 2518 } 2519 return false; 2520 } 2521 2522 size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len, 2523 lldb::ByteOrder dst_byte_order, 2524 Status &error) const { 2525 // Get a data extractor that points to the native scalar data 2526 DataExtractor data; 2527 if (!GetData(data)) { 2528 error.SetErrorString("invalid scalar value"); 2529 return 0; 2530 } 2531 2532 const size_t src_len = data.GetByteSize(); 2533 2534 // Prepare a memory buffer that contains some or all of the register value 2535 const size_t bytes_copied = 2536 data.CopyByteOrderedData(0, // src offset 2537 src_len, // src length 2538 dst, // dst buffer 2539 dst_len, // dst length 2540 dst_byte_order); // dst byte order 2541 if (bytes_copied == 0) 2542 error.SetErrorString("failed to copy data"); 2543 2544 return bytes_copied; 2545 } 2546 2547 bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) { 2548 if (bit_size == 0) 2549 return true; 2550 2551 switch (m_type) { 2552 case Scalar::e_void: 2553 case Scalar::e_float: 2554 case Scalar::e_double: 2555 case Scalar::e_long_double: 2556 break; 2557 2558 case Scalar::e_sint: 2559 case Scalar::e_slong: 2560 case Scalar::e_slonglong: 2561 case Scalar::e_sint128: 2562 case Scalar::e_sint256: 2563 case Scalar::e_sint512: 2564 m_integer = m_integer.ashr(bit_offset) 2565 .sextOrTrunc(bit_size) 2566 .sextOrSelf(8 * GetByteSize()); 2567 return true; 2568 2569 case Scalar::e_uint: 2570 case Scalar::e_ulong: 2571 case Scalar::e_ulonglong: 2572 case Scalar::e_uint128: 2573 case Scalar::e_uint256: 2574 case Scalar::e_uint512: 2575 m_integer = m_integer.lshr(bit_offset) 2576 .zextOrTrunc(bit_size) 2577 .zextOrSelf(8 * GetByteSize()); 2578 return true; 2579 } 2580 return false; 2581 } 2582 2583 bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) { 2584 // If either entry is void then we can just compare the types 2585 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2586 return lhs.m_type == rhs.m_type; 2587 2588 Scalar temp_value; 2589 const Scalar *a; 2590 const Scalar *b; 2591 llvm::APFloat::cmpResult result; 2592 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { 2593 case Scalar::e_void: 2594 break; 2595 case Scalar::e_sint: 2596 case Scalar::e_uint: 2597 case Scalar::e_slong: 2598 case Scalar::e_ulong: 2599 case Scalar::e_slonglong: 2600 case Scalar::e_ulonglong: 2601 case Scalar::e_sint128: 2602 case Scalar::e_uint128: 2603 case Scalar::e_sint256: 2604 case Scalar::e_uint256: 2605 case Scalar::e_sint512: 2606 case Scalar::e_uint512: 2607 return a->m_integer == b->m_integer; 2608 case Scalar::e_float: 2609 case Scalar::e_double: 2610 case Scalar::e_long_double: 2611 result = a->m_float.compare(b->m_float); 2612 if (result == llvm::APFloat::cmpEqual) 2613 return true; 2614 } 2615 return false; 2616 } 2617 2618 bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) { 2619 return !(lhs == rhs); 2620 } 2621 2622 bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) { 2623 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void) 2624 return false; 2625 2626 Scalar temp_value; 2627 const Scalar *a; 2628 const Scalar *b; 2629 llvm::APFloat::cmpResult result; 2630 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) { 2631 case Scalar::e_void: 2632 break; 2633 case Scalar::e_sint: 2634 case Scalar::e_slong: 2635 case Scalar::e_slonglong: 2636 case Scalar::e_sint128: 2637 case Scalar::e_sint256: 2638 case Scalar::e_sint512: 2639 case Scalar::e_uint512: 2640 return a->m_integer.slt(b->m_integer); 2641 case Scalar::e_uint: 2642 case Scalar::e_ulong: 2643 case Scalar::e_ulonglong: 2644 case Scalar::e_uint128: 2645 case Scalar::e_uint256: 2646 return a->m_integer.ult(b->m_integer); 2647 case Scalar::e_float: 2648 case Scalar::e_double: 2649 case Scalar::e_long_double: 2650 result = a->m_float.compare(b->m_float); 2651 if (result == llvm::APFloat::cmpLessThan) 2652 return true; 2653 } 2654 return false; 2655 } 2656 2657 bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) { 2658 return !(rhs < lhs); 2659 } 2660 2661 bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) { 2662 return rhs < lhs; 2663 } 2664 2665 bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) { 2666 return !(lhs < rhs); 2667 } 2668 2669 bool Scalar::ClearBit(uint32_t bit) { 2670 switch (m_type) { 2671 case e_void: 2672 break; 2673 case e_sint: 2674 case e_uint: 2675 case e_slong: 2676 case e_ulong: 2677 case e_slonglong: 2678 case e_ulonglong: 2679 case e_sint128: 2680 case e_uint128: 2681 case e_sint256: 2682 case e_uint256: 2683 case e_sint512: 2684 case e_uint512: 2685 m_integer.clearBit(bit); 2686 return true; 2687 case e_float: 2688 case e_double: 2689 case e_long_double: 2690 break; 2691 } 2692 return false; 2693 } 2694 2695 bool Scalar::SetBit(uint32_t bit) { 2696 switch (m_type) { 2697 case e_void: 2698 break; 2699 case e_sint: 2700 case e_uint: 2701 case e_slong: 2702 case e_ulong: 2703 case e_slonglong: 2704 case e_ulonglong: 2705 case e_sint128: 2706 case e_uint128: 2707 case e_sint256: 2708 case e_uint256: 2709 case e_sint512: 2710 case e_uint512: 2711 m_integer.setBit(bit); 2712 return true; 2713 case e_float: 2714 case e_double: 2715 case e_long_double: 2716 break; 2717 } 2718 return false; 2719 } 2720 2721 llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os, const Scalar &scalar) { 2722 StreamString s; 2723 scalar.GetValue(&s, /*show_type*/ true); 2724 return os << s.GetString(); 2725 } 2726