| //===-- DWARFCompileUnit.cpp ----------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "DWARFCompileUnit.h" |
| #include "DWARFContext.h" |
| #include "DWARFFormValue.h" |
| #include "llvm/Support/Dwarf.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/raw_ostream.h" |
| using namespace llvm; |
| using namespace dwarf; |
| |
| DataExtractor DWARFCompileUnit::getDebugInfoExtractor() const { |
| return DataExtractor(Context.getInfoSection(), |
| Context.isLittleEndian(), getAddressByteSize()); |
| } |
| |
| bool DWARFCompileUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) { |
| clear(); |
| |
| Offset = *offset_ptr; |
| |
| if (debug_info.isValidOffset(*offset_ptr)) { |
| uint64_t abbrOffset; |
| const DWARFDebugAbbrev *abbr = Context.getDebugAbbrev(); |
| Length = debug_info.getU32(offset_ptr); |
| Version = debug_info.getU16(offset_ptr); |
| abbrOffset = debug_info.getU32(offset_ptr); |
| AddrSize = debug_info.getU8(offset_ptr); |
| |
| bool lengthOK = debug_info.isValidOffset(getNextCompileUnitOffset()-1); |
| bool versionOK = DWARFContext::isSupportedVersion(Version); |
| bool abbrOffsetOK = Context.getAbbrevSection().size() > abbrOffset; |
| bool addrSizeOK = AddrSize == 4 || AddrSize == 8; |
| |
| if (lengthOK && versionOK && addrSizeOK && abbrOffsetOK && abbr != NULL) { |
| Abbrevs = abbr->getAbbreviationDeclarationSet(abbrOffset); |
| return true; |
| } |
| |
| // reset the offset to where we tried to parse from if anything went wrong |
| *offset_ptr = Offset; |
| } |
| |
| return false; |
| } |
| |
| uint32_t |
| DWARFCompileUnit::extract(uint32_t offset, DataExtractor debug_info_data, |
| const DWARFAbbreviationDeclarationSet *abbrevs) { |
| clear(); |
| |
| Offset = offset; |
| |
| if (debug_info_data.isValidOffset(offset)) { |
| Length = debug_info_data.getU32(&offset); |
| Version = debug_info_data.getU16(&offset); |
| bool abbrevsOK = debug_info_data.getU32(&offset) == abbrevs->getOffset(); |
| Abbrevs = abbrevs; |
| AddrSize = debug_info_data.getU8 (&offset); |
| |
| bool versionOK = DWARFContext::isSupportedVersion(Version); |
| bool addrSizeOK = AddrSize == 4 || AddrSize == 8; |
| |
| if (versionOK && addrSizeOK && abbrevsOK && |
| debug_info_data.isValidOffset(offset)) |
| return offset; |
| } |
| return 0; |
| } |
| |
| void DWARFCompileUnit::clear() { |
| Offset = 0; |
| Length = 0; |
| Version = 0; |
| Abbrevs = 0; |
| AddrSize = 0; |
| BaseAddr = 0; |
| DieArray.clear(); |
| } |
| |
| void DWARFCompileUnit::dump(raw_ostream &OS) { |
| OS << format("0x%08x", Offset) << ": Compile Unit:" |
| << " length = " << format("0x%08x", Length) |
| << " version = " << format("0x%04x", Version) |
| << " abbr_offset = " << format("0x%04x", Abbrevs->getOffset()) |
| << " addr_size = " << format("0x%02x", AddrSize) |
| << " (next CU at " << format("0x%08x", getNextCompileUnitOffset()) |
| << ")\n"; |
| |
| getCompileUnitDIE(false)->dump(OS, this, -1U); |
| } |
| |
| void DWARFCompileUnit::setDIERelations() { |
| if (DieArray.empty()) |
| return; |
| DWARFDebugInfoEntryMinimal *die_array_begin = &DieArray.front(); |
| DWARFDebugInfoEntryMinimal *die_array_end = &DieArray.back(); |
| DWARFDebugInfoEntryMinimal *curr_die; |
| // We purposely are skipping the last element in the array in the loop below |
| // so that we can always have a valid next item |
| for (curr_die = die_array_begin; curr_die < die_array_end; ++curr_die) { |
| // Since our loop doesn't include the last element, we can always |
| // safely access the next die in the array. |
| DWARFDebugInfoEntryMinimal *next_die = curr_die + 1; |
| |
| const DWARFAbbreviationDeclaration *curr_die_abbrev = |
| curr_die->getAbbreviationDeclarationPtr(); |
| |
| if (curr_die_abbrev) { |
| // Normal DIE |
| if (curr_die_abbrev->hasChildren()) |
| next_die->setParent(curr_die); |
| else |
| curr_die->setSibling(next_die); |
| } else { |
| // NULL DIE that terminates a sibling chain |
| DWARFDebugInfoEntryMinimal *parent = curr_die->getParent(); |
| if (parent) |
| parent->setSibling(next_die); |
| } |
| } |
| |
| // Since we skipped the last element, we need to fix it up! |
| if (die_array_begin < die_array_end) |
| curr_die->setParent(die_array_begin); |
| } |
| |
| size_t DWARFCompileUnit::extractDIEsIfNeeded(bool cu_die_only) { |
| const size_t initial_die_array_size = DieArray.size(); |
| if ((cu_die_only && initial_die_array_size > 0) || |
| initial_die_array_size > 1) |
| return 0; // Already parsed |
| |
| // Set the offset to that of the first DIE and calculate the start of the |
| // next compilation unit header. |
| uint32_t offset = getFirstDIEOffset(); |
| uint32_t next_cu_offset = getNextCompileUnitOffset(); |
| |
| DWARFDebugInfoEntryMinimal die; |
| // Keep a flat array of the DIE for binary lookup by DIE offset |
| uint32_t depth = 0; |
| // We are in our compile unit, parse starting at the offset |
| // we were told to parse |
| |
| const uint8_t *fixed_form_sizes = |
| DWARFFormValue::getFixedFormSizesForAddressSize(getAddressByteSize()); |
| |
| while (offset < next_cu_offset && |
| die.extractFast(this, fixed_form_sizes, &offset)) { |
| |
| if (depth == 0) { |
| uint64_t base_addr = |
| die.getAttributeValueAsUnsigned(this, DW_AT_low_pc, -1U); |
| if (base_addr == -1U) |
| base_addr = die.getAttributeValueAsUnsigned(this, DW_AT_entry_pc, 0); |
| setBaseAddress(base_addr); |
| } |
| |
| if (cu_die_only) { |
| addDIE(die); |
| return 1; |
| } |
| else if (depth == 0 && initial_die_array_size == 1) { |
| // Don't append the CU die as we already did that |
| } else { |
| addDIE (die); |
| } |
| |
| const DWARFAbbreviationDeclaration *abbrDecl = |
| die.getAbbreviationDeclarationPtr(); |
| if (abbrDecl) { |
| // Normal DIE |
| if (abbrDecl->hasChildren()) |
| ++depth; |
| } else { |
| // NULL DIE. |
| if (depth > 0) |
| --depth; |
| if (depth == 0) |
| break; // We are done with this compile unit! |
| } |
| |
| } |
| |
| // Give a little bit of info if we encounter corrupt DWARF (our offset |
| // should always terminate at or before the start of the next compilation |
| // unit header). |
| if (offset > next_cu_offset) { |
| fprintf (stderr, "warning: DWARF compile unit extends beyond its bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), offset); |
| } |
| |
| setDIERelations(); |
| return DieArray.size(); |
| } |
| |
| void DWARFCompileUnit::clearDIEs(bool keep_compile_unit_die) { |
| if (DieArray.size() > 1) { |
| // std::vectors never get any smaller when resized to a smaller size, |
| // or when clear() or erase() are called, the size will report that it |
| // is smaller, but the memory allocated remains intact (call capacity() |
| // to see this). So we need to create a temporary vector and swap the |
| // contents which will cause just the internal pointers to be swapped |
| // so that when "tmp_array" goes out of scope, it will destroy the |
| // contents. |
| |
| // Save at least the compile unit DIE |
| std::vector<DWARFDebugInfoEntryMinimal> tmpArray; |
| DieArray.swap(tmpArray); |
| if (keep_compile_unit_die) |
| DieArray.push_back(tmpArray.front()); |
| } |
| } |
| |
| void |
| DWARFCompileUnit::buildAddressRangeTable(DWARFDebugAranges *debug_aranges, |
| bool clear_dies_if_already_not_parsed){ |
| // This function is usually called if there in no .debug_aranges section |
| // in order to produce a compile unit level set of address ranges that |
| // is accurate. If the DIEs weren't parsed, then we don't want all dies for |
| // all compile units to stay loaded when they weren't needed. So we can end |
| // up parsing the DWARF and then throwing them all away to keep memory usage |
| // down. |
| const bool clear_dies = extractDIEsIfNeeded(false) > 1; |
| |
| DieArray[0].buildAddressRangeTable(this, debug_aranges); |
| |
| // Keep memory down by clearing DIEs if this generate function |
| // caused them to be parsed. |
| if (clear_dies) |
| clearDIEs(true); |
| } |