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