llvm-project/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

1246 lines
43 KiB
C++
Raw Normal View History

//===-- 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 "lldb/Symbol/ObjectFile.h"
#include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h"
#include "DWARFCompileUnit.h"
#include "DWARFDebugAranges.h"
#include "DWARFDebugInfoEntry.h"
#include "DWARFFormValue.h"
#include "LogChannelDWARF.h"
using namespace lldb_private;
using namespace std;
//----------------------------------------------------------------------
// Constructor
//----------------------------------------------------------------------
DWARFDebugInfo::DWARFDebugInfo() :
m_dwarf2Data(NULL),
m_compile_units(),
m_cu_aranges_ap ()
{
}
//----------------------------------------------------------------------
// SetDwarfData
//----------------------------------------------------------------------
void
DWARFDebugInfo::SetDwarfData(SymbolFileDWARF* dwarf2Data)
{
m_dwarf2Data = dwarf2Data;
m_compile_units.clear();
}
DWARFDebugAranges &
DWARFDebugInfo::GetCompileUnitAranges ()
{
if (m_cu_aranges_ap.get() == NULL && m_dwarf2Data)
{
Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES);
m_cu_aranges_ap.reset (new DWARFDebugAranges());
const DataExtractor &debug_aranges_data = m_dwarf2Data->get_debug_aranges_data();
if (debug_aranges_data.GetByteSize() > 0)
{
if (log)
log->Printf ("DWARFDebugInfo::GetCompileUnitAranges() for \"%s/%s\" from .debug_aranges",
m_dwarf2Data->GetObjectFile()->GetFileSpec().GetDirectory().GetCString(),
m_dwarf2Data->GetObjectFile()->GetFileSpec().GetFilename().GetCString());
m_cu_aranges_ap->Extract (debug_aranges_data);
}
else
{
if (log)
log->Printf ("DWARFDebugInfo::GetCompileUnitAranges() for \"%s/%s\" by parsing",
m_dwarf2Data->GetObjectFile()->GetFileSpec().GetDirectory().GetCString(),
m_dwarf2Data->GetObjectFile()->GetFileSpec().GetFilename().GetCString());
const uint32_t num_compile_units = GetNumCompileUnits();
uint32_t idx;
const bool clear_dies_if_already_not_parsed = true;
for (idx = 0; idx < num_compile_units; ++idx)
{
DWARFCompileUnit* cu = GetCompileUnitAtIndex(idx);
if (cu)
cu->BuildAddressRangeTable (m_dwarf2Data, m_cu_aranges_ap.get(), clear_dies_if_already_not_parsed);
}
}
// Sort with a fudge factor of 16 to make sure if we have a lot
// of functions in the compile unit whose end address if followed
// a start address that is "fudge_size" bytes close, it will combine
// the arange entries. This currently happens a lot on x86_64. This
// will help reduce the size of the aranges since sort will sort all
// of them and combine aranges that are consecutive for ranges in the
// same compile unit and we really don't need it to be all that
// accurate since we will get exact accuracy when we search the
// actual compile unit aranges which point to the exact range and
// the exact DIE offset of the function.
const bool minimize = true;
const uint32_t fudge_factor = 16;
m_cu_aranges_ap->Sort (minimize, fudge_factor);
}
return *m_cu_aranges_ap.get();
}
//----------------------------------------------------------------------
// 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
{
DWARFDebugAranges &cu_aranges = GetCompileUnitAranges ();
const dw_offset_t cu_offset = cu_aranges.FindAddress (address);
cu_sp = GetCompileUnit(cu_offset);
}
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
}
DWARFDebugInfoEntry*
DWARFDebugInfo::GetDIEPtrWithCompileUnitHint (dw_offset_t die_offset, DWARFCompileUnit**cu_handle)
{
assert (cu_handle);
DWARFDebugInfoEntry* die = NULL;
if (*cu_handle)
die = (*cu_handle)->GetDIEPtr(die_offset);
if (die == NULL)
{
DWARFCompileUnitSP cu_sp (GetCompileUnitContainingDIE(die_offset));
if (cu_sp.get())
{
*cu_handle = cu_sp.get();
die = cu_sp->GetDIEPtr(die_offset);
}
}
if (die == NULL)
*cu_handle = NULL;
return die;
}
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 function 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 function 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 proper
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 attribute (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 subroutines. 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.set_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.set_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.");
}
}
}
}
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.set_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 compile 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),
Looking at some of the test suite failures in DWARF in .o files with the debug map showed that the location lists in the .o files needed some refactoring in order to work. The case that was failing was where a function that was in the "__TEXT.__textcoal_nt" in the .o file, and in the "__TEXT.__text" section in the main executable. This made symbol lookup fail due to the way we were finding a real address in the debug map which was by finding the section that the function was in in the .o file and trying to find this in the main executable. Now the section list supports finding a linked address in a section or any child sections. After fixing this, we ran into issue that were due to DWARF and how it represents locations lists. DWARF makes a list of address ranges and expressions that go along with those address ranges. The location addresses are expressed in terms of a compile unit address + offset. This works fine as long as nothing moves around. When stuff moves around and offsets change between the remapped compile unit base address and the new function address, then we can run into trouble. To deal with this, we now store supply a location list slide amount to any location list expressions that will allow us to make the location list addresses into zero based offsets from the object that owns the location list (always a function in our case). With these fixes we can now re-link random address ranges inside the debugger for use with our DWARF + debug map, incremental linking, and more. Another issue that arose when doing the DWARF in the .o files was that GCC 4.2 emits a ".debug_aranges" that only mentions functions that are externally visible. This makes .debug_aranges useless to us and we now generate a real address range lookup table in the DWARF parser at the same time as we index the name tables (that are needed because .debug_pubnames is just as useless). llvm-gcc doesn't generate a .debug_aranges section, though this could be fixed, we aren't going to rely upon it. Renamed a bunch of "UINT_MAX" to "UINT32_MAX". llvm-svn: 113829
2010-09-14 10:20:48 +08:00
found_depth(UINT32_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
// whether 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().Test(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
Looking at some of the test suite failures in DWARF in .o files with the debug map showed that the location lists in the .o files needed some refactoring in order to work. The case that was failing was where a function that was in the "__TEXT.__textcoal_nt" in the .o file, and in the "__TEXT.__text" section in the main executable. This made symbol lookup fail due to the way we were finding a real address in the debug map which was by finding the section that the function was in in the .o file and trying to find this in the main executable. Now the section list supports finding a linked address in a section or any child sections. After fixing this, we ran into issue that were due to DWARF and how it represents locations lists. DWARF makes a list of address ranges and expressions that go along with those address ranges. The location addresses are expressed in terms of a compile unit address + offset. This works fine as long as nothing moves around. When stuff moves around and offsets change between the remapped compile unit base address and the new function address, then we can run into trouble. To deal with this, we now store supply a location list slide amount to any location list expressions that will allow us to make the location list addresses into zero based offsets from the object that owns the location list (always a function in our case). With these fixes we can now re-link random address ranges inside the debugger for use with our DWARF + debug map, incremental linking, and more. Another issue that arose when doing the DWARF in the .o files was that GCC 4.2 emits a ".debug_aranges" that only mentions functions that are externally visible. This makes .debug_aranges useless to us and we now generate a real address range lookup table in the DWARF parser at the same time as we index the name tables (that are needed because .debug_pubnames is just as useless). llvm-gcc doesn't generate a .debug_aranges section, though this could be fixed, we aren't going to rely upon it. Renamed a bunch of "UINT_MAX" to "UINT32_MAX". llvm-svn: 113829
2010-09-14 10:20:48 +08:00
if (dumpInfo->recurse_depth == UINT32_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);
Looking at some of the test suite failures in DWARF in .o files with the debug map showed that the location lists in the .o files needed some refactoring in order to work. The case that was failing was where a function that was in the "__TEXT.__textcoal_nt" in the .o file, and in the "__TEXT.__text" section in the main executable. This made symbol lookup fail due to the way we were finding a real address in the debug map which was by finding the section that the function was in in the .o file and trying to find this in the main executable. Now the section list supports finding a linked address in a section or any child sections. After fixing this, we ran into issue that were due to DWARF and how it represents locations lists. DWARF makes a list of address ranges and expressions that go along with those address ranges. The location addresses are expressed in terms of a compile unit address + offset. This works fine as long as nothing moves around. When stuff moves around and offsets change between the remapped compile unit base address and the new function address, then we can run into trouble. To deal with this, we now store supply a location list slide amount to any location list expressions that will allow us to make the location list addresses into zero based offsets from the object that owns the location list (always a function in our case). With these fixes we can now re-link random address ranges inside the debugger for use with our DWARF + debug map, incremental linking, and more. Another issue that arose when doing the DWARF in the .o files was that GCC 4.2 emits a ".debug_aranges" that only mentions functions that are externally visible. This makes .debug_aranges useless to us and we now generate a real address range lookup table in the DWARF parser at the same time as we index the name tables (that are needed because .debug_pubnames is just as useless). llvm-gcc doesn't generate a .debug_aranges section, though this could be fixed, we aren't going to rely upon it. Renamed a bunch of "UINT_MAX" to "UINT32_MAX". llvm-svn: 113829
2010-09-14 10:20:48 +08:00
if (recurse_depth != UINT32_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();
}