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