lib/DebugInfo/DWARFDebugInfoEntry.cpp

   1 //===-- DWARFDebugInfoEntry.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 "DWARFDebugInfoEntry.h"
  11 #include "DWARFCompileUnit.h"
  12 #include "DWARFContext.h"
  13 #include "DWARFDebugAbbrev.h"
  14 #include "DWARFFormValue.h"
  15 #include "llvm/Support/Dwarf.h"
  16 #include "llvm/Support/Format.h"
  17 #include "llvm/Support/raw_ostream.h"
  18 using namespace llvm;
  19 using namespace dwarf;
  20
  21 void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS,
  22                                       const DWARFCompileUnit *cu,
  23                                       unsigned recurseDepth,
  24                                       unsigned indent) const {
  25   DataExtractor debug_info_data = cu->getDebugInfoExtractor();
  26   uint32_t offset = Offset;
  27
  28   if (debug_info_data.isValidOffset(offset)) {
  29     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
  30
  31     OS << format("\n0x%8.8x: ", Offset);
  32     if (abbrCode) {
  33       if (AbbrevDecl) {
  34         const char *tagString = TagString(getTag());
  35         if (tagString)
  36           OS.indent(indent) << tagString;
  37         else
  38           OS.indent(indent) << format("DW_TAG_Unknown_%x", getTag());
  39         OS << format(" [%u] %c\n", abbrCode,
  40                      AbbrevDecl->hasChildren() ? '*' : ' ');
  41
  42         // Dump all data in the .debug_info for the attributes
  43         const uint32_t numAttributes = AbbrevDecl->getNumAttributes();
  44         for (uint32_t i = 0; i != numAttributes; ++i) {
  45           uint16_t attr = AbbrevDecl->getAttrByIndex(i);
  46           uint16_t form = AbbrevDecl->getFormByIndex(i);
  47           dumpAttribute(OS, cu, &offset, attr, form, indent);
  48         }
  49
  50         const DWARFDebugInfoEntryMinimal *child = getFirstChild();
  51         if (recurseDepth > 0 && child) {
  52           while (child) {
  53             child->dump(OS, cu, recurseDepth-1, indent+2);
  54             child = child->getSibling();
  55           }
  56         }
  57       } else {
  58         OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
  59            << abbrCode << '\n';
  60       }
  61     } else {
  62       OS.indent(indent) << "NULL\n";
  63     }
  64   }
  65 }
  66
  67 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
  68                                                const DWARFCompileUnit *cu,
  69                                                uint32_t* offset_ptr,
  70                                                uint16_t attr,
  71                                                uint16_t form,
  72                                                unsigned indent) const {
  73   OS << format("0x%8.8x: ", *offset_ptr);
  74   OS.indent(indent+2);
  75   const char *attrString = AttributeString(attr);
  76   if (attrString)
  77     OS << attrString;
  78   else
  79     OS << format("DW_AT_Unknown_%x", attr);
  80   const char *formString = FormEncodingString(form);
  81   if (formString)
  82     OS << " [" << formString << ']';
  83   else
  84     OS << format(" [DW_FORM_Unknown_%x]", form);
  85
  86   DWARFFormValue formValue(form);
  87
  88   if (!formValue.extractValue(cu->getDebugInfoExtractor(), offset_ptr, cu))
  89     return;
  90
  91   OS << "\t(";
  92   formValue.dump(OS, cu);
  93   OS << ")\n";
  94 }
  95
  96 bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFCompileUnit *cu,
  97                                              const uint8_t *fixed_form_sizes,
  98                                              uint32_t *offset_ptr) {
  99   Offset = *offset_ptr;
 100
 101   DataExtractor debug_info_data = cu->getDebugInfoExtractor();
 102   uint64_t abbrCode = debug_info_data.getULEB128(offset_ptr);
 103
 104   assert (fixed_form_sizes); // For best performance this should be specified!
 105
 106   if (abbrCode) {
 107     uint32_t offset = *offset_ptr;
 108
 109     AbbrevDecl = cu->getAbbreviations()->getAbbreviationDeclaration(abbrCode);
 110
 111     // Skip all data in the .debug_info for the attributes
 112     const uint32_t numAttributes = AbbrevDecl->getNumAttributes();
 113     uint32_t i;
 114     uint16_t form;
 115     for (i=0; i<numAttributes; ++i) {
 116       form = AbbrevDecl->getFormByIndex(i);
 117
 118       const uint8_t fixed_skip_size = fixed_form_sizes[form];
 119       if (fixed_skip_size)
 120         offset += fixed_skip_size;
 121       else {
 122         bool form_is_indirect = false;
 123         do {
 124           form_is_indirect = false;
 125           uint32_t form_size = 0;
 126           switch (form) {
 127           // Blocks if inlined data that have a length field and the data bytes
 128           // inlined in the .debug_info.
 129           case DW_FORM_block:
 130             form_size = debug_info_data.getULEB128(&offset);
 131             break;
 132           case DW_FORM_block1:
 133             form_size = debug_info_data.getU8(&offset);
 134             break;
 135           case DW_FORM_block2:
 136             form_size = debug_info_data.getU16(&offset);
 137             break;
 138           case DW_FORM_block4:
 139             form_size = debug_info_data.getU32(&offset);
 140             break;
 141
 142           // Inlined NULL terminated C-strings
 143           case DW_FORM_string:
 144             debug_info_data.getCStr(&offset);
 145             break;
 146
 147           // Compile unit address sized values
 148           case DW_FORM_addr:
 149           case DW_FORM_ref_addr:
 150             form_size = cu->getAddressByteSize();
 151             break;
 152
 153           // 1 byte values
 154           case DW_FORM_data1:
 155           case DW_FORM_flag:
 156           case DW_FORM_ref1:
 157             form_size = 1;
 158             break;
 159
 160           // 2 byte values
 161           case DW_FORM_data2:
 162           case DW_FORM_ref2:
 163             form_size = 2;
 164             break;
 165
 166           // 4 byte values
 167           case DW_FORM_strp:
 168           case DW_FORM_data4:
 169           case DW_FORM_ref4:
 170             form_size = 4;
 171             break;
 172
 173           // 8 byte values
 174           case DW_FORM_data8:
 175           case DW_FORM_ref8:
 176             form_size = 8;
 177             break;
 178
 179           // signed or unsigned LEB 128 values
 180           case DW_FORM_sdata:
 181           case DW_FORM_udata:
 182           case DW_FORM_ref_udata:
 183             debug_info_data.getULEB128(&offset);
 184             break;
 185
 186           case DW_FORM_indirect:
 187             form_is_indirect = true;
 188             form = debug_info_data.getULEB128(&offset);
 189             break;
 190
 191           default:
 192             *offset_ptr = Offset;
 193             return false;
 194           }
 195           offset += form_size;
 196
 197         } while (form_is_indirect);
 198       }
 199     }
 200     *offset_ptr = offset;
 201     return true;
 202   } else {
 203     AbbrevDecl = NULL;
 204     return true; // NULL debug tag entry
 205   }
 206 }
 207
 208 bool
 209 DWARFDebugInfoEntryMinimal::extract(const DWARFCompileUnit *cu,
 210                                     uint32_t *offset_ptr) {
 211   DataExtractor debug_info_data = cu->getDebugInfoExtractor();
 212   const uint32_t cu_end_offset = cu->getNextCompileUnitOffset();
 213   const uint8_t cu_addr_size = cu->getAddressByteSize();
 214   uint32_t offset = *offset_ptr;
 215   if ((offset < cu_end_offset) && debug_info_data.isValidOffset(offset)) {
 216     Offset = offset;
 217
 218     uint64_t abbrCode = debug_info_data.getULEB128(&offset);
 219
 220     if (abbrCode) {
 221       AbbrevDecl = cu->getAbbreviations()->getAbbreviationDeclaration(abbrCode);
 222
 223       if (AbbrevDecl) {
 224         uint16_t tag = AbbrevDecl->getTag();
 225
 226         bool isCompileUnitTag = tag == DW_TAG_compile_unit;
 227         if(cu && isCompileUnitTag)
 228           const_cast<DWARFCompileUnit*>(cu)->setBaseAddress(0);
 229
 230         // Skip all data in the .debug_info for the attributes
 231         const uint32_t numAttributes = AbbrevDecl->getNumAttributes();
 232         for (uint32_t i = 0; i != numAttributes; ++i) {
 233           uint16_t attr = AbbrevDecl->getAttrByIndex(i);
 234           uint16_t form = AbbrevDecl->getFormByIndex(i);
 235
 236           if (isCompileUnitTag &&
 237               ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc))) {
 238             DWARFFormValue form_value(form);
 239             if (form_value.extractValue(debug_info_data, &offset, cu)) {
 240               if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc)
 241                 const_cast<DWARFCompileUnit*>(cu)
 242                   ->setBaseAddress(form_value.getUnsigned());
 243             }
 244           } else {
 245             bool form_is_indirect = false;
 246             do {
 247               form_is_indirect = false;
 248               register uint32_t form_size = 0;
 249               switch (form) {
 250               // Blocks if inlined data that have a length field and the data
 251               // bytes // inlined in the .debug_info
 252               case DW_FORM_block:
 253                 form_size = debug_info_data.getULEB128(&offset);
 254                 break;
 255               case DW_FORM_block1:
 256                 form_size = debug_info_data.getU8(&offset);
 257                 break;
 258               case DW_FORM_block2:
 259                 form_size = debug_info_data.getU16(&offset);
 260                 break;
 261               case DW_FORM_block4:
 262                 form_size = debug_info_data.getU32(&offset);
 263                 break;
 264
 265               // Inlined NULL terminated C-strings
 266               case DW_FORM_string:
 267                 debug_info_data.getCStr(&offset);
 268                 break;
 269
 270               // Compile unit address sized values
 271               case DW_FORM_addr:
 272               case DW_FORM_ref_addr:
 273                 form_size = cu_addr_size;
 274                 break;
 275
 276               // 1 byte values
 277               case DW_FORM_data1:
 278               case DW_FORM_flag:
 279               case DW_FORM_ref1:
 280                 form_size = 1;
 281                 break;
 282
 283               // 2 byte values
 284               case DW_FORM_data2:
 285               case DW_FORM_ref2:
 286                 form_size = 2;
 287                 break;
 288
 289                 // 4 byte values
 290               case DW_FORM_strp:
 291                 form_size = 4;
 292                 break;
 293
 294               case DW_FORM_data4:
 295               case DW_FORM_ref4:
 296                 form_size = 4;
 297                 break;
 298
 299               // 8 byte values
 300               case DW_FORM_data8:
 301               case DW_FORM_ref8:
 302                 form_size = 8;
 303                 break;
 304
 305               // signed or unsigned LEB 128 values
 306               case DW_FORM_sdata:
 307               case DW_FORM_udata:
 308               case DW_FORM_ref_udata:
 309                 debug_info_data.getULEB128(&offset);
 310                 break;
 311
 312               case DW_FORM_indirect:
 313                 form = debug_info_data.getULEB128(&offset);
 314                 form_is_indirect = true;
 315                 break;
 316
 317               default:
 318                 *offset_ptr = offset;
 319                 return false;
 320               }
 321
 322               offset += form_size;
 323             } while (form_is_indirect);
 324           }
 325         }
 326         *offset_ptr = offset;
 327         return true;
 328       }
 329     } else {
 330       AbbrevDecl = NULL;
 331       *offset_ptr = offset;
 332       return true;    // NULL debug tag entry
 333     }
 334   }
 335
 336   return false;
 337 }
 338
 339 uint32_t
 340 DWARFDebugInfoEntryMinimal::getAttributeValue(const DWARFCompileUnit *cu,
 341                                               const uint16_t attr,
 342                                               DWARFFormValue &form_value,
 343                                               uint32_t *end_attr_offset_ptr)
 344                                               const {
 345   if (AbbrevDecl) {
 346     uint32_t attr_idx = AbbrevDecl->findAttributeIndex(attr);
 347
 348     if (attr_idx != -1U) {
 349       uint32_t offset = getOffset();
 350
 351       DataExtractor debug_info_data = cu->getDebugInfoExtractor();
 352
 353       // Skip the abbreviation code so we are at the data for the attributes
 354       debug_info_data.getULEB128(&offset);
 355
 356       uint32_t idx = 0;
 357       while (idx < attr_idx)
 358         DWARFFormValue::skipValue(AbbrevDecl->getFormByIndex(idx++),
 359                                   debug_info_data, &offset, cu);
 360
 361       const uint32_t attr_offset = offset;
 362       form_value = DWARFFormValue(AbbrevDecl->getFormByIndex(idx));
 363       if (form_value.extractValue(debug_info_data, &offset, cu)) {
 364         if (end_attr_offset_ptr)
 365           *end_attr_offset_ptr = offset;
 366         return attr_offset;
 367       }
 368     }
 369   }
 370
 371   return 0;
 372 }
 373
 374 const char*
 375 DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
 376     const DWARFCompileUnit* cu,
 377     const uint16_t attr,
 378     const char* fail_value) const {
 379   DWARFFormValue form_value;
 380   if (getAttributeValue(cu, attr, form_value)) {
 381     DataExtractor stringExtractor(cu->getContext().getStringSection(),
 382         false, 0);
 383     return form_value.getAsCString(&stringExtractor);
 384   }
 385   return fail_value;
 386 }
 387
 388 uint64_t
 389 DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsigned(
 390     const DWARFCompileUnit* cu,
 391     const uint16_t attr,
 392     uint64_t fail_value) const {
 393   DWARFFormValue form_value;
 394   if (getAttributeValue(cu, attr, form_value))
 395       return form_value.getUnsigned();
 396   return fail_value;
 397 }
 398
 399 int64_t
 400 DWARFDebugInfoEntryMinimal::getAttributeValueAsSigned(
 401     const DWARFCompileUnit* cu,
 402     const uint16_t attr,
 403     int64_t fail_value) const {
 404   DWARFFormValue form_value;
 405   if (getAttributeValue(cu, attr, form_value))
 406       return form_value.getSigned();
 407   return fail_value;
 408 }
 409
 410 uint64_t
 411 DWARFDebugInfoEntryMinimal::getAttributeValueAsReference(
 412                                                   const DWARFCompileUnit* cu,
 413                                                   const uint16_t attr,
 414                                                   uint64_t fail_value) const {
 415   DWARFFormValue form_value;
 416   if (getAttributeValue(cu, attr, form_value))
 417       return form_value.getReference(cu);
 418   return fail_value;
 419 }
 420
 421 void
 422 DWARFDebugInfoEntryMinimal::buildAddressRangeTable(const DWARFCompileUnit *cu,
 423                                                DWARFDebugAranges *debug_aranges)
 424                                                    const {
 425   if (AbbrevDecl) {
 426     uint16_t tag = AbbrevDecl->getTag();
 427     if (tag == DW_TAG_subprogram) {
 428       uint64_t hi_pc = -1ULL;
 429       uint64_t lo_pc = getAttributeValueAsUnsigned(cu, DW_AT_low_pc, -1ULL);
 430       if (lo_pc != -1ULL)
 431         hi_pc = getAttributeValueAsUnsigned(cu, DW_AT_high_pc, -1ULL);
 432       if (hi_pc != -1ULL)
 433         debug_aranges->appendRange(cu->getOffset(), lo_pc, hi_pc);
 434     }
 435
 436     const DWARFDebugInfoEntryMinimal *child = getFirstChild();
 437     while (child) {
 438       child->buildAddressRangeTable(cu, debug_aranges);
 439       child = child->getSibling();
 440     }
 441   }
 442 }