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