lib/DebugInfo/DWARF/DWARFFormValue.cpp

   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