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