1 //===-- DWARFFormValue.cpp ------------------------------------------------===// 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 "SyntaxHighlighting.h" 11 #include "llvm/ADT/ArrayRef.h" 12 #include "llvm/ADT/StringRef.h" 13 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" 14 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 15 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 16 #include "llvm/Support/Debug.h" 17 #include "llvm/Support/Dwarf.h" 18 #include "llvm/Support/Format.h" 19 #include "llvm/Support/raw_ostream.h" 20 #include <cassert> 21 #include <limits> 22 using namespace llvm; 23 using namespace dwarf; 24 using namespace syntax; 25 26 static const DWARFFormValue::FormClass DWARF4FormClasses[] = { 27 DWARFFormValue::FC_Unknown, // 0x0 28 DWARFFormValue::FC_Address, // 0x01 DW_FORM_addr 29 DWARFFormValue::FC_Unknown, // 0x02 unused 30 DWARFFormValue::FC_Block, // 0x03 DW_FORM_block2 31 DWARFFormValue::FC_Block, // 0x04 DW_FORM_block4 32 DWARFFormValue::FC_Constant, // 0x05 DW_FORM_data2 33 // --- These can be FC_SectionOffset in DWARF3 and below: 34 DWARFFormValue::FC_Constant, // 0x06 DW_FORM_data4 35 DWARFFormValue::FC_Constant, // 0x07 DW_FORM_data8 36 // --- 37 DWARFFormValue::FC_String, // 0x08 DW_FORM_string 38 DWARFFormValue::FC_Block, // 0x09 DW_FORM_block 39 DWARFFormValue::FC_Block, // 0x0a DW_FORM_block1 40 DWARFFormValue::FC_Constant, // 0x0b DW_FORM_data1 41 DWARFFormValue::FC_Flag, // 0x0c DW_FORM_flag 42 DWARFFormValue::FC_Constant, // 0x0d DW_FORM_sdata 43 DWARFFormValue::FC_String, // 0x0e DW_FORM_strp 44 DWARFFormValue::FC_Constant, // 0x0f DW_FORM_udata 45 DWARFFormValue::FC_Reference, // 0x10 DW_FORM_ref_addr 46 DWARFFormValue::FC_Reference, // 0x11 DW_FORM_ref1 47 DWARFFormValue::FC_Reference, // 0x12 DW_FORM_ref2 48 DWARFFormValue::FC_Reference, // 0x13 DW_FORM_ref4 49 DWARFFormValue::FC_Reference, // 0x14 DW_FORM_ref8 50 DWARFFormValue::FC_Reference, // 0x15 DW_FORM_ref_udata 51 DWARFFormValue::FC_Indirect, // 0x16 DW_FORM_indirect 52 DWARFFormValue::FC_SectionOffset, // 0x17 DW_FORM_sec_offset 53 DWARFFormValue::FC_Exprloc, // 0x18 DW_FORM_exprloc 54 DWARFFormValue::FC_Flag, // 0x19 DW_FORM_flag_present 55 }; 56 57 namespace { 58 59 /// A helper class that can be used in DWARFFormValue.cpp functions that need 60 /// to know the byte size of DW_FORM values that vary in size depending on the 61 /// DWARF version, address byte size, or DWARF32 or DWARF64. 62 class FormSizeHelper { 63 uint16_t Version; 64 uint8_t AddrSize; 65 llvm::dwarf::DwarfFormat Format; 66 67 public: 68 FormSizeHelper(uint16_t V, uint8_t A, llvm::dwarf::DwarfFormat F) 69 : Version(V), AddrSize(A), Format(F) {} 70 uint8_t getAddressByteSize() const { return AddrSize; } 71 uint8_t getRefAddrByteSize() const { 72 if (Version == 2) 73 return AddrSize; 74 return getDwarfOffsetByteSize(); 75 } 76 uint8_t getDwarfOffsetByteSize() const { 77 switch (Format) { 78 case dwarf::DwarfFormat::DWARF32: 79 return 4; 80 case dwarf::DwarfFormat::DWARF64: 81 return 8; 82 } 83 llvm_unreachable("Invalid Format value"); 84 } 85 }; 86 87 } // end anonymous namespace 88 89 template <class T> 90 static Optional<uint8_t> getFixedByteSize(dwarf::Form Form, const T *U) { 91 switch (Form) { 92 case DW_FORM_addr: 93 if (U) 94 return U->getAddressByteSize(); 95 return None; 96 97 case DW_FORM_block: // ULEB128 length L followed by L bytes. 98 case DW_FORM_block1: // 1 byte length L followed by L bytes. 99 case DW_FORM_block2: // 2 byte length L followed by L bytes. 100 case DW_FORM_block4: // 4 byte length L followed by L bytes. 101 case DW_FORM_string: // C-string with null terminator. 102 case DW_FORM_sdata: // SLEB128. 103 case DW_FORM_udata: // ULEB128. 104 case DW_FORM_ref_udata: // ULEB128. 105 case DW_FORM_indirect: // ULEB128. 106 case DW_FORM_exprloc: // ULEB128 length L followed by L bytes. 107 case DW_FORM_strx: // ULEB128. 108 case DW_FORM_addrx: // ULEB128. 109 case DW_FORM_loclistx: // ULEB128. 110 case DW_FORM_rnglistx: // ULEB128. 111 case DW_FORM_GNU_addr_index: // ULEB128. 112 case DW_FORM_GNU_str_index: // ULEB128. 113 return None; 114 115 case DW_FORM_ref_addr: 116 if (U) 117 return U->getRefAddrByteSize(); 118 return None; 119 120 case DW_FORM_flag: 121 case DW_FORM_data1: 122 case DW_FORM_ref1: 123 return 1; 124 125 case DW_FORM_data2: 126 case DW_FORM_ref2: 127 return 2; 128 129 case DW_FORM_data4: 130 case DW_FORM_ref4: 131 return 4; 132 133 case DW_FORM_strp: 134 case DW_FORM_GNU_ref_alt: 135 case DW_FORM_GNU_strp_alt: 136 case DW_FORM_line_strp: 137 case DW_FORM_sec_offset: 138 case DW_FORM_strp_sup: 139 case DW_FORM_ref_sup: 140 if (U) 141 return U->getDwarfOffsetByteSize(); 142 return None; 143 144 case DW_FORM_data8: 145 case DW_FORM_ref8: 146 case DW_FORM_ref_sig8: 147 return 8; 148 149 case DW_FORM_flag_present: 150 return 0; 151 152 case DW_FORM_data16: 153 return 16; 154 155 case DW_FORM_implicit_const: 156 // The implicit value is stored in the abbreviation as a ULEB128, any 157 // there no data in debug info. 158 return 0; 159 160 default: 161 llvm_unreachable("Handle this form in this switch statement"); 162 } 163 return None; 164 } 165 166 template <class T> 167 static bool skipFormValue(dwarf::Form Form, const DataExtractor &DebugInfoData, 168 uint32_t *OffsetPtr, const T *U) { 169 bool Indirect = false; 170 do { 171 switch (Form) { 172 // Blocks of inlined data that have a length field and the data bytes 173 // inlined in the .debug_info. 174 case DW_FORM_exprloc: 175 case DW_FORM_block: { 176 uint64_t size = DebugInfoData.getULEB128(OffsetPtr); 177 *OffsetPtr += size; 178 return true; 179 } 180 case DW_FORM_block1: { 181 uint8_t size = DebugInfoData.getU8(OffsetPtr); 182 *OffsetPtr += size; 183 return true; 184 } 185 case DW_FORM_block2: { 186 uint16_t size = DebugInfoData.getU16(OffsetPtr); 187 *OffsetPtr += size; 188 return true; 189 } 190 case DW_FORM_block4: { 191 uint32_t size = DebugInfoData.getU32(OffsetPtr); 192 *OffsetPtr += size; 193 return true; 194 } 195 196 // Inlined NULL terminated C-strings. 197 case DW_FORM_string: 198 DebugInfoData.getCStr(OffsetPtr); 199 return true; 200 201 case DW_FORM_addr: 202 case DW_FORM_ref_addr: 203 case DW_FORM_flag_present: 204 case DW_FORM_data1: 205 case DW_FORM_data2: 206 case DW_FORM_data4: 207 case DW_FORM_data8: 208 case DW_FORM_flag: 209 case DW_FORM_ref1: 210 case DW_FORM_ref2: 211 case DW_FORM_ref4: 212 case DW_FORM_ref8: 213 case DW_FORM_ref_sig8: 214 case DW_FORM_ref_sup: 215 case DW_FORM_sec_offset: 216 case DW_FORM_strp: 217 case DW_FORM_strp_sup: 218 case DW_FORM_line_strp: 219 case DW_FORM_GNU_ref_alt: 220 case DW_FORM_GNU_strp_alt: 221 if (Optional<uint8_t> FixedSize = ::getFixedByteSize(Form, U)) { 222 *OffsetPtr += *FixedSize; 223 return true; 224 } 225 return false; 226 227 // signed or unsigned LEB 128 values. 228 case DW_FORM_sdata: 229 DebugInfoData.getSLEB128(OffsetPtr); 230 return true; 231 232 case DW_FORM_udata: 233 case DW_FORM_ref_udata: 234 case DW_FORM_strx: 235 case DW_FORM_addrx: 236 case DW_FORM_loclistx: 237 case DW_FORM_rnglistx: 238 case DW_FORM_GNU_addr_index: 239 case DW_FORM_GNU_str_index: 240 DebugInfoData.getULEB128(OffsetPtr); 241 return true; 242 243 case DW_FORM_indirect: 244 Indirect = true; 245 Form = static_cast<dwarf::Form>(DebugInfoData.getULEB128(OffsetPtr)); 246 break; 247 248 default: 249 return false; 250 } 251 } while (Indirect); 252 return true; 253 } 254 255 Optional<uint8_t> DWARFFormValue::getFixedByteSize(dwarf::Form Form, 256 const DWARFUnit *U) { 257 return ::getFixedByteSize(Form, U); 258 } 259 260 Optional<uint8_t> 261 DWARFFormValue::getFixedByteSize(dwarf::Form Form, uint16_t Version, 262 uint8_t AddrSize, 263 llvm::dwarf::DwarfFormat Format) { 264 FormSizeHelper FSH(Version, AddrSize, Format); 265 return ::getFixedByteSize(Form, &FSH); 266 } 267 268 bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const { 269 // First, check DWARF4 form classes. 270 if (Form < makeArrayRef(DWARF4FormClasses).size() && 271 DWARF4FormClasses[Form] == FC) 272 return true; 273 // Check more forms from DWARF4 and DWARF5 proposals. 274 switch (Form) { 275 case DW_FORM_ref_sig8: 276 case DW_FORM_GNU_ref_alt: 277 return (FC == FC_Reference); 278 case DW_FORM_GNU_addr_index: 279 return (FC == FC_Address); 280 case DW_FORM_GNU_str_index: 281 case DW_FORM_GNU_strp_alt: 282 return (FC == FC_String); 283 default: 284 break; 285 } 286 // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset. 287 // Don't check for DWARF version here, as some producers may still do this 288 // by mistake. 289 return (Form == DW_FORM_data4 || Form == DW_FORM_data8) && 290 FC == FC_SectionOffset; 291 } 292 293 bool DWARFFormValue::extractValue(const DataExtractor &data, 294 uint32_t *offset_ptr, 295 const DWARFUnit *cu) { 296 U = cu; 297 bool indirect = false; 298 bool is_block = false; 299 Value.data = nullptr; 300 // Read the value for the form into value and follow and DW_FORM_indirect 301 // instances we run into 302 do { 303 indirect = false; 304 switch (Form) { 305 case DW_FORM_addr: 306 case DW_FORM_ref_addr: { 307 if (!U) 308 return false; 309 uint16_t AddrSize = 310 (Form == DW_FORM_addr) 311 ? U->getAddressByteSize() 312 : U->getRefAddrByteSize(); 313 RelocAddrMap::const_iterator AI = U->getRelocMap()->find(*offset_ptr); 314 if (AI != U->getRelocMap()->end()) { 315 Value.uval = data.getUnsigned(offset_ptr, AddrSize) + AI->second.second; 316 } else 317 Value.uval = data.getUnsigned(offset_ptr, AddrSize); 318 break; 319 } 320 case DW_FORM_exprloc: 321 case DW_FORM_block: 322 Value.uval = data.getULEB128(offset_ptr); 323 is_block = true; 324 break; 325 case DW_FORM_block1: 326 Value.uval = data.getU8(offset_ptr); 327 is_block = true; 328 break; 329 case DW_FORM_block2: 330 Value.uval = data.getU16(offset_ptr); 331 is_block = true; 332 break; 333 case DW_FORM_block4: 334 Value.uval = data.getU32(offset_ptr); 335 is_block = true; 336 break; 337 case DW_FORM_data1: 338 case DW_FORM_ref1: 339 case DW_FORM_flag: 340 Value.uval = data.getU8(offset_ptr); 341 break; 342 case DW_FORM_data2: 343 case DW_FORM_ref2: 344 Value.uval = data.getU16(offset_ptr); 345 break; 346 case DW_FORM_data4: 347 case DW_FORM_ref4: { 348 Value.uval = data.getU32(offset_ptr); 349 if (!U) 350 break; 351 RelocAddrMap::const_iterator AI = U->getRelocMap()->find(*offset_ptr-4); 352 if (AI != U->getRelocMap()->end()) 353 Value.uval += AI->second.second; 354 break; 355 } 356 case DW_FORM_data8: 357 case DW_FORM_ref8: 358 Value.uval = data.getU64(offset_ptr); 359 break; 360 case DW_FORM_sdata: 361 Value.sval = data.getSLEB128(offset_ptr); 362 break; 363 case DW_FORM_udata: 364 case DW_FORM_ref_udata: 365 Value.uval = data.getULEB128(offset_ptr); 366 break; 367 case DW_FORM_string: 368 Value.cstr = data.getCStr(offset_ptr); 369 break; 370 case DW_FORM_indirect: 371 Form = static_cast<dwarf::Form>(data.getULEB128(offset_ptr)); 372 indirect = true; 373 break; 374 case DW_FORM_strp: 375 case DW_FORM_sec_offset: 376 case DW_FORM_GNU_ref_alt: 377 case DW_FORM_GNU_strp_alt: 378 case DW_FORM_line_strp: 379 case DW_FORM_strp_sup: 380 case DW_FORM_ref_sup: { 381 if (!U) 382 return false; 383 RelocAddrMap::const_iterator AI = U->getRelocMap()->find(*offset_ptr); 384 uint8_t Size = U->getDwarfOffsetByteSize(); 385 Value.uval = data.getUnsigned(offset_ptr, Size); 386 if (AI != U->getRelocMap()->end()) 387 Value.uval += AI->second.second; 388 break; 389 } 390 case DW_FORM_flag_present: 391 Value.uval = 1; 392 break; 393 case DW_FORM_ref_sig8: 394 Value.uval = data.getU64(offset_ptr); 395 break; 396 case DW_FORM_GNU_addr_index: 397 case DW_FORM_GNU_str_index: 398 Value.uval = data.getULEB128(offset_ptr); 399 break; 400 default: 401 return false; 402 } 403 } while (indirect); 404 405 if (is_block) { 406 StringRef str = data.getData().substr(*offset_ptr, Value.uval); 407 Value.data = nullptr; 408 if (!str.empty()) { 409 Value.data = reinterpret_cast<const uint8_t *>(str.data()); 410 *offset_ptr += Value.uval; 411 } 412 } 413 414 return true; 415 } 416 417 bool DWARFFormValue::skipValue(DataExtractor DebugInfoData, 418 uint32_t *offset_ptr, const DWARFUnit *U) const { 419 return DWARFFormValue::skipValue(Form, DebugInfoData, offset_ptr, U); 420 } 421 422 bool DWARFFormValue::skipValue(dwarf::Form form, DataExtractor DebugInfoData, 423 uint32_t *offset_ptr, const DWARFUnit *U) { 424 return skipFormValue(form, DebugInfoData, offset_ptr, U); 425 } 426 427 bool DWARFFormValue::skipValue(dwarf::Form form, DataExtractor DebugInfoData, 428 uint32_t *offset_ptr, uint16_t Version, 429 uint8_t AddrSize, 430 llvm::dwarf::DwarfFormat Format) { 431 FormSizeHelper FSH(Version, AddrSize, Format); 432 return skipFormValue(form, DebugInfoData, offset_ptr, &FSH); 433 } 434 435 void 436 DWARFFormValue::dump(raw_ostream &OS) const { 437 uint64_t uvalue = Value.uval; 438 bool cu_relative_offset = false; 439 440 switch (Form) { 441 case DW_FORM_addr: OS << format("0x%016" PRIx64, uvalue); break; 442 case DW_FORM_GNU_addr_index: { 443 OS << format(" indexed (%8.8x) address = ", (uint32_t)uvalue); 444 uint64_t Address; 445 if (U == nullptr) 446 OS << "<invalid dwarf unit>"; 447 else if (U->getAddrOffsetSectionItem(uvalue, Address)) 448 OS << format("0x%016" PRIx64, Address); 449 else 450 OS << "<no .debug_addr section>"; 451 break; 452 } 453 case DW_FORM_flag_present: OS << "true"; break; 454 case DW_FORM_flag: 455 case DW_FORM_data1: OS << format("0x%02x", (uint8_t)uvalue); break; 456 case DW_FORM_data2: OS << format("0x%04x", (uint16_t)uvalue); break; 457 case DW_FORM_data4: OS << format("0x%08x", (uint32_t)uvalue); break; 458 case DW_FORM_ref_sig8: 459 case DW_FORM_data8: OS << format("0x%016" PRIx64, uvalue); break; 460 case DW_FORM_string: 461 OS << '"'; 462 OS.write_escaped(Value.cstr); 463 OS << '"'; 464 break; 465 case DW_FORM_exprloc: 466 case DW_FORM_block: 467 case DW_FORM_block1: 468 case DW_FORM_block2: 469 case DW_FORM_block4: 470 if (uvalue > 0) { 471 switch (Form) { 472 case DW_FORM_exprloc: 473 case DW_FORM_block: OS << format("<0x%" PRIx64 "> ", uvalue); break; 474 case DW_FORM_block1: OS << format("<0x%2.2x> ", (uint8_t)uvalue); break; 475 case DW_FORM_block2: OS << format("<0x%4.4x> ", (uint16_t)uvalue); break; 476 case DW_FORM_block4: OS << format("<0x%8.8x> ", (uint32_t)uvalue); break; 477 default: break; 478 } 479 480 const uint8_t* data_ptr = Value.data; 481 if (data_ptr) { 482 // uvalue contains size of block 483 const uint8_t* end_data_ptr = data_ptr + uvalue; 484 while (data_ptr < end_data_ptr) { 485 OS << format("%2.2x ", *data_ptr); 486 ++data_ptr; 487 } 488 } 489 else 490 OS << "NULL"; 491 } 492 break; 493 494 case DW_FORM_sdata: OS << Value.sval; break; 495 case DW_FORM_udata: OS << Value.uval; break; 496 case DW_FORM_strp: { 497 OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue); 498 dumpString(OS); 499 break; 500 } 501 case DW_FORM_GNU_str_index: { 502 OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue); 503 dumpString(OS); 504 break; 505 } 506 case DW_FORM_GNU_strp_alt: { 507 OS << format("alt indirect string, offset: 0x%" PRIx64 "", uvalue); 508 dumpString(OS); 509 break; 510 } 511 case DW_FORM_ref_addr: 512 OS << format("0x%016" PRIx64, uvalue); 513 break; 514 case DW_FORM_ref1: 515 cu_relative_offset = true; 516 OS << format("cu + 0x%2.2x", (uint8_t)uvalue); 517 break; 518 case DW_FORM_ref2: 519 cu_relative_offset = true; 520 OS << format("cu + 0x%4.4x", (uint16_t)uvalue); 521 break; 522 case DW_FORM_ref4: 523 cu_relative_offset = true; 524 OS << format("cu + 0x%4.4x", (uint32_t)uvalue); 525 break; 526 case DW_FORM_ref8: 527 cu_relative_offset = true; 528 OS << format("cu + 0x%8.8" PRIx64, uvalue); 529 break; 530 case DW_FORM_ref_udata: 531 cu_relative_offset = true; 532 OS << format("cu + 0x%" PRIx64, uvalue); 533 break; 534 case DW_FORM_GNU_ref_alt: 535 OS << format("<alt 0x%" PRIx64 ">", uvalue); 536 break; 537 538 // All DW_FORM_indirect attributes should be resolved prior to calling 539 // this function 540 case DW_FORM_indirect: 541 OS << "DW_FORM_indirect"; 542 break; 543 544 // Should be formatted to 64-bit for DWARF64. 545 case DW_FORM_sec_offset: 546 OS << format("0x%08x", (uint32_t)uvalue); 547 break; 548 549 default: 550 OS << format("DW_FORM(0x%4.4x)", Form); 551 break; 552 } 553 554 if (cu_relative_offset) { 555 OS << " => {"; 556 WithColor(OS, syntax::Address).get() 557 << format("0x%8.8" PRIx64, uvalue + (U ? U->getOffset() : 0)); 558 OS << "}"; 559 } 560 } 561 562 void DWARFFormValue::dumpString(raw_ostream &OS) const { 563 Optional<const char *> DbgStr = getAsCString(); 564 if (DbgStr.hasValue()) { 565 raw_ostream &COS = WithColor(OS, syntax::String); 566 COS << '"'; 567 COS.write_escaped(DbgStr.getValue()); 568 COS << '"'; 569 } 570 } 571 572 Optional<const char *> DWARFFormValue::getAsCString() const { 573 if (!isFormClass(FC_String)) 574 return None; 575 if (Form == DW_FORM_string) 576 return Value.cstr; 577 // FIXME: Add support for DW_FORM_GNU_strp_alt 578 if (Form == DW_FORM_GNU_strp_alt || U == nullptr) 579 return None; 580 uint32_t Offset = Value.uval; 581 if (Form == DW_FORM_GNU_str_index) { 582 uint32_t StrOffset; 583 if (!U->getStringOffsetSectionItem(Offset, StrOffset)) 584 return None; 585 Offset = StrOffset; 586 } 587 if (const char *Str = U->getStringExtractor().getCStr(&Offset)) { 588 return Str; 589 } 590 return None; 591 } 592 593 Optional<uint64_t> DWARFFormValue::getAsAddress() const { 594 if (!isFormClass(FC_Address)) 595 return None; 596 if (Form == DW_FORM_GNU_addr_index) { 597 uint32_t Index = Value.uval; 598 uint64_t Result; 599 if (!U || !U->getAddrOffsetSectionItem(Index, Result)) 600 return None; 601 return Result; 602 } 603 return Value.uval; 604 } 605 606 Optional<uint64_t> DWARFFormValue::getAsReference() const { 607 if (!isFormClass(FC_Reference)) 608 return None; 609 switch (Form) { 610 case DW_FORM_ref1: 611 case DW_FORM_ref2: 612 case DW_FORM_ref4: 613 case DW_FORM_ref8: 614 case DW_FORM_ref_udata: 615 if (!U) 616 return None; 617 return Value.uval + U->getOffset(); 618 case DW_FORM_ref_addr: 619 case DW_FORM_ref_sig8: 620 case DW_FORM_GNU_ref_alt: 621 return Value.uval; 622 default: 623 return None; 624 } 625 } 626 627 Optional<uint64_t> DWARFFormValue::getAsSectionOffset() const { 628 if (!isFormClass(FC_SectionOffset)) 629 return None; 630 return Value.uval; 631 } 632 633 Optional<uint64_t> DWARFFormValue::getAsUnsignedConstant() const { 634 if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) 635 || Form == DW_FORM_sdata) 636 return None; 637 return Value.uval; 638 } 639 640 Optional<int64_t> DWARFFormValue::getAsSignedConstant() const { 641 if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) || 642 (Form == DW_FORM_udata && uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval)) 643 return None; 644 switch (Form) { 645 case DW_FORM_data4: 646 return int32_t(Value.uval); 647 case DW_FORM_data2: 648 return int16_t(Value.uval); 649 case DW_FORM_data1: 650 return int8_t(Value.uval); 651 case DW_FORM_sdata: 652 case DW_FORM_data8: 653 default: 654 return Value.sval; 655 } 656 } 657 658 Optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const { 659 if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc)) 660 return None; 661 return makeArrayRef(Value.data, Value.uval); 662 } 663 664