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