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 DWARFFormValue::extractValue(DataExtractor data, uint32_t *offset_ptr,
  78                                   const DWARFUnit *cu) {
  79   bool indirect = false;
  80   bool is_block = false;
  81   Value.data = NULL;
  82   // Read the value for the form into value and follow and DW_FORM_indirect
  83   // instances we run into
  84   do {
  85     indirect = false;
  86     switch (Form) {
  87     case DW_FORM_addr:
  88     case DW_FORM_ref_addr: {
  89       uint16_t AddrSize =
  90           (Form == DW_FORM_addr)
  91               ? cu->getAddressByteSize()
  92               : getRefAddrSize(cu->getAddressByteSize(), cu->getVersion());
  93       RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr);
  94       if (AI != cu->getRelocMap()->end()) {
  95         const std::pair<uint8_t, int64_t> &R = AI->second;
  96         Value.uval = data.getUnsigned(offset_ptr, AddrSize) + R.second;
  97       } else
  98         Value.uval = data.getUnsigned(offset_ptr, AddrSize);
  99       break;
 100     }
 101     case DW_FORM_exprloc:
 102     case DW_FORM_block:
 103       Value.uval = data.getULEB128(offset_ptr);
 104       is_block = true;
 105       break;
 106     case DW_FORM_block1:
 107       Value.uval = data.getU8(offset_ptr);
 108       is_block = true;
 109       break;
 110     case DW_FORM_block2:
 111       Value.uval = data.getU16(offset_ptr);
 112       is_block = true;
 113       break;
 114     case DW_FORM_block4:
 115       Value.uval = data.getU32(offset_ptr);
 116       is_block = true;
 117       break;
 118     case DW_FORM_data1:
 119     case DW_FORM_ref1:
 120     case DW_FORM_flag:
 121       Value.uval = data.getU8(offset_ptr);
 122       break;
 123     case DW_FORM_data2:
 124     case DW_FORM_ref2:
 125       Value.uval = data.getU16(offset_ptr);
 126       break;
 127     case DW_FORM_data4:
 128     case DW_FORM_ref4: {
 129       RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr);
 130       Value.uval = data.getU32(offset_ptr);
 131       if (AI != cu->getRelocMap()->end())
 132         Value.uval += AI->second.second;
 133       break;
 134     }
 135     case DW_FORM_data8:
 136     case DW_FORM_ref8:
 137       Value.uval = data.getU64(offset_ptr);
 138       break;
 139     case DW_FORM_sdata:
 140       Value.sval = data.getSLEB128(offset_ptr);
 141       break;
 142     case DW_FORM_strp: {
 143       RelocAddrMap::const_iterator AI
 144         = cu->getRelocMap()->find(*offset_ptr);
 145       if (AI != cu->getRelocMap()->end()) {
 146         const std::pair<uint8_t, int64_t> &R = AI->second;
 147         Value.uval = data.getU32(offset_ptr) + R.second;
 148       } else
 149         Value.uval = data.getU32(offset_ptr);
 150       break;
 151     }
 152     case DW_FORM_udata:
 153     case DW_FORM_ref_udata:
 154       Value.uval = data.getULEB128(offset_ptr);
 155       break;
 156     case DW_FORM_string:
 157       Value.cstr = data.getCStr(offset_ptr);
 158       // Set the string value to also be the data for inlined cstr form
 159       // values only so we can tell the differnence between DW_FORM_string
 160       // and DW_FORM_strp form values
 161       Value.data = (const uint8_t*)Value.cstr;
 162       break;
 163     case DW_FORM_indirect:
 164       Form = data.getULEB128(offset_ptr);
 165       indirect = true;
 166       break;
 167     case DW_FORM_sec_offset: {
 168       // FIXME: This is 64-bit for DWARF64.
 169       RelocAddrMap::const_iterator AI
 170         = cu->getRelocMap()->find(*offset_ptr);
 171       if (AI != cu->getRelocMap()->end()) {
 172         const std::pair<uint8_t, int64_t> &R = AI->second;
 173         Value.uval = data.getU32(offset_ptr) + R.second;
 174       } else
 175         Value.uval = data.getU32(offset_ptr);
 176       break;
 177     }
 178     case DW_FORM_flag_present:
 179       Value.uval = 1;
 180       break;
 181     case DW_FORM_ref_sig8:
 182       Value.uval = data.getU64(offset_ptr);
 183       break;
 184     case DW_FORM_GNU_addr_index:
 185     case DW_FORM_GNU_str_index:
 186       Value.uval = data.getULEB128(offset_ptr);
 187       Value.IsDWOIndex = true;
 188       break;
 189     default:
 190       return false;
 191     }
 192   } while (indirect);
 193
 194   if (is_block) {
 195     StringRef str = data.getData().substr(*offset_ptr, Value.uval);
 196     Value.data = NULL;
 197     if (!str.empty()) {
 198       Value.data = reinterpret_cast<const uint8_t *>(str.data());
 199       *offset_ptr += Value.uval;
 200     }
 201   }
 202
 203   return true;
 204 }
 205
 206 bool
 207 DWARFFormValue::skipValue(DataExtractor debug_info_data, uint32_t* offset_ptr,
 208                           const DWARFUnit *cu) const {
 209   return DWARFFormValue::skipValue(Form, debug_info_data, offset_ptr, cu);
 210 }
 211
 212 bool
 213 DWARFFormValue::skipValue(uint16_t form, DataExtractor debug_info_data,
 214                           uint32_t *offset_ptr, const DWARFUnit *cu) {
 215   bool indirect = false;
 216   do {
 217     switch (form) {
 218     // Blocks if inlined data that have a length field and the data bytes
 219     // inlined in the .debug_info
 220     case DW_FORM_exprloc:
 221     case DW_FORM_block: {
 222       uint64_t size = debug_info_data.getULEB128(offset_ptr);
 223       *offset_ptr += size;
 224       return true;
 225     }
 226     case DW_FORM_block1: {
 227       uint8_t size = debug_info_data.getU8(offset_ptr);
 228       *offset_ptr += size;
 229       return true;
 230     }
 231     case DW_FORM_block2: {
 232       uint16_t size = debug_info_data.getU16(offset_ptr);
 233       *offset_ptr += size;
 234       return true;
 235     }
 236     case DW_FORM_block4: {
 237       uint32_t size = debug_info_data.getU32(offset_ptr);
 238       *offset_ptr += size;
 239       return true;
 240     }
 241
 242     // Inlined NULL terminated C-strings
 243     case DW_FORM_string:
 244       debug_info_data.getCStr(offset_ptr);
 245       return true;
 246
 247     // Compile unit address sized values
 248     case DW_FORM_addr:
 249       *offset_ptr += cu->getAddressByteSize();
 250       return true;
 251     case DW_FORM_ref_addr:
 252       *offset_ptr += getRefAddrSize(cu->getAddressByteSize(), cu->getVersion());
 253       return true;
 254
 255     // 0 byte values - implied from the form.
 256     case DW_FORM_flag_present:
 257       return true;
 258
 259     // 1 byte values
 260     case DW_FORM_data1:
 261     case DW_FORM_flag:
 262     case DW_FORM_ref1:
 263       *offset_ptr += 1;
 264       return true;
 265
 266     // 2 byte values
 267     case DW_FORM_data2:
 268     case DW_FORM_ref2:
 269       *offset_ptr += 2;
 270       return true;
 271
 272     // 4 byte values
 273     case DW_FORM_strp:
 274     case DW_FORM_data4:
 275     case DW_FORM_ref4:
 276       *offset_ptr += 4;
 277       return true;
 278
 279     // 8 byte values
 280     case DW_FORM_data8:
 281     case DW_FORM_ref8:
 282     case DW_FORM_ref_sig8:
 283       *offset_ptr += 8;
 284       return true;
 285
 286     // signed or unsigned LEB 128 values
 287     //  case DW_FORM_APPLE_db_str:
 288     case DW_FORM_sdata:
 289     case DW_FORM_udata:
 290     case DW_FORM_ref_udata:
 291     case DW_FORM_GNU_str_index:
 292     case DW_FORM_GNU_addr_index:
 293       debug_info_data.getULEB128(offset_ptr);
 294       return true;
 295
 296     case DW_FORM_indirect:
 297       indirect = true;
 298       form = debug_info_data.getULEB128(offset_ptr);
 299       break;
 300
 301     // FIXME: 4 for DWARF32, 8 for DWARF64.
 302     case DW_FORM_sec_offset:
 303       *offset_ptr += 4;
 304       return true;
 305
 306     default:
 307       return false;
 308     }
 309   } while (indirect);
 310   return true;
 311 }
 312
 313 void
 314 DWARFFormValue::dump(raw_ostream &OS, const DWARFUnit *cu) const {
 315   DataExtractor debug_str_data(cu->getStringSection(), true, 0);
 316   DataExtractor debug_str_offset_data(cu->getStringOffsetSection(), true, 0);
 317   uint64_t uvalue = getUnsigned();
 318   bool cu_relative_offset = false;
 319
 320   switch (Form) {
 321   case DW_FORM_addr:      OS << format("0x%016" PRIx64, uvalue); break;
 322   case DW_FORM_GNU_addr_index: {
 323     OS << format(" indexed (%8.8x) address = ", (uint32_t)uvalue);
 324     uint64_t Address;
 325     if (cu->getAddrOffsetSectionItem(uvalue, Address))
 326       OS << format("0x%016" PRIx64, Address);
 327     else
 328       OS << "<no .debug_addr section>";
 329     break;
 330   }
 331   case DW_FORM_flag_present: OS << "true"; break;
 332   case DW_FORM_flag:
 333   case DW_FORM_data1:     OS << format("0x%02x", (uint8_t)uvalue); break;
 334   case DW_FORM_data2:     OS << format("0x%04x", (uint16_t)uvalue); break;
 335   case DW_FORM_data4:     OS << format("0x%08x", (uint32_t)uvalue); break;
 336   case DW_FORM_ref_sig8:
 337   case DW_FORM_data8:     OS << format("0x%016" PRIx64, uvalue); break;
 338   case DW_FORM_string:
 339     OS << '"';
 340     OS.write_escaped(getAsCString(NULL));
 341     OS << '"';
 342     break;
 343   case DW_FORM_exprloc:
 344   case DW_FORM_block:
 345   case DW_FORM_block1:
 346   case DW_FORM_block2:
 347   case DW_FORM_block4:
 348     if (uvalue > 0) {
 349       switch (Form) {
 350       case DW_FORM_exprloc:
 351       case DW_FORM_block:  OS << format("<0x%" PRIx64 "> ", uvalue);     break;
 352       case DW_FORM_block1: OS << format("<0x%2.2x> ", (uint8_t)uvalue);  break;
 353       case DW_FORM_block2: OS << format("<0x%4.4x> ", (uint16_t)uvalue); break;
 354       case DW_FORM_block4: OS << format("<0x%8.8x> ", (uint32_t)uvalue); break;
 355       default: break;
 356       }
 357
 358       const uint8_t* data_ptr = Value.data;
 359       if (data_ptr) {
 360         // uvalue contains size of block
 361         const uint8_t* end_data_ptr = data_ptr + uvalue;
 362         while (data_ptr < end_data_ptr) {
 363           OS << format("%2.2x ", *data_ptr);
 364           ++data_ptr;
 365         }
 366       }
 367       else
 368         OS << "NULL";
 369     }
 370     break;
 371
 372   case DW_FORM_sdata:     OS << getSigned();   break;
 373   case DW_FORM_udata:     OS << getUnsigned(); break;
 374   case DW_FORM_strp: {
 375     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
 376     const char* dbg_str = getAsCString(cu);
 377     if (dbg_str) {
 378       OS << '"';
 379       OS.write_escaped(dbg_str);
 380       OS << '"';
 381     }
 382     break;
 383   }
 384   case DW_FORM_GNU_str_index: {
 385     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
 386     const char *dbg_str = getAsCString(cu);
 387     if (dbg_str) {
 388       OS << '"';
 389       OS.write_escaped(dbg_str);
 390       OS << '"';
 391     }
 392     break;
 393   }
 394   case DW_FORM_ref_addr:
 395     OS << format("0x%016" PRIx64, uvalue);
 396     break;
 397   case DW_FORM_ref1:
 398     cu_relative_offset = true;
 399     OS << format("cu + 0x%2.2x", (uint8_t)uvalue);
 400     break;
 401   case DW_FORM_ref2:
 402     cu_relative_offset = true;
 403     OS << format("cu + 0x%4.4x", (uint16_t)uvalue);
 404     break;
 405   case DW_FORM_ref4:
 406     cu_relative_offset = true;
 407     OS << format("cu + 0x%4.4x", (uint32_t)uvalue);
 408     break;
 409   case DW_FORM_ref8:
 410     cu_relative_offset = true;
 411     OS << format("cu + 0x%8.8" PRIx64, uvalue);
 412     break;
 413   case DW_FORM_ref_udata:
 414     cu_relative_offset = true;
 415     OS << format("cu + 0x%" PRIx64, uvalue);
 416     break;
 417
 418     // All DW_FORM_indirect attributes should be resolved prior to calling
 419     // this function
 420   case DW_FORM_indirect:
 421     OS << "DW_FORM_indirect";
 422     break;
 423
 424     // Should be formatted to 64-bit for DWARF64.
 425   case DW_FORM_sec_offset:
 426     OS << format("0x%08x", (uint32_t)uvalue);
 427     break;
 428
 429   default:
 430     OS << format("DW_FORM(0x%4.4x)", Form);
 431     break;
 432   }
 433
 434   if (cu_relative_offset)
 435     OS << format(" => {0x%8.8" PRIx64 "}", uvalue + (cu ? cu->getOffset() : 0));
 436 }
 437
 438 const char *DWARFFormValue::getAsCString(const DWARFUnit *CU) const {
 439   if (isInlinedCStr())
 440     return Value.cstr;
 441   if (!CU)
 442     return NULL;
 443   uint32_t Offset = Value.uval;
 444   if (Value.IsDWOIndex) {
 445     uint32_t StrOffset;
 446     if (!CU->getStringOffsetSectionItem(Offset, StrOffset))
 447       return NULL;
 448     Offset = StrOffset;
 449   }
 450   return CU->getStringExtractor().getCStr(&Offset);
 451 }
 452
 453 uint64_t DWARFFormValue::getAsAddress(const DWARFUnit *CU) const {
 454   if (!CU)
 455     return 0;
 456   if (Value.IsDWOIndex) {
 457     uint32_t Index = Value.uval;
 458     uint64_t Address;
 459     if (!CU->getAddrOffsetSectionItem(Index, Address))
 460       return 0;
 461     return Address;
 462   }
 463   return Value.uval;
 464 }
 465
 466 uint64_t DWARFFormValue::getReference(const DWARFUnit *cu) const {
 467   uint64_t die_offset = Value.uval;
 468   switch (Form) {
 469   case DW_FORM_ref1:
 470   case DW_FORM_ref2:
 471   case DW_FORM_ref4:
 472   case DW_FORM_ref8:
 473   case DW_FORM_ref_udata:
 474       die_offset += (cu ? cu->getOffset() : 0);
 475       break;
 476   default:
 477       break;
 478   }
 479
 480   return die_offset;
 481 }