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