contrib/llvm/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     uint64_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   return false;
 208 }
 209
 210 bool
 211 DWARFDebugInfoEntryMinimal::extract(const DWARFCompileUnit *cu,
 212                                     uint32_t *offset_ptr) {
 213   DataExtractor debug_info_data = cu->getDebugInfoExtractor();
 214   const uint32_t cu_end_offset = cu->getNextCompileUnitOffset();
 215   const uint8_t cu_addr_size = cu->getAddressByteSize();
 216   uint32_t offset = *offset_ptr;
 217   if ((offset < cu_end_offset) && debug_info_data.isValidOffset(offset)) {
 218     Offset = offset;
 219
 220     uint64_t abbrCode = debug_info_data.getULEB128(&offset);
 221
 222     if (abbrCode) {
 223       AbbrevDecl = cu->getAbbreviations()->getAbbreviationDeclaration(abbrCode);
 224
 225       if (AbbrevDecl) {
 226         uint16_t tag = AbbrevDecl->getTag();
 227
 228         bool isCompileUnitTag = tag == DW_TAG_compile_unit;
 229         if(cu && isCompileUnitTag)
 230           const_cast<DWARFCompileUnit*>(cu)->setBaseAddress(0);
 231
 232         // Skip all data in the .debug_info for the attributes
 233         const uint32_t numAttributes = AbbrevDecl->getNumAttributes();
 234         for (uint32_t i = 0; i != numAttributes; ++i) {
 235           uint16_t attr = AbbrevDecl->getAttrByIndex(i);
 236           uint16_t form = AbbrevDecl->getFormByIndex(i);
 237
 238           if (isCompileUnitTag &&
 239               ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc))) {
 240             DWARFFormValue form_value(form);
 241             if (form_value.extractValue(debug_info_data, &offset, cu)) {
 242               if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc)
 243                 const_cast<DWARFCompileUnit*>(cu)
 244                   ->setBaseAddress(form_value.getUnsigned());
 245             }
 246           } else {
 247             bool form_is_indirect = false;
 248             do {
 249               form_is_indirect = false;
 250               register uint32_t form_size = 0;
 251               switch (form) {
 252               // Blocks if inlined data that have a length field and the data
 253               // bytes // inlined in the .debug_info
 254               case DW_FORM_block:
 255                 form_size = debug_info_data.getULEB128(&offset);
 256                 break;
 257               case DW_FORM_block1:
 258                 form_size = debug_info_data.getU8(&offset);
 259                 break;
 260               case DW_FORM_block2:
 261                 form_size = debug_info_data.getU16(&offset);
 262                 break;
 263               case DW_FORM_block4:
 264                 form_size = debug_info_data.getU32(&offset);
 265                 break;
 266
 267               // Inlined NULL terminated C-strings
 268               case DW_FORM_string:
 269                 debug_info_data.getCStr(&offset);
 270                 break;
 271
 272               // Compile unit address sized values
 273               case DW_FORM_addr:
 274               case DW_FORM_ref_addr:
 275                 form_size = cu_addr_size;
 276                 break;
 277
 278               // 1 byte values
 279               case DW_FORM_data1:
 280               case DW_FORM_flag:
 281               case DW_FORM_ref1:
 282                 form_size = 1;
 283                 break;
 284
 285               // 2 byte values
 286               case DW_FORM_data2:
 287               case DW_FORM_ref2:
 288                 form_size = 2;
 289                 break;
 290
 291                 // 4 byte values
 292               case DW_FORM_strp:
 293                 form_size = 4;
 294                 break;
 295
 296               case DW_FORM_data4:
 297               case DW_FORM_ref4:
 298                 form_size = 4;
 299                 break;
 300
 301               // 8 byte values
 302               case DW_FORM_data8:
 303               case DW_FORM_ref8:
 304                 form_size = 8;
 305                 break;
 306
 307               // signed or unsigned LEB 128 values
 308               case DW_FORM_sdata:
 309               case DW_FORM_udata:
 310               case DW_FORM_ref_udata:
 311                 debug_info_data.getULEB128(&offset);
 312                 break;
 313
 314               case DW_FORM_indirect:
 315                 form = debug_info_data.getULEB128(&offset);
 316                 form_is_indirect = true;
 317                 break;
 318
 319               default:
 320                 *offset_ptr = offset;
 321                 return false;
 322               }
 323
 324               offset += form_size;
 325             } while (form_is_indirect);
 326           }
 327         }
 328         *offset_ptr = offset;
 329         return true;
 330       }
 331     } else {
 332       AbbrevDecl = NULL;
 333       *offset_ptr = offset;
 334       return true;    // NULL debug tag entry
 335     }
 336   }
 337
 338   return false;
 339 }
 340
 341 uint32_t
 342 DWARFDebugInfoEntryMinimal::getAttributeValue(const DWARFCompileUnit *cu,
 343                                               const uint16_t attr,
 344                                               DWARFFormValue &form_value,
 345                                               uint32_t *end_attr_offset_ptr)
 346                                               const {
 347   if (AbbrevDecl) {
 348     uint32_t attr_idx = AbbrevDecl->findAttributeIndex(attr);
 349
 350     if (attr_idx != -1U) {
 351       uint32_t offset = getOffset();
 352
 353       DataExtractor debug_info_data = cu->getDebugInfoExtractor();
 354
 355       // Skip the abbreviation code so we are at the data for the attributes
 356       debug_info_data.getULEB128(&offset);
 357
 358       uint32_t idx = 0;
 359       while (idx < attr_idx)
 360         DWARFFormValue::skipValue(AbbrevDecl->getFormByIndex(idx++),
 361                                   debug_info_data, &offset, cu);
 362
 363       const uint32_t attr_offset = offset;
 364       form_value = DWARFFormValue(AbbrevDecl->getFormByIndex(idx));
 365       if (form_value.extractValue(debug_info_data, &offset, cu)) {
 366         if (end_attr_offset_ptr)
 367           *end_attr_offset_ptr = offset;
 368         return attr_offset;
 369       }
 370     }
 371   }
 372
 373   return 0;
 374 }
 375
 376 const char*
 377 DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
 378     const DWARFCompileUnit* cu,
 379     const uint16_t attr,
 380     const char* fail_value) const {
 381   DWARFFormValue form_value;
 382   if (getAttributeValue(cu, attr, form_value)) {
 383     DataExtractor stringExtractor(cu->getContext().getStringSection(),
 384         false, 0);
 385     return form_value.getAsCString(&stringExtractor);
 386   }
 387   return fail_value;
 388 }
 389
 390 uint64_t
 391 DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsigned(
 392     const DWARFCompileUnit* cu,
 393     const uint16_t attr,
 394     uint64_t fail_value) const {
 395   DWARFFormValue form_value;
 396   if (getAttributeValue(cu, attr, form_value))
 397       return form_value.getUnsigned();
 398   return fail_value;
 399 }
 400
 401 int64_t
 402 DWARFDebugInfoEntryMinimal::getAttributeValueAsSigned(
 403     const DWARFCompileUnit* cu,
 404     const uint16_t attr,
 405     int64_t fail_value) const {
 406   DWARFFormValue form_value;
 407   if (getAttributeValue(cu, attr, form_value))
 408       return form_value.getSigned();
 409   return fail_value;
 410 }
 411
 412 uint64_t
 413 DWARFDebugInfoEntryMinimal::getAttributeValueAsReference(
 414                                                   const DWARFCompileUnit* cu,
 415                                                   const uint16_t attr,
 416                                                   uint64_t fail_value) const {
 417   DWARFFormValue form_value;
 418   if (getAttributeValue(cu, attr, form_value))
 419       return form_value.getReference(cu);
 420   return fail_value;
 421 }
 422
 423 void
 424 DWARFDebugInfoEntryMinimal::buildAddressRangeTable(const DWARFCompileUnit *cu,
 425                                                DWARFDebugAranges *debug_aranges)
 426                                                    const {
 427   if (AbbrevDecl) {
 428     uint16_t tag = AbbrevDecl->getTag();
 429     if (tag == DW_TAG_subprogram) {
 430       uint64_t hi_pc = -1ULL;
 431       uint64_t lo_pc = getAttributeValueAsUnsigned(cu, DW_AT_low_pc, -1ULL);
 432       if (lo_pc != -1ULL)
 433         hi_pc = getAttributeValueAsUnsigned(cu, DW_AT_high_pc, -1ULL);
 434       if (hi_pc != -1ULL)
 435         debug_aranges->appendRange(cu->getOffset(), lo_pc, hi_pc);
 436     }
 437
 438     const DWARFDebugInfoEntryMinimal *child = getFirstChild();
 439     while (child) {
 440       child->buildAddressRangeTable(cu, debug_aranges);
 441       child = child->getSibling();
 442     }
 443   }
 444 }