lib/DebugInfo/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/DWARFFormValue.h"
  11 #include "DWARFCompileUnit.h"
  12 #include "DWARFContext.h"
  13 #include "llvm/Support/Debug.h"
  14 #include "llvm/Support/Dwarf.h"
  15 #include "llvm/Support/Format.h"
  16 #include "llvm/Support/raw_ostream.h"
  17 #include <cassert>
  18 using namespace llvm;
  19 using namespace dwarf;
  20
  21 namespace {
  22 template <uint8_t AddrSize, uint8_t RefAddrSize> struct FixedFormSizes {
  23   static const uint8_t sizes[];
  24 };
  25 }
  26
  27 template <uint8_t AddrSize, uint8_t RefAddrSize>
  28 const uint8_t FixedFormSizes<AddrSize, RefAddrSize>::sizes[] = {
  29   0,           // 0x00 unused
  30   AddrSize,    // 0x01 DW_FORM_addr
  31   0,           // 0x02 unused
  32   0,           // 0x03 DW_FORM_block2
  33   0,           // 0x04 DW_FORM_block4
  34   2,           // 0x05 DW_FORM_data2
  35   4,           // 0x06 DW_FORM_data4
  36   8,           // 0x07 DW_FORM_data8
  37   0,           // 0x08 DW_FORM_string
  38   0,           // 0x09 DW_FORM_block
  39   0,           // 0x0a DW_FORM_block1
  40   1,           // 0x0b DW_FORM_data1
  41   1,           // 0x0c DW_FORM_flag
  42   0,           // 0x0d DW_FORM_sdata
  43   4,           // 0x0e DW_FORM_strp
  44   0,           // 0x0f DW_FORM_udata
  45   RefAddrSize, // 0x10 DW_FORM_ref_addr
  46   1,           // 0x11 DW_FORM_ref1
  47   2,           // 0x12 DW_FORM_ref2
  48   4,           // 0x13 DW_FORM_ref4
  49   8,           // 0x14 DW_FORM_ref8
  50   0,           // 0x15 DW_FORM_ref_udata
  51   0,           // 0x16 DW_FORM_indirect
  52   4,           // 0x17 DW_FORM_sec_offset
  53   0,           // 0x18 DW_FORM_exprloc
  54   0,           // 0x19 DW_FORM_flag_present
  55   8,           // 0x20 DW_FORM_ref_sig8
  56 };
  57
  58 static uint8_t getRefAddrSize(uint8_t AddrSize, uint16_t Version) {
  59   // FIXME: Support DWARF64.
  60   return (Version == 2) ? AddrSize : 4;
  61 }
  62
  63 const uint8_t *
  64 DWARFFormValue::getFixedFormSizes(uint8_t AddrSize, uint16_t Version) {
  65   uint8_t RefAddrSize = getRefAddrSize(AddrSize, Version);
  66   if (AddrSize == 4 && RefAddrSize == 4)
  67     return FixedFormSizes<4, 4>::sizes;
  68   if (AddrSize == 4 && RefAddrSize == 8)
  69     return FixedFormSizes<4, 8>::sizes;
  70   if (AddrSize == 8 && RefAddrSize == 4)
  71     return FixedFormSizes<8, 4>::sizes;
  72   if (AddrSize == 8 && RefAddrSize == 8)
  73     return FixedFormSizes<8, 8>::sizes;
  74   return 0;
  75 }
  76
  77 bool
  78 DWARFFormValue::extractValue(DataExtractor data, uint32_t *offset_ptr,
  79                              const DWARFCompileUnit *cu) {
  80   bool indirect = false;
  81   bool is_block = false;
  82   Value.data = NULL;
  83   // Read the value for the form into value and follow and DW_FORM_indirect
  84   // instances we run into
  85   do {
  86     indirect = false;
  87     switch (Form) {
  88     case DW_FORM_addr:
  89     case DW_FORM_ref_addr: {
  90       uint16_t AddrSize =
  91           (Form == DW_FORM_addr)
  92               ? cu->getAddressByteSize()
  93               : getRefAddrSize(cu->getAddressByteSize(), cu->getVersion());
  94       RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr);
  95       if (AI != cu->getRelocMap()->end()) {
  96         const std::pair<uint8_t, int64_t> &R = AI->second;
  97         Value.uval = data.getUnsigned(offset_ptr, AddrSize) + R.second;
  98       } else
  99         Value.uval = data.getUnsigned(offset_ptr, AddrSize);
 100       break;
 101     }
 102     case DW_FORM_exprloc:
 103     case DW_FORM_block:
 104       Value.uval = data.getULEB128(offset_ptr);
 105       is_block = true;
 106       break;
 107     case DW_FORM_block1:
 108       Value.uval = data.getU8(offset_ptr);
 109       is_block = true;
 110       break;
 111     case DW_FORM_block2:
 112       Value.uval = data.getU16(offset_ptr);
 113       is_block = true;
 114       break;
 115     case DW_FORM_block4:
 116       Value.uval = data.getU32(offset_ptr);
 117       is_block = true;
 118       break;
 119     case DW_FORM_data1:
 120     case DW_FORM_ref1:
 121     case DW_FORM_flag:
 122       Value.uval = data.getU8(offset_ptr);
 123       break;
 124     case DW_FORM_data2:
 125     case DW_FORM_ref2:
 126       Value.uval = data.getU16(offset_ptr);
 127       break;
 128     case DW_FORM_data4:
 129     case DW_FORM_ref4: {
 130       RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr);
 131       Value.uval = data.getU32(offset_ptr);
 132       if (AI != cu->getRelocMap()->end())
 133         Value.uval += AI->second.second;
 134       break;
 135     }
 136     case DW_FORM_data8:
 137     case DW_FORM_ref8:
 138       Value.uval = data.getU64(offset_ptr);
 139       break;
 140     case DW_FORM_sdata:
 141       Value.sval = data.getSLEB128(offset_ptr);
 142       break;
 143     case DW_FORM_strp: {
 144       RelocAddrMap::const_iterator AI
 145         = cu->getRelocMap()->find(*offset_ptr);
 146       if (AI != cu->getRelocMap()->end()) {
 147         const std::pair<uint8_t, int64_t> &R = AI->second;
 148         Value.uval = data.getU32(offset_ptr) + R.second;
 149       } else
 150         Value.uval = data.getU32(offset_ptr);
 151       break;
 152     }
 153     case DW_FORM_udata:
 154     case DW_FORM_ref_udata:
 155       Value.uval = data.getULEB128(offset_ptr);
 156       break;
 157     case DW_FORM_string:
 158       Value.cstr = data.getCStr(offset_ptr);
 159       // Set the string value to also be the data for inlined cstr form
 160       // values only so we can tell the differnence between DW_FORM_string
 161       // and DW_FORM_strp form values
 162       Value.data = (const uint8_t*)Value.cstr;
 163       break;
 164     case DW_FORM_indirect:
 165       Form = data.getULEB128(offset_ptr);
 166       indirect = true;
 167       break;
 168     case DW_FORM_sec_offset: {
 169       // FIXME: This is 64-bit for DWARF64.
 170       RelocAddrMap::const_iterator AI
 171         = cu->getRelocMap()->find(*offset_ptr);
 172       if (AI != cu->getRelocMap()->end()) {
 173         const std::pair<uint8_t, int64_t> &R = AI->second;
 174         Value.uval = data.getU32(offset_ptr) + R.second;
 175       } else
 176         Value.uval = data.getU32(offset_ptr);
 177       break;
 178     }
 179     case DW_FORM_flag_present:
 180       Value.uval = 1;
 181       break;
 182     case DW_FORM_ref_sig8:
 183       Value.uval = data.getU64(offset_ptr);
 184       break;
 185     case DW_FORM_GNU_addr_index:
 186     case DW_FORM_GNU_str_index:
 187       Value.uval = data.getULEB128(offset_ptr);
 188       Value.IsDWOIndex = true;
 189       break;
 190     default:
 191       return false;
 192     }
 193   } while (indirect);
 194
 195   if (is_block) {
 196     StringRef str = data.getData().substr(*offset_ptr, Value.uval);
 197     Value.data = NULL;
 198     if (!str.empty()) {
 199       Value.data = reinterpret_cast<const uint8_t *>(str.data());
 200       *offset_ptr += Value.uval;
 201     }
 202   }
 203
 204   return true;
 205 }
 206
 207 bool
 208 DWARFFormValue::skipValue(DataExtractor debug_info_data, uint32_t* offset_ptr,
 209                           const DWARFCompileUnit *cu) const {
 210   return DWARFFormValue::skipValue(Form, debug_info_data, offset_ptr, cu);
 211 }
 212
 213 bool
 214 DWARFFormValue::skipValue(uint16_t form, DataExtractor debug_info_data,
 215                           uint32_t *offset_ptr, const DWARFCompileUnit *cu) {
 216   bool indirect = false;
 217   do {
 218     switch (form) {
 219     // Blocks if inlined data that have a length field and the data bytes
 220     // inlined in the .debug_info
 221     case DW_FORM_exprloc:
 222     case DW_FORM_block: {
 223       uint64_t size = debug_info_data.getULEB128(offset_ptr);
 224       *offset_ptr += size;
 225       return true;
 226     }
 227     case DW_FORM_block1: {
 228       uint8_t size = debug_info_data.getU8(offset_ptr);
 229       *offset_ptr += size;
 230       return true;
 231     }
 232     case DW_FORM_block2: {
 233       uint16_t size = debug_info_data.getU16(offset_ptr);
 234       *offset_ptr += size;
 235       return true;
 236     }
 237     case DW_FORM_block4: {
 238       uint32_t size = debug_info_data.getU32(offset_ptr);
 239       *offset_ptr += size;
 240       return true;
 241     }
 242
 243     // Inlined NULL terminated C-strings
 244     case DW_FORM_string:
 245       debug_info_data.getCStr(offset_ptr);
 246       return true;
 247
 248     // Compile unit address sized values
 249     case DW_FORM_addr:
 250       *offset_ptr += cu->getAddressByteSize();
 251       return true;
 252     case DW_FORM_ref_addr:
 253       *offset_ptr += getRefAddrSize(cu->getAddressByteSize(), cu->getVersion());
 254       return true;
 255
 256     // 0 byte values - implied from the form.
 257     case DW_FORM_flag_present:
 258       return true;
 259
 260     // 1 byte values
 261     case DW_FORM_data1:
 262     case DW_FORM_flag:
 263     case DW_FORM_ref1:
 264       *offset_ptr += 1;
 265       return true;
 266
 267     // 2 byte values
 268     case DW_FORM_data2:
 269     case DW_FORM_ref2:
 270       *offset_ptr += 2;
 271       return true;
 272
 273     // 4 byte values
 274     case DW_FORM_strp:
 275     case DW_FORM_data4:
 276     case DW_FORM_ref4:
 277       *offset_ptr += 4;
 278       return true;
 279
 280     // 8 byte values
 281     case DW_FORM_data8:
 282     case DW_FORM_ref8:
 283     case DW_FORM_ref_sig8:
 284       *offset_ptr += 8;
 285       return true;
 286
 287     // signed or unsigned LEB 128 values
 288     //  case DW_FORM_APPLE_db_str:
 289     case DW_FORM_sdata:
 290     case DW_FORM_udata:
 291     case DW_FORM_ref_udata:
 292     case DW_FORM_GNU_str_index:
 293     case DW_FORM_GNU_addr_index:
 294       debug_info_data.getULEB128(offset_ptr);
 295       return true;
 296
 297     case DW_FORM_indirect:
 298       indirect = true;
 299       form = debug_info_data.getULEB128(offset_ptr);
 300       break;
 301
 302     // FIXME: 4 for DWARF32, 8 for DWARF64.
 303     case DW_FORM_sec_offset:
 304       *offset_ptr += 4;
 305       return true;
 306
 307     default:
 308       return false;
 309     }
 310   } while (indirect);
 311   return true;
 312 }
 313
 314 void
 315 DWARFFormValue::dump(raw_ostream &OS, const DWARFCompileUnit *cu) const {
 316   DataExtractor debug_str_data(cu->getStringSection(), true, 0);
 317   DataExtractor debug_str_offset_data(cu->getStringOffsetSection(), true, 0);
 318   uint64_t uvalue = getUnsigned();
 319   bool cu_relative_offset = false;
 320
 321   switch (Form) {
 322   case DW_FORM_addr:      OS << format("0x%016" PRIx64, uvalue); break;
 323   case DW_FORM_GNU_addr_index: {
 324     OS << format(" indexed (%8.8x) address = ", (uint32_t)uvalue);
 325     uint64_t Address;
 326     if (cu->getAddrOffsetSectionItem(uvalue, Address))
 327       OS << format("0x%016" PRIx64, Address);
 328     else
 329       OS << "<no .debug_addr section>";
 330     break;
 331   }
 332   case DW_FORM_flag_present: OS << "true"; break;
 333   case DW_FORM_flag:
 334   case DW_FORM_data1:     OS << format("0x%02x", (uint8_t)uvalue); break;
 335   case DW_FORM_data2:     OS << format("0x%04x", (uint16_t)uvalue); break;
 336   case DW_FORM_data4:     OS << format("0x%08x", (uint32_t)uvalue); break;
 337   case DW_FORM_ref_sig8:
 338   case DW_FORM_data8:     OS << format("0x%016" PRIx64, uvalue); break;
 339   case DW_FORM_string:
 340     OS << '"';
 341     OS.write_escaped(getAsCString(NULL));
 342     OS << '"';
 343     break;
 344   case DW_FORM_exprloc:
 345   case DW_FORM_block:
 346   case DW_FORM_block1:
 347   case DW_FORM_block2:
 348   case DW_FORM_block4:
 349     if (uvalue > 0) {
 350       switch (Form) {
 351       case DW_FORM_exprloc:
 352       case DW_FORM_block:  OS << format("<0x%" PRIx64 "> ", uvalue);     break;
 353       case DW_FORM_block1: OS << format("<0x%2.2x> ", (uint8_t)uvalue);  break;
 354       case DW_FORM_block2: OS << format("<0x%4.4x> ", (uint16_t)uvalue); break;
 355       case DW_FORM_block4: OS << format("<0x%8.8x> ", (uint32_t)uvalue); break;
 356       default: break;
 357       }
 358
 359       const uint8_t* data_ptr = Value.data;
 360       if (data_ptr) {
 361         // uvalue contains size of block
 362         const uint8_t* end_data_ptr = data_ptr + uvalue;
 363         while (data_ptr < end_data_ptr) {
 364           OS << format("%2.2x ", *data_ptr);
 365           ++data_ptr;
 366         }
 367       }
 368       else
 369         OS << "NULL";
 370     }
 371     break;
 372
 373   case DW_FORM_sdata:     OS << getSigned();   break;
 374   case DW_FORM_udata:     OS << getUnsigned(); break;
 375   case DW_FORM_strp: {
 376     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
 377     const char* dbg_str = getAsCString(cu);
 378     if (dbg_str) {
 379       OS << '"';
 380       OS.write_escaped(dbg_str);
 381       OS << '"';
 382     }
 383     break;
 384   }
 385   case DW_FORM_GNU_str_index: {
 386     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
 387     const char *dbg_str = getAsCString(cu);
 388     if (dbg_str) {
 389       OS << '"';
 390       OS.write_escaped(dbg_str);
 391       OS << '"';
 392     }
 393     break;
 394   }
 395   case DW_FORM_ref_addr:
 396     OS << format("0x%016" PRIx64, uvalue);
 397     break;
 398   case DW_FORM_ref1:
 399     cu_relative_offset = true;
 400     OS << format("cu + 0x%2.2x", (uint8_t)uvalue);
 401     break;
 402   case DW_FORM_ref2:
 403     cu_relative_offset = true;
 404     OS << format("cu + 0x%4.4x", (uint16_t)uvalue);
 405     break;
 406   case DW_FORM_ref4:
 407     cu_relative_offset = true;
 408     OS << format("cu + 0x%4.4x", (uint32_t)uvalue);
 409     break;
 410   case DW_FORM_ref8:
 411     cu_relative_offset = true;
 412     OS << format("cu + 0x%8.8" PRIx64, uvalue);
 413     break;
 414   case DW_FORM_ref_udata:
 415     cu_relative_offset = true;
 416     OS << format("cu + 0x%" PRIx64, uvalue);
 417     break;
 418
 419     // All DW_FORM_indirect attributes should be resolved prior to calling
 420     // this function
 421   case DW_FORM_indirect:
 422     OS << "DW_FORM_indirect";
 423     break;
 424
 425     // Should be formatted to 64-bit for DWARF64.
 426   case DW_FORM_sec_offset:
 427     OS << format("0x%08x", (uint32_t)uvalue);
 428     break;
 429
 430   default:
 431     OS << format("DW_FORM(0x%4.4x)", Form);
 432     break;
 433   }
 434
 435   if (cu_relative_offset)
 436     OS << format(" => {0x%8.8" PRIx64 "}", uvalue + (cu ? cu->getOffset() : 0));
 437 }
 438
 439 const char*
 440 DWARFFormValue::getAsCString(const DWARFCompileUnit *CU) const {
 441   if (isInlinedCStr())
 442     return Value.cstr;
 443   if (!CU)
 444     return NULL;
 445   uint32_t Offset = Value.uval;
 446   if (Value.IsDWOIndex) {
 447     uint32_t StrOffset;
 448     if (!CU->getStringOffsetSectionItem(Offset, StrOffset))
 449       return NULL;
 450     Offset = StrOffset;
 451   }
 452   return CU->getStringExtractor().getCStr(&Offset);
 453 }
 454
 455 uint64_t
 456 DWARFFormValue::getAsAddress(const DWARFCompileUnit *CU) const {
 457   if (!CU)
 458     return 0;
 459   if (Value.IsDWOIndex) {
 460     uint32_t Index = Value.uval;
 461     uint64_t Address;
 462     if (!CU->getAddrOffsetSectionItem(Index, Address))
 463       return 0;
 464     return Address;
 465   }
 466   return Value.uval;
 467 }
 468
 469 uint64_t DWARFFormValue::getReference(const DWARFCompileUnit *cu) const {
 470   uint64_t die_offset = Value.uval;
 471   switch (Form) {
 472   case DW_FORM_ref1:
 473   case DW_FORM_ref2:
 474   case DW_FORM_ref4:
 475   case DW_FORM_ref8:
 476   case DW_FORM_ref_udata:
 477       die_offset += (cu ? cu->getOffset() : 0);
 478       break;
 479   default:
 480       break;
 481   }
 482
 483   return die_offset;
 484 }
 485
 486 bool
 487 DWARFFormValue::resolveCompileUnitReferences(const DWARFCompileUnit *cu) {
 488   switch (Form) {
 489   case DW_FORM_ref1:
 490   case DW_FORM_ref2:
 491   case DW_FORM_ref4:
 492   case DW_FORM_ref8:
 493   case DW_FORM_ref_udata:
 494     Value.uval += cu->getOffset();
 495     Form = DW_FORM_ref_addr;
 496     return true;
 497   default:
 498     break;
 499   }
 500   return false;
 501 }
 502
 503 const uint8_t *DWARFFormValue::BlockData() const {
 504   if (!isInlinedCStr())
 505     return Value.data;
 506   return NULL;
 507 }
 508
 509 bool DWARFFormValue::isBlockForm(uint16_t form) {
 510   switch (form) {
 511   case DW_FORM_exprloc:
 512   case DW_FORM_block:
 513   case DW_FORM_block1:
 514   case DW_FORM_block2:
 515   case DW_FORM_block4:
 516     return true;
 517   }
 518   return false;
 519 }
 520
 521 bool DWARFFormValue::isDataForm(uint16_t form) {
 522   switch (form) {
 523   case DW_FORM_sdata:
 524   case DW_FORM_udata:
 525   case DW_FORM_data1:
 526   case DW_FORM_data2:
 527   case DW_FORM_data4:
 528   case DW_FORM_data8:
 529     return true;
 530   }
 531   return false;
 532 }