Initial checkin of lldb code from internal Apple repo.
git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@105619 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp b/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
new file mode 100644
index 0000000..fcb0ccf
--- /dev/null
+++ b/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
@@ -0,0 +1,1206 @@
+//===-- DWARFDebugInfo.cpp --------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SymbolFileDWARF.h"
+
+#include <algorithm>
+#include <set>
+
+#include "lldb/Core/RegularExpression.h"
+#include "lldb/Core/Stream.h"
+
+#include "DWARFDebugInfo.h"
+#include "DWARFCompileUnit.h"
+#include "DWARFDebugAranges.h"
+#include "DWARFDebugInfoEntry.h"
+#include "DWARFFormValue.h"
+
+using namespace lldb_private;
+using namespace std;
+
+//----------------------------------------------------------------------
+// Constructor
+//----------------------------------------------------------------------
+DWARFDebugInfo::DWARFDebugInfo() :
+ m_dwarf2Data(NULL),
+ m_compile_units()
+{
+}
+
+//----------------------------------------------------------------------
+// SetDwarfData
+//----------------------------------------------------------------------
+void
+DWARFDebugInfo::SetDwarfData(SymbolFileDWARF* dwarf2Data)
+{
+ m_dwarf2Data = dwarf2Data;
+ m_compile_units.clear();
+}
+
+//----------------------------------------------------------------------
+// BuildDIEAddressRangeTable
+//----------------------------------------------------------------------
+bool
+DWARFDebugInfo::BuildFunctionAddressRangeTable(DWARFDebugAranges* debug_aranges)
+{
+ const uint32_t num_compile_units = GetNumCompileUnits();
+ uint32_t idx;
+ for (idx = 0; idx < num_compile_units; ++idx)
+ {
+ DWARFCompileUnit* cu = GetCompileUnitAtIndex (idx);
+ if (cu)
+ {
+ cu->DIE()->BuildFunctionAddressRangeTable(m_dwarf2Data, cu, debug_aranges);
+ }
+ }
+ return !debug_aranges->IsEmpty();
+}
+
+//----------------------------------------------------------------------
+// LookupAddress
+//----------------------------------------------------------------------
+bool
+DWARFDebugInfo::LookupAddress
+(
+ const dw_addr_t address,
+ const dw_offset_t hint_die_offset,
+ DWARFCompileUnitSP& cu_sp,
+ DWARFDebugInfoEntry** function_die,
+ DWARFDebugInfoEntry** block_die
+)
+{
+
+ if (hint_die_offset != DW_INVALID_OFFSET)
+ cu_sp = GetCompileUnit(hint_die_offset);
+ else
+ {
+ // Get a non const version of the address ranges
+ DWARFDebugAranges* debug_aranges = ((SymbolFileDWARF*)m_dwarf2Data)->DebugAranges();
+
+ if (debug_aranges != NULL)
+ {
+ // If we have an empty address ranges section, lets build a sorted
+ // table ourselves by going through all of the debug information so we
+ // can do quick subsequent searches.
+
+ if (debug_aranges->IsEmpty())
+ {
+ const uint32_t num_compile_units = GetNumCompileUnits();
+ uint32_t idx;
+ for (idx = 0; idx < num_compile_units; ++idx)
+ {
+ DWARFCompileUnit* cu = GetCompileUnitAtIndex(idx);
+ if (cu)
+ cu->DIE()->BuildAddressRangeTable(m_dwarf2Data, cu, debug_aranges);
+ }
+ }
+ cu_sp = GetCompileUnit(debug_aranges->FindAddress(address));
+ }
+ }
+
+ if (cu_sp.get())
+ {
+ if (cu_sp->LookupAddress(address, function_die, block_die))
+ return true;
+ cu_sp.reset();
+ }
+ else
+ {
+ // The hint_die_offset may have been a pointer to the actual item that
+ // we are looking for
+ DWARFDebugInfoEntry* die_ptr = GetDIEPtr(hint_die_offset, &cu_sp);
+ if (die_ptr)
+ {
+ if (cu_sp.get())
+ {
+ if (function_die || block_die)
+ return die_ptr->LookupAddress(address, m_dwarf2Data, cu_sp.get(), function_die, block_die);
+
+ // We only wanted the compile unit that contained this address
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+
+void
+DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded()
+{
+ if (m_compile_units.empty())
+ {
+ if (m_dwarf2Data != NULL)
+ {
+ uint32_t offset = 0;
+ const DataExtractor &debug_info_data = m_dwarf2Data->get_debug_info_data();
+ while (debug_info_data.ValidOffset(offset))
+ {
+ DWARFCompileUnitSP cu_sp(new DWARFCompileUnit(m_dwarf2Data));
+ // Out of memory?
+ if (cu_sp.get() == NULL)
+ break;
+
+ if (cu_sp->Extract(debug_info_data, &offset) == false)
+ break;
+
+ m_compile_units.push_back(cu_sp);
+
+ offset = cu_sp->GetNextCompileUnitOffset();
+ }
+ }
+ }
+}
+
+uint32_t
+DWARFDebugInfo::GetNumCompileUnits()
+{
+ ParseCompileUnitHeadersIfNeeded();
+ return m_compile_units.size();
+}
+
+DWARFCompileUnit*
+DWARFDebugInfo::GetCompileUnitAtIndex(uint32_t idx)
+{
+ DWARFCompileUnit* cu = NULL;
+ if (idx < GetNumCompileUnits())
+ cu = m_compile_units[idx].get();
+ return cu;
+}
+
+static bool CompileUnitOffsetLessThan (const DWARFCompileUnitSP& a, const DWARFCompileUnitSP& b)
+{
+ return a->GetOffset() < b->GetOffset();
+}
+
+
+static int
+CompareDWARFCompileUnitSPOffset (const void *key, const void *arrmem)
+{
+ const dw_offset_t key_cu_offset = *(dw_offset_t*) key;
+ const dw_offset_t cu_offset = ((DWARFCompileUnitSP *)arrmem)->get()->GetOffset();
+ if (key_cu_offset < cu_offset)
+ return -1;
+ if (key_cu_offset > cu_offset)
+ return 1;
+ return 0;
+}
+
+DWARFCompileUnitSP
+DWARFDebugInfo::GetCompileUnit(dw_offset_t cu_offset, uint32_t* idx_ptr)
+{
+ DWARFCompileUnitSP cu_sp;
+ uint32_t cu_idx = DW_INVALID_INDEX;
+ if (cu_offset != DW_INVALID_OFFSET)
+ {
+ ParseCompileUnitHeadersIfNeeded();
+
+ DWARFCompileUnitSP* match = (DWARFCompileUnitSP*)bsearch(&cu_offset, &m_compile_units[0], m_compile_units.size(), sizeof(DWARFCompileUnitSP), CompareDWARFCompileUnitSPOffset);
+ if (match)
+ {
+ cu_sp = *match;
+ cu_idx = match - &m_compile_units[0];
+ }
+ }
+ if (idx_ptr)
+ *idx_ptr = cu_idx;
+ return cu_sp;
+}
+
+DWARFCompileUnitSP
+DWARFDebugInfo::GetCompileUnitContainingDIE(dw_offset_t die_offset)
+{
+ DWARFCompileUnitSP cu_sp;
+ if (die_offset != DW_INVALID_OFFSET)
+ {
+ ParseCompileUnitHeadersIfNeeded();
+
+ CompileUnitColl::const_iterator end_pos = m_compile_units.end();
+ CompileUnitColl::const_iterator pos;
+
+ for (pos = m_compile_units.begin(); pos != end_pos; ++pos)
+ {
+ dw_offset_t cu_start_offset = (*pos)->GetOffset();
+ dw_offset_t cu_end_offset = (*pos)->GetNextCompileUnitOffset();
+ if (cu_start_offset <= die_offset && die_offset < cu_end_offset)
+ {
+ cu_sp = *pos;
+ break;
+ }
+ }
+ }
+ return cu_sp;
+}
+
+//----------------------------------------------------------------------
+// Compare function DWARFDebugAranges::Range structures
+//----------------------------------------------------------------------
+static bool CompareDIEOffset (const DWARFDebugInfoEntry& die1, const DWARFDebugInfoEntry& die2)
+{
+ return die1.GetOffset() < die2.GetOffset();
+}
+
+
+//----------------------------------------------------------------------
+// GetDIE()
+//
+// Get the DIE (Debug Information Entry) with the specified offset.
+//----------------------------------------------------------------------
+DWARFDebugInfoEntry*
+DWARFDebugInfo::GetDIEPtr(dw_offset_t die_offset, DWARFCompileUnitSP* cu_sp_ptr)
+{
+ DWARFCompileUnitSP cu_sp(GetCompileUnitContainingDIE(die_offset));
+ if (cu_sp_ptr)
+ *cu_sp_ptr = cu_sp;
+ if (cu_sp.get())
+ return cu_sp->GetDIEPtr(die_offset);
+ return NULL; // Not found in any compile units
+}
+
+const DWARFDebugInfoEntry*
+DWARFDebugInfo::GetDIEPtrContainingOffset(dw_offset_t die_offset, DWARFCompileUnitSP* cu_sp_ptr)
+{
+ DWARFCompileUnitSP cu_sp(GetCompileUnitContainingDIE(die_offset));
+ if (cu_sp_ptr)
+ *cu_sp_ptr = cu_sp;
+ if (cu_sp.get())
+ return cu_sp->GetDIEPtrContainingOffset(die_offset);
+
+ return NULL; // Not found in any compile units
+
+}
+
+//----------------------------------------------------------------------
+// DWARFDebugInfo_ParseCallback
+//
+// A callback function for the static DWARFDebugInfo::Parse() function
+// that gets parses all compile units and DIE's into an internate
+// representation for further modification.
+//----------------------------------------------------------------------
+
+static dw_offset_t
+DWARFDebugInfo_ParseCallback
+(
+ SymbolFileDWARF* dwarf2Data,
+ DWARFCompileUnitSP& cu_sp,
+ DWARFDebugInfoEntry* die,
+ const dw_offset_t next_offset,
+ const uint32_t curr_depth,
+ void* userData
+)
+{
+ DWARFDebugInfo* debug_info = (DWARFDebugInfo*)userData;
+ DWARFCompileUnit* cu = cu_sp.get();
+ if (die)
+ {
+ cu->AddDIE(*die);
+ }
+ else if (cu)
+ {
+ debug_info->AddCompileUnit(cu_sp);
+ }
+
+ // Just return the current offset to parse the next CU or DIE entry
+ return next_offset;
+}
+
+//----------------------------------------------------------------------
+// AddCompileUnit
+//----------------------------------------------------------------------
+void
+DWARFDebugInfo::AddCompileUnit(DWARFCompileUnitSP& cu)
+{
+ m_compile_units.push_back(cu);
+}
+
+/*
+void
+DWARFDebugInfo::AddDIE(DWARFDebugInfoEntry& die)
+{
+ m_die_array.push_back(die);
+}
+*/
+
+
+
+
+//----------------------------------------------------------------------
+// Parse
+//
+// Parses the .debug_info section and uses the .debug_abbrev section
+// and various other sections in the SymbolFileDWARF class and calls the
+// supplied callback function each time a compile unit header, or debug
+// information entry is successfully parsed. This function can be used
+// for different tasks such as parsing the file contents into a
+// structured data, dumping, verifying and much more.
+//----------------------------------------------------------------------
+void
+DWARFDebugInfo::Parse(SymbolFileDWARF* dwarf2Data, Callback callback, void* userData)
+{
+ if (dwarf2Data)
+ {
+ uint32_t offset = 0;
+ uint32_t depth = 0;
+ DWARFCompileUnitSP cu(new DWARFCompileUnit(dwarf2Data));
+ if (cu.get() == NULL)
+ return;
+ DWARFDebugInfoEntry die;
+
+ while (cu->Extract(dwarf2Data->get_debug_info_data(), &offset))
+ {
+ const dw_offset_t next_cu_offset = cu->GetNextCompileUnitOffset();
+
+ depth = 0;
+ // Call the callback funtion with no DIE pointer for the compile unit
+ // and get the offset that we are to continue to parse from
+ offset = callback(dwarf2Data, cu, NULL, offset, depth, userData);
+
+ // Make sure we are within our compile unit
+ if (offset < next_cu_offset)
+ {
+ // We are in our compile unit, parse starting at the offset
+ // we were told to parse
+ bool done = false;
+ while (!done && die.Extract(dwarf2Data, cu.get(), &offset))
+ {
+ // Call the callback funtion with DIE pointer that falls within the compile unit
+ offset = callback(dwarf2Data, cu, &die, offset, depth, userData);
+
+ if (die.IsNULL())
+ {
+ if (depth)
+ --depth;
+ else
+ done = true; // We are done with this compile unit!
+ }
+ else if (die.HasChildren())
+ ++depth;
+ }
+ }
+
+ // Make sure the offset returned is valid, and if not stop parsing.
+ // Returning DW_INVALID_OFFSET from this callback is a good way to end
+ // all parsing
+ if (!dwarf2Data->get_debug_info_data().ValidOffset(offset))
+ break;
+
+ // See if during the callback anyone retained a copy of the compile
+ // unit other than ourselves and if so, let whomever did own the object
+ // and create a new one for our own use!
+ if (!cu.unique())
+ cu.reset(new DWARFCompileUnit(dwarf2Data));
+
+
+ // Make sure we start on a propper
+ offset = next_cu_offset;
+ }
+ }
+}
+
+/*
+typedef struct AddressRangeTag
+{
+ dw_addr_t lo_pc;
+ dw_addr_t hi_pc;
+ dw_offset_t die_offset;
+} AddressRange;
+*/
+struct DIERange
+{
+ DIERange() :
+ range(),
+ lo_die_offset(),
+ hi_die_offset()
+ {
+ }
+
+ DWARFDebugAranges::Range range;
+ dw_offset_t lo_die_offset;
+ dw_offset_t hi_die_offset;
+};
+
+typedef struct DwarfStat
+{
+ DwarfStat() : count(0), byte_size(0) {}
+ uint32_t count;
+ uint32_t byte_size;
+} DwarfStat;
+
+typedef map<dw_attr_t, DwarfStat> DwarfAttrStatMap;
+
+typedef struct DIEStat
+{
+ DIEStat() : count(0), byte_size(0), attr_stats() {}
+ uint32_t count;
+ uint32_t byte_size;
+ DwarfAttrStatMap attr_stats;
+} DIEStat;
+
+typedef map<dw_tag_t, DIEStat> DIEStatMap;
+struct VerifyInfo
+{
+ VerifyInfo(Stream* the_strm) :
+ strm(the_strm),
+ die_ranges(),
+ addr_range_errors(0),
+ sibling_errors(0),
+ die_stats()
+ {
+ }
+
+ Stream* strm;
+ vector<DIERange> die_ranges;
+ uint32_t addr_range_errors;
+ uint32_t sibling_errors;
+ DIEStatMap die_stats;
+
+ DISALLOW_COPY_AND_ASSIGN(VerifyInfo);
+
+};
+
+
+//----------------------------------------------------------------------
+// VerifyCallback
+//
+// A callback function for the static DWARFDebugInfo::Parse() function
+// that gets called each time a compile unit header or debug information
+// entry is successfully parsed.
+//
+// This function will verify the DWARF information is well formed by
+// making sure that any DW_TAG_compile_unit tags that have valid address
+// ranges (DW_AT_low_pc and DW_AT_high_pc) have no gaps in the address
+// ranges of it contained DW_TAG_subprogram tags. Also the sibling chain
+// and relationships are verified to make sure nothing gets hosed up
+// when dead stripping occurs.
+//----------------------------------------------------------------------
+
+static dw_offset_t
+VerifyCallback
+(
+ SymbolFileDWARF* dwarf2Data,
+ DWARFCompileUnitSP& cu_sp,
+ DWARFDebugInfoEntry* die,
+ const dw_offset_t next_offset,
+ const uint32_t curr_depth,
+ void* userData
+)
+{
+ VerifyInfo* verifyInfo = (VerifyInfo*)userData;
+
+ const DWARFCompileUnit* cu = cu_sp.get();
+ Stream *s = verifyInfo->strm;
+ bool verbose = s->GetVerbose();
+ if (die)
+ {
+ // die->Dump(dwarf2Data, cu, f);
+ const DWARFAbbreviationDeclaration* abbrevDecl = die->GetAbbreviationDeclarationPtr();
+ // We have a DIE entry
+ if (abbrevDecl)
+ {
+ const dw_offset_t die_offset = die->GetOffset();
+ const dw_offset_t sibling = die->GetAttributeValueAsReference(dwarf2Data, cu, DW_AT_sibling, DW_INVALID_OFFSET);
+
+ if (sibling != DW_INVALID_OFFSET)
+ {
+ if (sibling <= next_offset)
+ {
+ if (verifyInfo->sibling_errors++ == 0)
+ s->Printf("ERROR\n");
+ s->Printf(" 0x%8.8x: sibling attribyte (0x%8.8x) in this die is not valid: it is less than this DIE or some of its contents.\n", die->GetOffset(), sibling);
+ }
+ else if (sibling > verifyInfo->die_ranges.back().hi_die_offset)
+ {
+ if (verifyInfo->sibling_errors++ == 0)
+ s->Printf("ERROR\n");
+ s->Printf(" 0x%8.8x: sibling attribute (0x%8.8x) in this DIE is not valid: it is greater than the end of the parent scope.\n", die->GetOffset(), sibling);
+ }
+ }
+
+ if ((die_offset < verifyInfo->die_ranges.back().lo_die_offset) || (die_offset >= verifyInfo->die_ranges.back().hi_die_offset))
+ {
+ if (verifyInfo->sibling_errors++ == 0)
+ s->Printf("ERROR\n");
+ s->Printf(" 0x%8.8x: DIE offset is not within the parent DIE range {0x%8.8x}: (0x%8.8x - 0x%8.8x)\n",
+ die->GetOffset(),
+ verifyInfo->die_ranges.back().range.offset,
+ verifyInfo->die_ranges.back().lo_die_offset,
+ verifyInfo->die_ranges.back().hi_die_offset);
+
+ }
+
+ dw_tag_t tag = abbrevDecl->Tag();
+
+ // Keep some stats on this DWARF file
+ verifyInfo->die_stats[tag].count++;
+ verifyInfo->die_stats[tag].byte_size += (next_offset - die->GetOffset());
+
+ if (verbose)
+ {
+ DIEStat& tag_stat = verifyInfo->die_stats[tag];
+
+ const DataExtractor& debug_info = dwarf2Data->get_debug_info_data();
+
+ dw_offset_t offset = die->GetOffset();
+ // Skip the abbreviation code so we are at the data for the attributes
+ debug_info.Skip_LEB128(&offset);
+
+ const uint32_t numAttributes = abbrevDecl->NumAttributes();
+ dw_attr_t attr;
+ dw_form_t form;
+ for (uint32_t idx = 0; idx < numAttributes; ++idx)
+ {
+ dw_offset_t start_offset = offset;
+ abbrevDecl->GetAttrAndFormByIndexUnchecked(idx, attr, form);
+ DWARFFormValue::SkipValue(form, debug_info, &offset, cu);
+
+ if (tag_stat.attr_stats.find(attr) == tag_stat.attr_stats.end())
+ {
+ tag_stat.attr_stats[attr].count = 0;
+ tag_stat.attr_stats[attr].byte_size = 0;
+ }
+
+ tag_stat.attr_stats[attr].count++;
+ tag_stat.attr_stats[attr].byte_size += offset - start_offset;
+ }
+ }
+
+ DWARFDebugAranges::Range range;
+ range.offset = die->GetOffset();
+
+ switch (tag)
+ {
+ case DW_TAG_compile_unit:
+ // Check for previous subroutines that were within a previous
+ //
+ // VerifyAddressRangesForCU(verifyInfo);
+ // Remember which compile unit we are dealing with so we can verify
+ // the address ranges within it (if any) are contiguous. The DWARF
+ // spec states that if a compile unit TAG has high and low PC
+ // attributes, there must be no gaps in the address ranges of it's
+ // contained subtroutines. If there are gaps, the high and low PC
+ // must not be in the DW_TAG_compile_unit's attributes. Errors like
+ // this can crop up when optimized code is dead stripped and the debug
+ // information isn't properly fixed up for output.
+ range.lo_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_low_pc, DW_INVALID_ADDRESS);
+ if (range.lo_pc != DW_INVALID_ADDRESS)
+ {
+ range.hi_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_high_pc, DW_INVALID_ADDRESS);
+ if (s->GetVerbose())
+ {
+ s->Printf("\n CU ");
+ range.Dump(s);
+ }
+ }
+ else
+ {
+ range.lo_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_entry_pc, DW_INVALID_ADDRESS);
+ }
+ break;
+
+ case DW_TAG_subprogram:
+ // If the DW_TAG_compile_unit that contained this function had a
+ // valid address range, add all of the valid subroutine address
+ // ranges to a collection of addresses which will be sorted
+ // and verified right before the next DW_TAG_compile_unit is
+ // processed to make sure that there are no gaps in the address
+ // range.
+ range.lo_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_low_pc, DW_INVALID_ADDRESS);
+ if (range.lo_pc != DW_INVALID_ADDRESS)
+ {
+ range.hi_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_high_pc, DW_INVALID_ADDRESS);
+ if (range.hi_pc != DW_INVALID_ADDRESS)
+ {
+ range.offset = die->GetOffset();
+ bool valid = range.ValidRange();
+ if (!valid || s->GetVerbose())
+ {
+ s->Printf("\n FUNC ");
+ range.Dump(s);
+ if (!valid)
+ {
+ ++verifyInfo->addr_range_errors;
+ s->Printf(" ERROR: Invalid address range for function.");
+ }
+ }
+
+ // Only add to our subroutine ranges if our compile unit has a valid address range
+ // if (valid && verifyInfo->die_ranges.size() >= 2 && verifyInfo->die_ranges[1].range.ValidRange())
+ // verifyInfo->subroutine_ranges.InsertRange(range);
+ }
+ }
+ break;
+
+ case DW_TAG_lexical_block:
+ case DW_TAG_inlined_subroutine:
+ {
+ range.lo_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_low_pc, DW_INVALID_ADDRESS);
+ if (range.lo_pc != DW_INVALID_ADDRESS)
+ {
+ range.hi_pc = die->GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_high_pc, DW_INVALID_ADDRESS);
+ if (range.hi_pc != DW_INVALID_ADDRESS)
+ {
+ range.offset = die->GetOffset();
+ bool valid = range.ValidRange();
+ if (!valid || s->GetVerbose())
+ {
+ s->Printf("\n BLCK ");
+ range.Dump(s);
+ if (!valid)
+ {
+ ++verifyInfo->addr_range_errors;
+ s->Printf(" ERROR: Invalid address range for block or inlined subroutine.");
+ }
+ }
+ }
+ }
+ }
+ break;
+ }
+
+ if (range.ValidRange() && verifyInfo->die_ranges.back().range.ValidRange())
+ {
+ if (!verifyInfo->die_ranges.back().range.Contains(range))
+ {
+ ++verifyInfo->addr_range_errors;
+ s->Printf("\n ");
+ range.Dump(s);
+ s->Printf(" ERROR: Range is not in parent");
+ verifyInfo->die_ranges.back().range.Dump(s);
+ }
+ }
+
+ if (die->HasChildren())
+ {
+ // Keep tabs on the valid address ranges for the current item to make
+ // sure that it all fits (make sure the sibling offsets got fixed up
+ // correctly if any functions were dead stripped).
+ DIERange die_range;
+ die_range.range = range;
+ die_range.lo_die_offset = next_offset;
+ die_range.hi_die_offset = sibling;
+ if (die_range.hi_die_offset == DW_INVALID_OFFSET)
+ die_range.hi_die_offset = verifyInfo->die_ranges.back().hi_die_offset;
+ verifyInfo->die_ranges.push_back(die_range);
+ }
+ }
+ else
+ {
+ // NULL entry
+ verifyInfo->die_ranges.pop_back();
+ }
+ }
+ else
+ {
+ // cu->Dump(ostrm_ptr); // Dump the compile unit for the DIE
+ // We have a new comile unit header
+ verifyInfo->die_ranges.clear();
+ DIERange die_range;
+ die_range.range.offset = cu->GetOffset();
+ die_range.lo_die_offset = next_offset;
+ die_range.hi_die_offset = cu->GetNextCompileUnitOffset();
+ verifyInfo->die_ranges.push_back(die_range);
+ }
+
+ // Just return the current offset to parse the next CU or DIE entry
+ return next_offset;
+}
+
+
+class CompareDIEStatSizes
+{
+public:
+ bool operator() (const DIEStatMap::const_iterator& pos1, const DIEStatMap::const_iterator& pos2) const
+ {
+ return pos1->second.byte_size <= pos2->second.byte_size;
+ }
+};
+
+class CompareAttrDIEStatSizes
+{
+public:
+ bool operator() (const DwarfAttrStatMap::const_iterator& pos1, const DwarfAttrStatMap::const_iterator& pos2) const
+ {
+ return pos1->second.byte_size <= pos2->second.byte_size;
+ }
+};
+
+//----------------------------------------------------------------------
+// Verify
+//
+// Verifies the DWARF information is valid.
+//----------------------------------------------------------------------
+void
+DWARFDebugInfo::Verify(Stream *s, SymbolFileDWARF* dwarf2Data)
+{
+ s->Printf("Verifying Compile Unit Header chain.....");
+ VerifyInfo verifyInfo(s);
+ verifyInfo.addr_range_errors = 0;
+ verifyInfo.sibling_errors = 0;
+
+ bool verbose = s->GetVerbose();
+
+ uint32_t offset = 0;
+ if (verbose)
+ s->EOL();
+// vector<dw_offset_t> valid_cu_offsets;
+ DWARFCompileUnit cu (dwarf2Data);
+ bool success = true;
+ while ( success && dwarf2Data->get_debug_info_data().ValidOffset(offset+cu.Size()) )
+ {
+ success = cu.Extract (dwarf2Data->get_debug_info_data(), &offset);
+ if (!success)
+ s->Printf("ERROR\n");
+ // else
+ // valid_cu_offsets.push_back(cu.GetOffset());
+
+ cu.Verify(verifyInfo.strm);
+ offset = cu.GetNextCompileUnitOffset();
+ }
+
+ if (success)
+ s->Printf("OK\n");
+
+ s->Printf("Verifying address ranges and siblings...");
+ if (verbose)
+ s->EOL();
+ DWARFDebugInfo::Parse(dwarf2Data, VerifyCallback, &verifyInfo);
+
+// VerifyAddressRangesForCU(&verifyInfo);
+
+ if (verifyInfo.addr_range_errors > 0)
+ s->Printf("\nERRORS - %u error(s) were found.\n", verifyInfo.addr_range_errors);
+ else
+ s->Printf("OK\n");
+
+ uint32_t total_category_sizes[kNumTagCategories] = {0};
+ uint32_t total_category_count[kNumTagCategories] = {0};
+ uint32_t total_die_count = 0;
+ uint32_t total_die_size = 0;
+
+ typedef set<DIEStatMap::const_iterator, CompareDIEStatSizes> DIEStatBySizeMap;
+
+ s->PutCString( "\n"
+ "DWARF Statistics\n"
+ "Count Size Size % Tag\n"
+ "-------- -------- -------- -------------------------------------------\n");
+ DIEStatBySizeMap statBySizeMap;
+ DIEStatMap::const_iterator pos;
+ DIEStatMap::const_iterator end_pos = verifyInfo.die_stats.end();
+ for (pos = verifyInfo.die_stats.begin(); pos != end_pos; ++pos)
+ {
+ const uint32_t die_count = pos->second.count;
+ const uint32_t die_size = pos->second.byte_size;
+
+ statBySizeMap.insert(pos);
+ total_die_count += die_count;
+ total_die_size += die_size;
+ DW_TAG_CategoryEnum category = get_tag_category(pos->first);
+ total_category_sizes[category] += die_size;
+ total_category_count[category] += die_count;
+ }
+
+ float total_die_size_float = total_die_size;
+
+ DIEStatBySizeMap::const_reverse_iterator size_pos;
+ DIEStatBySizeMap::const_reverse_iterator size_pos_end = statBySizeMap.rend();
+ float percentage;
+ for (size_pos = statBySizeMap.rbegin(); size_pos != size_pos_end; ++size_pos)
+ {
+ pos = *size_pos;
+
+ const DIEStat& tag_stat = pos->second;
+
+ const uint32_t die_count = tag_stat.count;
+ const uint32_t die_size = tag_stat.byte_size;
+ percentage = ((float)die_size/total_die_size_float)*100.0;
+ s->Printf("%7u %8u %2.2f%% %s\n", die_count, die_size, percentage, DW_TAG_value_to_name(pos->first));
+
+ const DwarfAttrStatMap& attr_stats = tag_stat.attr_stats;
+ if (!attr_stats.empty())
+ {
+ typedef set<DwarfAttrStatMap::const_iterator, CompareAttrDIEStatSizes> DwarfAttrStatBySizeMap;
+ DwarfAttrStatBySizeMap attrStatBySizeMap;
+ DwarfAttrStatMap::const_iterator attr_stat_pos;
+ DwarfAttrStatMap::const_iterator attr_stat_pos_end = attr_stats.end();
+ for (attr_stat_pos = attr_stats.begin(); attr_stat_pos != attr_stat_pos_end; ++attr_stat_pos)
+ {
+ attrStatBySizeMap.insert(attr_stat_pos);
+ }
+
+ DwarfAttrStatBySizeMap::const_reverse_iterator attr_size_pos;
+ DwarfAttrStatBySizeMap::const_reverse_iterator attr_size_pos_end = attrStatBySizeMap.rend();
+ for (attr_size_pos = attrStatBySizeMap.rbegin(); attr_size_pos != attr_size_pos_end; ++attr_size_pos)
+ {
+ attr_stat_pos = *attr_size_pos;
+ percentage = ((float)attr_stat_pos->second.byte_size/die_size)*100.0;
+ s->Printf("%7u %8u %2.2f%% %s\n", attr_stat_pos->second.count, attr_stat_pos->second.byte_size, percentage, DW_AT_value_to_name(attr_stat_pos->first));
+ }
+ s->EOL();
+ }
+ }
+
+ s->Printf("-------- -------- -------- -------------------------------------------\n");
+ s->Printf("%7u %8u 100.00% Total for all DIEs\n", total_die_count, total_die_size);
+
+ float total_category_percentages[kNumTagCategories] =
+ {
+ ((float)total_category_sizes[TagCategoryVariable]/total_die_size_float)*100.0,
+ ((float)total_category_sizes[TagCategoryType]/total_die_size_float)*100.0,
+ ((float)total_category_sizes[TagCategoryProgram]/total_die_size_float)*100.0
+ };
+
+ s->EOL();
+ s->Printf("%7u %8u %2.2f%% %s\n", total_category_count[TagCategoryVariable], total_category_sizes[TagCategoryVariable], total_category_percentages[TagCategoryVariable], "Total for variable related DIEs");
+ s->Printf("%7u %8u %2.2f%% %s\n", total_category_count[TagCategoryType], total_category_sizes[TagCategoryType], total_category_percentages[TagCategoryType], "Total for type related DIEs");
+ s->Printf("%7u %8u %2.2f%% %s\n", total_category_count[TagCategoryProgram], total_category_sizes[TagCategoryProgram], total_category_percentages[TagCategoryProgram], "Total for program related DIEs");
+ s->Printf("\n\n");
+}
+
+typedef struct DumpInfo
+{
+ DumpInfo(Stream* init_strm, uint32_t off, uint32_t depth) :
+ strm(init_strm),
+ die_offset(off),
+ recurse_depth(depth),
+ found_depth(UINT_MAX),
+ found_die(false),
+ ancestors()
+ {
+ }
+ Stream* strm;
+ const uint32_t die_offset;
+ const uint32_t recurse_depth;
+ uint32_t found_depth;
+ bool found_die;
+ std::vector<DWARFDebugInfoEntry> ancestors;
+
+ DISALLOW_COPY_AND_ASSIGN(DumpInfo);
+} DumpInfo;
+
+//----------------------------------------------------------------------
+// DumpCallback
+//
+// A callback function for the static DWARFDebugInfo::Parse() function
+// that gets called each time a compile unit header or debug information
+// entry is successfully parsed.
+//
+// This function dump DWARF information and obey recurse depth and
+// wether a single DIE is to be dumped (or all of the data).
+//----------------------------------------------------------------------
+static dw_offset_t DumpCallback
+(
+ SymbolFileDWARF* dwarf2Data,
+ DWARFCompileUnitSP& cu_sp,
+ DWARFDebugInfoEntry* die,
+ const dw_offset_t next_offset,
+ const uint32_t curr_depth,
+ void* userData
+)
+{
+ DumpInfo* dumpInfo = (DumpInfo*)userData;
+
+ const DWARFCompileUnit* cu = cu_sp.get();
+
+ Stream *s = dumpInfo->strm;
+ bool show_parents = s->GetFlags().IsSet(DWARFDebugInfo::eDumpFlag_ShowAncestors);
+
+ if (die)
+ {
+ // Are we dumping everything?
+ if (dumpInfo->die_offset == DW_INVALID_OFFSET)
+ {
+ // Yes we are dumping everything. Obey our recurse level though
+ if (curr_depth < dumpInfo->recurse_depth)
+ die->Dump(dwarf2Data, cu, s, 0);
+ }
+ else
+ {
+ // We are dumping a specific DIE entry by offset
+ if (dumpInfo->die_offset == die->GetOffset())
+ {
+ // We found the DIE we were looking for, dump it!
+ if (show_parents)
+ {
+ s->SetIndentLevel(0);
+ const uint32_t num_ancestors = dumpInfo->ancestors.size();
+ if (num_ancestors > 0)
+ {
+ for (uint32_t i=0; i<num_ancestors-1; ++i)
+ {
+ dumpInfo->ancestors[i].Dump(dwarf2Data, cu, s, 0);
+ s->IndentMore();
+ }
+ }
+ }
+
+ dumpInfo->found_depth = curr_depth;
+
+ die->Dump(dwarf2Data, cu, s, 0);
+
+ // Note that we found the DIE we were looking for
+ dumpInfo->found_die = true;
+
+ // Since we are dumping a single DIE, if there are no children we are done!
+ if (!die->HasChildren() || dumpInfo->recurse_depth == 0)
+ return DW_INVALID_OFFSET; // Return an invalid address to end parsing
+ }
+ else if (dumpInfo->found_die)
+ {
+ // Are we done with all the children?
+ if (curr_depth <= dumpInfo->found_depth)
+ return DW_INVALID_OFFSET;
+
+ // We have already found our DIE and are printing it's children. Obey
+ // our recurse depth and return an invalid offset if we get done
+ // dumping all the the children
+ if (dumpInfo->recurse_depth == UINT_MAX || curr_depth <= dumpInfo->found_depth + dumpInfo->recurse_depth)
+ die->Dump(dwarf2Data, cu, s, 0);
+ }
+ else if (dumpInfo->die_offset > die->GetOffset())
+ {
+ if (show_parents)
+ dumpInfo->ancestors.back() = *die;
+ }
+ }
+
+ // Keep up with our indent level
+ if (die->IsNULL())
+ {
+ if (show_parents)
+ dumpInfo->ancestors.pop_back();
+
+ if (curr_depth <= 1)
+ return cu->GetNextCompileUnitOffset();
+ else
+ s->IndentLess();
+ }
+ else if (die->HasChildren())
+ {
+ if (show_parents)
+ {
+ DWARFDebugInfoEntry null_die;
+ dumpInfo->ancestors.push_back(null_die);
+ }
+ s->IndentMore();
+ }
+ }
+ else
+ {
+ if (cu == NULL)
+ s->PutCString("NULL - cu");
+ // We have a compile unit, reset our indent level to zero just in case
+ s->SetIndentLevel(0);
+
+ // See if we are dumping everything?
+ if (dumpInfo->die_offset == DW_INVALID_OFFSET)
+ {
+ // We are dumping everything
+ cu->Dump(s);
+ return cu->GetFirstDIEOffset(); // Return true to parse all DIEs in this Compile Unit
+ }
+ else
+ {
+ if (show_parents)
+ {
+ dumpInfo->ancestors.clear();
+ dumpInfo->ancestors.resize(1);
+ }
+
+ // We are dumping only a single DIE possibly with it's children and
+ // we must find it's compile unit before we can dump it properly
+ if (dumpInfo->die_offset < cu->GetFirstDIEOffset())
+ {
+ // Not found, maybe the DIE offset provided wasn't correct?
+ // *ostrm_ptr << "DIE at offset " << HEX32 << dumpInfo->die_offset << " was not found." << endl;
+ return DW_INVALID_OFFSET;
+ }
+ else
+ {
+ // See if the DIE is in this compile unit?
+ if (dumpInfo->die_offset < cu->GetNextCompileUnitOffset())
+ {
+ // This DIE is in this compile unit!
+ if (s->GetVerbose())
+ cu->Dump(s); // Dump the compile unit for the DIE in verbose mode
+
+ return next_offset;
+ // // We found our compile unit that contains our DIE, just skip to dumping the requested DIE...
+ // return dumpInfo->die_offset;
+ }
+ else
+ {
+ // Skip to the next compile unit as the DIE isn't in the current one!
+ return cu->GetNextCompileUnitOffset();
+ }
+ }
+ }
+ }
+
+ // Just return the current offset to parse the next CU or DIE entry
+ return next_offset;
+}
+
+//----------------------------------------------------------------------
+// Dump
+//
+// Dump the information in the .debug_info section to the specified
+// ostream. If die_offset is valid, a single DIE will be dumped. If the
+// die_offset is invalid, all the DWARF information will be dumped. Both
+// cases will obey a "recurse_depth" or how deep to traverse into the
+// children of each DIE entry. A recurse_depth of zero will dump all
+// compile unit headers. A recurse_depth of 1 will dump all compile unit
+// headers and the DW_TAG_compile unit tags. A depth of 2 will also
+// dump all types and functions.
+//----------------------------------------------------------------------
+void
+DWARFDebugInfo::Dump
+(
+ Stream *s,
+ SymbolFileDWARF* dwarf2Data,
+ const uint32_t die_offset,
+ const uint32_t recurse_depth
+)
+{
+ DumpInfo dumpInfo(s, die_offset, recurse_depth);
+ s->PutCString(".debug_info contents");
+ if (dwarf2Data->get_debug_info_data().GetByteSize() > 0)
+ {
+ if (die_offset == DW_INVALID_OFFSET)
+ s->PutCString(":\n");
+ else
+ {
+ s->Printf(" for DIE entry at .debug_info[0x%8.8x]", die_offset);
+ if (recurse_depth != UINT_MAX)
+ s->Printf(" recursing %u levels deep.", recurse_depth);
+ s->EOL();
+ }
+ }
+ else
+ {
+ s->PutCString(": < EMPTY >\n");
+ return;
+ }
+ DWARFDebugInfo::Parse(dwarf2Data, DumpCallback, &dumpInfo);
+}
+
+
+//----------------------------------------------------------------------
+// Dump
+//
+// Dump the contents of this DWARFDebugInfo object as has been parsed
+// and/or modified after it has been parsed.
+//----------------------------------------------------------------------
+void
+DWARFDebugInfo::Dump (Stream *s, const uint32_t die_offset, const uint32_t recurse_depth)
+{
+ DumpInfo dumpInfo(s, die_offset, recurse_depth);
+
+ s->PutCString("Dumping .debug_info section from internal representation\n");
+
+ CompileUnitColl::const_iterator pos;
+ uint32_t curr_depth = 0;
+ ParseCompileUnitHeadersIfNeeded();
+ for (pos = m_compile_units.begin(); pos != m_compile_units.end(); ++pos)
+ {
+ const DWARFCompileUnitSP& cu_sp = *pos;
+ DumpCallback(m_dwarf2Data, (DWARFCompileUnitSP&)cu_sp, NULL, 0, curr_depth, &dumpInfo);
+ cu_sp->DIE()->Dump(m_dwarf2Data, cu_sp.get(), s, recurse_depth);
+ }
+}
+
+
+//----------------------------------------------------------------------
+// FindCallbackString
+//
+// A callback function for the static DWARFDebugInfo::Parse() function
+// that gets called each time a compile unit header or debug information
+// entry is successfully parsed.
+//
+// This function will find the die_offset of any items whose DW_AT_name
+// matches the given string
+//----------------------------------------------------------------------
+typedef struct FindCallbackStringInfoTag
+{
+ const char* name;
+ bool ignore_case;
+ RegularExpression* regex;
+ vector<dw_offset_t>& die_offsets;
+} FindCallbackStringInfo;
+
+static dw_offset_t FindCallbackString
+(
+ SymbolFileDWARF* dwarf2Data,
+ DWARFCompileUnitSP& cu_sp,
+ DWARFDebugInfoEntry* die,
+ const dw_offset_t next_offset,
+ const uint32_t curr_depth,
+ void* userData
+)
+{
+ FindCallbackStringInfo* info = (FindCallbackStringInfo*)userData;
+ const DWARFCompileUnit* cu = cu_sp.get();
+
+ if (die)
+ {
+ const char* die_name = die->GetName(dwarf2Data, cu);
+ if (die_name)
+ {
+ if (info->regex)
+ {
+ if (info->regex->Execute(die_name))
+ info->die_offsets.push_back(die->GetOffset());
+ }
+ else
+ {
+ if ((info->ignore_case ? strcasecmp(die_name, info->name) : strcmp(die_name, info->name)) == 0)
+ info->die_offsets.push_back(die->GetOffset());
+ }
+ }
+ }
+
+ // Just return the current offset to parse the next CU or DIE entry
+ return next_offset;
+}
+
+//----------------------------------------------------------------------
+// Find
+//
+// Finds all DIE that have a specific DW_AT_name attribute by manually
+// searching through the debug information (not using the
+// .debug_pubnames section). The string must match the entire name
+// and case sensitive searches are an option.
+//----------------------------------------------------------------------
+bool
+DWARFDebugInfo::Find(const char* name, bool ignore_case, vector<dw_offset_t>& die_offsets) const
+{
+ die_offsets.clear();
+ if (name && name[0])
+ {
+ FindCallbackStringInfo info = { name, ignore_case, NULL, die_offsets };
+ DWARFDebugInfo::Parse(m_dwarf2Data, FindCallbackString, &info);
+ }
+ return !die_offsets.empty();
+}
+
+//----------------------------------------------------------------------
+// Find
+//
+// Finds all DIE that have a specific DW_AT_name attribute by manually
+// searching through the debug information (not using the
+// .debug_pubnames section). The string must match the supplied regular
+// expression.
+//----------------------------------------------------------------------
+bool
+DWARFDebugInfo::Find(RegularExpression& re, vector<dw_offset_t>& die_offsets) const
+{
+ die_offsets.clear();
+ FindCallbackStringInfo info = { NULL, false, &re, die_offsets };
+ DWARFDebugInfo::Parse(m_dwarf2Data, FindCallbackString, &info);
+ return !die_offsets.empty();
+}