This is an archive of the discontinued LLVM Phabricator instance.

Differential D12374

Code cleanup in preparation of adding split dwarf support
ClosedPublic

Authored by tberghammer on Aug 26 2015, 11:14 AM.

Details

Reviewers
clayborg
Commits
rG715cbe89398f: Code cleanup in preparation of adding split dwarf support
rLLDB247131: Code cleanup in preparation of adding split dwarf support
rL247131: Code cleanup in preparation of adding split dwarf support
Summary

Code cleanup in preparation of adding split dwarf support

  • Remove some unused code
  • Remove usage of DWARFDebugInfoEntry::Attributes where usage isn't reasonable
  • Cleanup DWARFMappedHash with separating it to header and implementation file and fixing the visibility of the functions

Diff Detail

Repository
rL LLVM

Event Timeline

tberghammer updated this revision to Diff 33226.Aug 26 2015, 11:14 AM
tberghammer retitled this revision from to Code cleanup in preparation of adding split dwarf support.
tberghammer updated this object.
tberghammer added a reviewer: clayborg.
tberghammer added a subscriber: lldb-commits.
Closed by commit rL247131: Code cleanup in preparation of adding split dwarf support (authored by tberghammer). · Explain WhySep 9 2015, 3:21 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
trunk/
source/
Plugins/
SymbolFile/
DWARF/
1 line
3 lines
40 lines
11 lines
33 lines
891 lines
741 lines
4 lines

Diff 34309

lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

Show All 16 Linesadd_lldb_library(lldbPluginSymbolFileDWARF
DWARFDebugRanges.cpp DWARFDebugRanges.cpp
DWARFDeclContext.cpp DWARFDeclContext.cpp
DWARFDefines.cpp DWARFDefines.cpp
DWARFDIE.cpp DWARFDIE.cpp
DWARFDIECollection.cpp DWARFDIECollection.cpp
DWARFFormValue.cpp DWARFFormValue.cpp
DWARFLocationDescription.cpp DWARFLocationDescription.cpp
DWARFLocationList.cpp DWARFLocationList.cpp
HashedNameToDIE.cpp
LogChannelDWARF.cpp LogChannelDWARF.cpp
NameToDIE.cpp NameToDIE.cpp
SymbolFileDWARF.cpp SymbolFileDWARF.cpp
SymbolFileDWARFDebugMap.cpp SymbolFileDWARFDebugMap.cpp
UniqueDWARFASTType.cpp UniqueDWARFASTType.cpp
) )

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Linespublic:
HasDIEsParsed () const HasDIEsParsed () const
{ {
return m_die_array.size() > 1; return m_die_array.size() > 1;
} }
DWARFDIE DWARFDIE
GetDIE (dw_offset_t die_offset); GetDIE (dw_offset_t die_offset);
DWARFDIE
GetDIEContainingOffset (dw_offset_t die_offset);
static uint8_t static uint8_t
GetAddressByteSize(const DWARFCompileUnit* cu); GetAddressByteSize(const DWARFCompileUnit* cu);
static bool static bool
IsDWARF64(const DWARFCompileUnit* cu); IsDWARF64(const DWARFCompileUnit* cu);
static uint8_t static uint8_t
GetDefaultAddressSize(); GetDefaultAddressSize();
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

Show First 20 Lines • Show All 563 Lines • ▼ Show 20 Lines if (die_offset != DW_INVALID_OFFSET)
else else
{ {
return m_dwarf2Data->DebugInfo()->GetDIE (die_offset); return m_dwarf2Data->DebugInfo()->GetDIE (die_offset);
} }
} }
return DWARFDIE(); // Not found return DWARFDIE(); // Not found
} }
//----------------------------------------------------------------------
// GetDIEPtrContainingOffset()
//
// Get the DIE (Debug Information Entry) that contains the specified
// .debug_info offset.
//----------------------------------------------------------------------
DWARFDIE
DWARFCompileUnit::GetDIEContainingOffset(dw_offset_t die_offset)
{
if (die_offset != DW_INVALID_OFFSET)
{
if (ContainsDIEOffset(die_offset))
{
ExtractDIEsIfNeeded (false);
DWARFDebugInfoEntry::iterator end = m_die_array.end();
DWARFDebugInfoEntry::iterator pos = lower_bound(m_die_array.begin(), end, die_offset, CompareDIEOffset);
if (pos != end)
{
if (die_offset >= (*pos).GetOffset())
{
DWARFDebugInfoEntry::iterator next = pos + 1;
if (next != end)
{
if (die_offset < (*next).GetOffset())
return DWARFDIE(this, &(*pos));
}
}
}
}
else
{
return m_dwarf2Data->DebugInfo()->GetDIEContainingOffset (die_offset);
}
}
return DWARFDIE(); // Not found
}
size_t size_t
DWARFCompileUnit::AppendDIEsWithTag (const dw_tag_t tag, DWARFDIECollection& dies, uint32_t depth) const DWARFCompileUnit::AppendDIEsWithTag (const dw_tag_t tag, DWARFDIECollection& dies, uint32_t depth) const
{ {
size_t old_size = dies.Size(); size_t old_size = dies.Size();
DWARFDebugInfoEntry::const_iterator pos; DWARFDebugInfoEntry::const_iterator pos;
DWARFDebugInfoEntry::const_iterator end = m_die_array.end(); DWARFDebugInfoEntry::const_iterator end = m_die_array.end();
for (pos = m_die_array.begin(); pos != end; ++pos) for (pos = m_die_array.begin(); pos != end; ++pos)
{ {
▲ Show 20 Lines • Show All 520 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
DWARFDebugInfo::GetDIE(dw_offset_t die_offset) DWARFDebugInfo::GetDIE(dw_offset_t die_offset)
{ {
DWARFCompileUnit *cu = GetCompileUnitContainingDIE(die_offset); DWARFCompileUnit *cu = GetCompileUnitContainingDIE(die_offset);
if (cu) if (cu)
return cu->GetDIE (die_offset); return cu->GetDIE (die_offset);
return DWARFDIE(); // Not found return DWARFDIE(); // Not found
} }
DWARFDIE
DWARFDebugInfo::GetDIEContainingOffset (dw_offset_t die_offset)
{
DWARFCompileUnit *cu = GetCompileUnitContainingDIE(die_offset);
if (cu)
return cu->GetDIEContainingOffset (die_offset);
return DWARFDIE(); // Not found
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Parse // Parse
// //
// Parses the .debug_info section and uses the .debug_abbrev section // Parses the .debug_info section and uses the .debug_abbrev section
// and various other sections in the SymbolFileDWARF class and calls the // and various other sections in the SymbolFileDWARF class and calls the
// supplied callback function each time a compile unit header, or debug // supplied callback function each time a compile unit header, or debug
// information entry is successfully parsed. This function can be used // information entry is successfully parsed. This function can be used
// for different tasks such as parsing the file contents into a // for different tasks such as parsing the file contents into a
▲ Show 20 Lines • Show All 420 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linespublic:
typedef std::vector<DWARFDebugInfoEntry> collection; typedef std::vector<DWARFDebugInfoEntry> collection;
typedef collection::iterator iterator; typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator; typedef collection::const_iterator const_iterator;
typedef std::vector<dw_offset_t> offset_collection; typedef std::vector<dw_offset_t> offset_collection;
typedef offset_collection::iterator offset_collection_iterator; typedef offset_collection::iterator offset_collection_iterator;
typedef offset_collection::const_iterator offset_collection_const_iterator; typedef offset_collection::const_iterator offset_collection_const_iterator;
struct CompareState
{
CompareState() :
die_offset_pairs()
{
assert(sizeof(dw_offset_t)*2 == sizeof(uint64_t));
}
bool AddTypePair(dw_offset_t a, dw_offset_t b)
{
uint64_t a_b_offsets = (uint64_t)a << 32 | (uint64_t)b;
// Return true if this type was inserted, false otherwise
return die_offset_pairs.insert(a_b_offsets).second;
}
std::set< uint64_t > die_offset_pairs;
};
DWARFDebugInfoEntry(): DWARFDebugInfoEntry():
m_offset (DW_INVALID_OFFSET), m_offset (DW_INVALID_OFFSET),
m_parent_idx (0), m_parent_idx (0),
m_sibling_idx (0), m_sibling_idx (0),
m_empty_children(false), m_empty_children(false),
m_abbr_idx (0), m_abbr_idx (0),
m_has_children (false), m_has_children (false),
m_tag (0) m_tag (0)
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines const char * GetQualifiedName (
std::string &storage) const; std::string &storage) const;
const char * GetQualifiedName ( const char * GetQualifiedName (
SymbolFileDWARF* dwarf2Data, SymbolFileDWARF* dwarf2Data,
DWARFCompileUnit* cu, DWARFCompileUnit* cu,
const DWARFAttributes& attributes, const DWARFAttributes& attributes,
std::string &storage) const; std::string &storage) const;
// static int Compare(
// SymbolFileDWARF* dwarf2Data,
// dw_offset_t a_die_offset,
// dw_offset_t b_die_offset,
// CompareState &compare_state,
// bool compare_siblings,
// bool compare_children);
//
// static int Compare(
// SymbolFileDWARF* dwarf2Data,
// DWARFCompileUnit* a_cu, const DWARFDebugInfoEntry* a_die,
// DWARFCompileUnit* b_cu, const DWARFDebugInfoEntry* b_die,
// CompareState &compare_state,
// bool compare_siblings,
// bool compare_children);
static bool OffsetLessThan ( static bool OffsetLessThan (
const DWARFDebugInfoEntry& a, const DWARFDebugInfoEntry& a,
const DWARFDebugInfoEntry& b); const DWARFDebugInfoEntry& b);
void Dump( void Dump(
SymbolFileDWARF* dwarf2Data, SymbolFileDWARF* dwarf2Data,
const DWARFCompileUnit* cu, const DWARFCompileUnit* cu,
lldb_private::Stream &s, lldb_private::Stream &s,
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

//===-- HashedNameToDIE.h ---------------------------------------*- C++ -*-===// //===-- HashedNameToDIE.h ---------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SymbolFileDWARF_HashedNameToDIE_h_ #ifndef SymbolFileDWARF_HashedNameToDIE_h_
#define SymbolFileDWARF_HashedNameToDIE_h_ #define SymbolFileDWARF_HashedNameToDIE_h_
#include <vector> #include <vector>
#include "DWARFDefines.h"
#include "DWARFFormValue.h"
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
#include "lldb/Core/dwarf.h" #include "lldb/Core/dwarf.h"
#include "lldb/Core/RegularExpression.h" #include "lldb/Core/RegularExpression.h"
#include "lldb/Core/MappedHash.h" #include "lldb/Core/MappedHash.h"
struct DWARFMappedHash #include "DWARFDefines.h"
{ #include "DWARFFormValue.h"
struct DIEInfo #include "NameToDIE.h"
{
dw_offset_t offset; // The DIE offset
dw_tag_t tag;
uint32_t type_flags; // Any flags for this DIEInfo
uint32_t qualified_name_hash; // A 32 bit hash of the fully qualified name
DIEInfo () :
offset (DW_INVALID_OFFSET),
tag (0),
type_flags (0),
qualified_name_hash (0)
{
}
DIEInfo (dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h) :
offset(o),
tag (t),
type_flags (f),
qualified_name_hash (h)
{
}
void
Clear()
{
offset = DW_INVALID_OFFSET;
tag = 0;
type_flags = 0;
qualified_name_hash = 0;
}
};
typedef std::vector<DIEInfo> DIEInfoArray;
typedef std::vector<uint32_t> DIEArray;
static void class SymbolFileDWARF;
ExtractDIEArray (const DIEInfoArray &die_info_array, class DWARFCompileUnit;
DIEArray &die_offsets) class DWARFDebugInfoEntry;
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
die_offsets.push_back (die_info_array[i].offset);
}
}
static void class DWARFMappedHash
ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
DIEArray &die_offsets)
{ {
if (tag == 0) public:
{ enum AtomType : uint16_t
ExtractDIEArray (die_info_array, die_offsets);
}
else
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
const dw_tag_t die_tag = die_info_array[i].tag;
bool tag_matches = die_tag == 0 || tag == die_tag;
if (!tag_matches)
{
if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
}
if (tag_matches)
die_offsets.push_back (die_info_array[i].offset);
}
}
}
static void
ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
const uint32_t qualified_name_hash,
DIEArray &die_offsets)
{
if (tag == 0)
{
ExtractDIEArray (die_info_array, die_offsets);
}
else
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
if (qualified_name_hash != die_info_array[i].qualified_name_hash)
continue;
const dw_tag_t die_tag = die_info_array[i].tag;
bool tag_matches = die_tag == 0 || tag == die_tag;
if (!tag_matches)
{
if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
}
if (tag_matches)
die_offsets.push_back (die_info_array[i].offset);
}
}
}
enum AtomType
{ {
eAtomTypeNULL = 0u, eAtomTypeNULL = 0u,
eAtomTypeDIEOffset = 1u, // DIE offset, check form for encoding eAtomTypeDIEOffset = 1u, // DIE offset, check form for encoding
eAtomTypeCUOffset = 2u, // DIE offset of the compiler unit header that contains the item in question eAtomTypeCUOffset = 2u, // DIE offset of the compiler unit header that contains the item in question
eAtomTypeTag = 3u, // DW_TAG_xxx value, should be encoded as DW_FORM_data1 (if no tags exceed 255) or DW_FORM_data2 eAtomTypeTag = 3u, // DW_TAG_xxx value, should be encoded as DW_FORM_data1 (if no tags exceed 255) or DW_FORM_data2
eAtomTypeNameFlags = 4u, // Flags from enum NameFlags eAtomTypeNameFlags = 4u, // Flags from enum NameFlags
eAtomTypeTypeFlags = 5u, // Flags from enum TypeFlags, eAtomTypeTypeFlags = 5u, // Flags from enum TypeFlags,
eAtomTypeQualNameHash = 6u // A 32 bit hash of the full qualified name (since all hash entries are basename only) eAtomTypeQualNameHash = 6u // A 32 bit hash of the full qualified name (since all hash entries are basename only)
// For example a type like "std::vector<int>::iterator" would have a name of "iterator" // For example a type like "std::vector<int>::iterator" would have a name of "iterator"
// and a 32 bit hash for "std::vector<int>::iterator" to allow us to not have to pull // and a 32 bit hash for "std::vector<int>::iterator" to allow us to not have to pull
// in debug info for a type when we know the fully qualified name. // in debug info for a type when we know the fully qualified name.
}; };
// Bit definitions for the eAtomTypeTypeFlags flags // Bit definitions for the eAtomTypeTypeFlags flags
enum TypeFlags enum TypeFlags
{ {
// Always set for C++, only set for ObjC if this is the // Always set for C++, only set for ObjC if this is the
// @implementation for class // @implementation for class
eTypeFlagClassIsImplementation = ( 1u << 1 ) eTypeFlagClassIsImplementation = ( 1u << 1 )
}; };
struct DIEInfo
static void
ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,
bool return_implementation_only_if_available,
DIEArray &die_offsets)
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
const dw_tag_t die_tag = die_info_array[i].tag;
if (die_tag == 0 || die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
{
if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation)
{
if (return_implementation_only_if_available)
{
// We found the one true definition for this class, so
// only return that
die_offsets.clear();
die_offsets.push_back (die_info_array[i].offset);
return;
}
else
{
// Put the one true definition as the first entry so it
// matches first
die_offsets.insert (die_offsets.begin(), die_info_array[i].offset);
}
}
else
{ {
die_offsets.push_back (die_info_array[i].offset); dw_offset_t offset; // The DIE offset
} dw_tag_t tag;
} uint32_t type_flags; // Any flags for this DIEInfo
} uint32_t qualified_name_hash; // A 32 bit hash of the fully qualified name
}
static void DIEInfo ();
ExtractTypesFromDIEArray (const DIEInfoArray &die_info_array, DIEInfo (dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
uint32_t type_flag_mask, };
uint32_t type_flag_value,
DIEArray &die_offsets)
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value)
die_offsets.push_back (die_info_array[i].offset);
}
}
struct Atom struct Atom
{ {
uint16_t type; AtomType type;
dw_form_t form; dw_form_t form;
Atom (uint16_t t = eAtomTypeNULL, dw_form_t f = 0) :
type (t),
form (f)
{
}
}; };
typedef std::vector<DIEInfo> DIEInfoArray;
typedef std::vector<Atom> AtomArray; typedef std::vector<Atom> AtomArray;
static const char * class Prologue
GetAtomTypeName (uint16_t atom)
{
switch (atom)
{
case eAtomTypeNULL: return "NULL";
case eAtomTypeDIEOffset: return "die-offset";
case eAtomTypeCUOffset: return "cu-offset";
case eAtomTypeTag: return "die-tag";
case eAtomTypeNameFlags: return "name-flags";
case eAtomTypeTypeFlags: return "type-flags";
case eAtomTypeQualNameHash: return "qualified-name-hash";
}
return "<invalid>";
}
struct Prologue
{
// DIE offset base so die offsets in hash_data can be CU relative
dw_offset_t die_base_offset;
AtomArray atoms;
uint32_t atom_mask;
size_t min_hash_data_byte_size;
bool hash_data_has_fixed_byte_size;
Prologue (dw_offset_t _die_base_offset = 0) :
die_base_offset (_die_base_offset),
atoms(),
atom_mask (0),
min_hash_data_byte_size(0),
hash_data_has_fixed_byte_size(true)
{ {
// Define an array of DIE offsets by first defining an array, public:
// and then define the atom type for the array, in this case Prologue (dw_offset_t _die_base_offset = 0);
// we have an array of DIE offsets
AppendAtom (eAtomTypeDIEOffset, DW_FORM_data4);
}
virtual ~Prologue()
{
}
void void
ClearAtoms () ClearAtoms ();
{
hash_data_has_fixed_byte_size = true;
min_hash_data_byte_size = 0;
atom_mask = 0;
atoms.clear();
}
bool bool
ContainsAtom (AtomType atom_type) const ContainsAtom (AtomType atom_type) const;
{
return (atom_mask & (1u << atom_type)) != 0;
}
virtual void
Clear ()
{
die_base_offset = 0;
ClearAtoms ();
}
void void
AppendAtom (AtomType type, dw_form_t form) Clear ();
{
atoms.push_back (Atom(type, form));
atom_mask |= 1u << type;
switch (form)
{
case DW_FORM_indirect:
case DW_FORM_exprloc:
case DW_FORM_flag_present:
case DW_FORM_ref_sig8:
assert (!"Unhandled atom form");
break;
case DW_FORM_string:
case DW_FORM_block:
case DW_FORM_block1:
case DW_FORM_sdata:
case DW_FORM_udata:
case DW_FORM_ref_udata:
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
hash_data_has_fixed_byte_size = false;
// Fall through to the cases below...
case DW_FORM_flag:
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_sec_offset:
min_hash_data_byte_size += 1;
break;
case DW_FORM_block2:
hash_data_has_fixed_byte_size = false;
// Fall through to the cases below...
case DW_FORM_data2:
case DW_FORM_ref2:
min_hash_data_byte_size += 2;
break;
case DW_FORM_block4:
hash_data_has_fixed_byte_size = false;
// Fall through to the cases below...
case DW_FORM_data4:
case DW_FORM_ref4:
case DW_FORM_addr:
case DW_FORM_ref_addr:
case DW_FORM_strp:
min_hash_data_byte_size += 4;
break;
case DW_FORM_data8:
case DW_FORM_ref8:
min_hash_data_byte_size += 8;
break;
} void
} AppendAtom (AtomType type, dw_form_t form);
// void
// Dump (std::ostream* ostrm_ptr);
lldb::offset_t lldb::offset_t
Read (const lldb_private::DataExtractor &data, Read (const lldb_private::DataExtractor &data, lldb::offset_t offset);
lldb::offset_t offset)
{
ClearAtoms ();
die_base_offset = data.GetU32 (&offset);
const uint32_t atom_count = data.GetU32 (&offset);
if (atom_count == 0x00060003u)
{
// Old format, deal with contents of old pre-release format
while (data.GetU32(&offset))
/* do nothing */;
// Hardcode to the only known value for now.
AppendAtom (eAtomTypeDIEOffset, DW_FORM_data4);
}
else
{
for (uint32_t i=0; i<atom_count; ++i)
{
AtomType type = (AtomType)data.GetU16 (&offset);
dw_form_t form = (dw_form_t)data.GetU16 (&offset);
AppendAtom (type, form);
}
}
return offset;
}
// virtual void
// Write (BinaryStreamBuf &s);
size_t size_t
GetByteSize () const GetByteSize () const;
{
// Add an extra count to the atoms size for the zero termination Atom that gets
// written to disk
return sizeof(die_base_offset) + sizeof(uint32_t) + atoms.size() * sizeof(Atom);
}
size_t size_t
GetMinimumHashDataByteSize () const GetMinimumHashDataByteSize () const;
{
return min_hash_data_byte_size;
}
bool bool
HashDataHasFixedByteSize() const HashDataHasFixedByteSize() const;
{
return hash_data_has_fixed_byte_size;
}
};
struct Header : public MappedHash::Header<Prologue> // DIE offset base so die offsets in hash_data can be CU relative
{ dw_offset_t die_base_offset;
Header (dw_offset_t _die_base_offset = 0) AtomArray atoms;
{ uint32_t atom_mask;
} size_t min_hash_data_byte_size;
bool hash_data_has_fixed_byte_size;
virtual };
~Header()
{
}
virtual size_t class Header : public MappedHash::Header<Prologue>
GetByteSize (const HeaderData &header_data)
{ {
return header_data.GetByteSize(); public:
} size_t
GetByteSize (const HeaderData &header_data) override;
// virtual void lldb::offset_t
// Dump (std::ostream* ostrm_ptr); Read (lldb_private::DataExtractor &data, lldb::offset_t offset) override;
//
virtual lldb::offset_t
Read (lldb_private::DataExtractor &data, lldb::offset_t offset)
{
offset = MappedHash::Header<Prologue>::Read (data, offset);
if (offset != UINT32_MAX)
{
offset = header_data.Read (data, offset);
}
return offset;
}
bool bool
Read (const lldb_private::DWARFDataExtractor &data, Read (const lldb_private::DWARFDataExtractor &data,
lldb::offset_t *offset_ptr, lldb::offset_t *offset_ptr,
DIEInfo &hash_data) const DIEInfo &hash_data) const;
{
const size_t num_atoms = header_data.atoms.size();
if (num_atoms == 0)
return false;
for (size_t i=0; i<num_atoms; ++i)
{
DWARFFormValue form_value (NULL, header_data.atoms[i].form);
if (!form_value.ExtractValue(data, offset_ptr))
return false;
switch (header_data.atoms[i].type)
{
case eAtomTypeDIEOffset: // DIE offset, check form for encoding
hash_data.offset = (dw_offset_t)form_value.Reference (header_data.die_base_offset);
break;
case eAtomTypeTag: // DW_TAG value for the DIE
hash_data.tag = (dw_tag_t)form_value.Unsigned ();
case eAtomTypeTypeFlags: // Flags from enum TypeFlags
hash_data.type_flags = (uint32_t)form_value.Unsigned ();
break;
case eAtomTypeQualNameHash: // Flags from enum TypeFlags
hash_data.qualified_name_hash = form_value.Unsigned ();
break;
default:
// We can always skip atoms we don't know about
break;
}
}
return true;
}
void void
Dump (lldb_private::Stream& strm, const DIEInfo &hash_data) const Dump (lldb_private::Stream& strm, const DIEInfo &hash_data) const;
{
const size_t num_atoms = header_data.atoms.size();
for (size_t i=0; i<num_atoms; ++i)
{
if (i > 0)
strm.PutCString (", ");
DWARFFormValue form_value (NULL, header_data.atoms[i].form);
switch (header_data.atoms[i].type)
{
case eAtomTypeDIEOffset: // DIE offset, check form for encoding
strm.Printf ("{0x%8.8x}", hash_data.offset);
break;
case eAtomTypeTag: // DW_TAG value for the DIE
{
const char *tag_cstr = lldb_private::DW_TAG_value_to_name (hash_data.tag);
if (tag_cstr)
strm.PutCString (tag_cstr);
else
strm.Printf ("DW_TAG_(0x%4.4x)", hash_data.tag);
}
break;
case eAtomTypeTypeFlags: // Flags from enum TypeFlags
strm.Printf ("0x%2.2x", hash_data.type_flags);
if (hash_data.type_flags)
{
strm.PutCString (" (");
if (hash_data.type_flags & eTypeFlagClassIsImplementation)
strm.PutCString (" implementation");
strm.PutCString (" )");
}
break;
case eAtomTypeQualNameHash: // Flags from enum TypeFlags
strm.Printf ("0x%8.8x", hash_data.qualified_name_hash);
break;
default:
strm.Printf ("AtomType(0x%x)", header_data.atoms[i].type);
break;
}
}
}
}; };
// A class for reading and using a saved hash table from a block of data // A class for reading and using a saved hash table from a block of data
// in memory // in memory
class MemoryTable : public MappedHash::MemoryTable<uint32_t, DWARFMappedHash::Header, DIEInfoArray> class MemoryTable : public MappedHash::MemoryTable<uint32_t, DWARFMappedHash::Header, DIEInfoArray>
{ {
public: public:
MemoryTable (lldb_private::DWARFDataExtractor &table_data, MemoryTable (lldb_private::DWARFDataExtractor &table_data,
const lldb_private::DWARFDataExtractor &string_table, const lldb_private::DWARFDataExtractor &string_table,
const char *name) : const char *name);
MappedHash::MemoryTable<uint32_t, Header, DIEInfoArray> (table_data),
m_data (table_data),
m_string_table (string_table),
m_name (name)
{
}
virtual
~MemoryTable ()
{
}
virtual const char *
GetStringForKeyType (KeyType key) const
{
// The key in the DWARF table is the .debug_str offset for the string
return m_string_table.PeekCStr (key);
}
virtual bool
ReadHashData (uint32_t hash_data_offset,
HashData &hash_data) const
{
lldb::offset_t offset = hash_data_offset;
offset += 4; // Skip string table offset that contains offset of hash name in .debug_str
const uint32_t count = m_data.GetU32 (&offset);
if (count > 0)
{
hash_data.resize(count);
for (uint32_t i=0; i<count; ++i)
{
if (!m_header.Read(m_data, &offset, hash_data[i]))
return false;
}
}
else
hash_data.clear();
return true;
}
virtual Result
GetHashDataForName (const char *name,
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const
{
pair.key = m_data.GetU32 (hash_data_offset_ptr);
pair.value.clear();
// If the key is zero, this terminates our chain of HashData objects
// for this hash value.
if (pair.key == 0)
return eResultEndOfHashData;
// There definitely should be a string for this string offset, if
// there isn't, there is something wrong, return and error
const char *strp_cstr = m_string_table.PeekCStr (pair.key);
if (strp_cstr == NULL)
{
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
const uint32_t count = m_data.GetU32 (hash_data_offset_ptr);
const size_t min_total_hash_data_size = count * m_header.header_data.GetMinimumHashDataByteSize();
if (count > 0 && m_data.ValidOffsetForDataOfSize (*hash_data_offset_ptr, min_total_hash_data_size))
{
// We have at least one HashData entry, and we have enough
// data to parse at least "count" HashData entries.
// First make sure the entire C string matches...
const bool match = strcmp (name, strp_cstr) == 0;
if (!match && m_header.header_data.HashDataHasFixedByteSize())
{
// If the string doesn't match and we have fixed size data,
// we can just add the total byte size of all HashData objects
// to the hash data offset and be done...
*hash_data_offset_ptr += min_total_hash_data_size;
}
else
{
// If the string does match, or we don't have fixed size data
// then we need to read the hash data as a stream. If the
// string matches we also append all HashData objects to the
// value array.
for (uint32_t i=0; i<count; ++i)
{
DIEInfo die_info;
if (m_header.Read(m_data, hash_data_offset_ptr, die_info))
{
// Only happened if the HashData of the string matched...
if (match)
pair.value.push_back (die_info);
}
else
{
// Something went wrong while reading the data
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
}
// Return the correct response depending on if the string matched
// or not...
if (match)
return eResultKeyMatch; // The key (cstring) matches and we have lookup results!
else
return eResultKeyMismatch; // The key doesn't match, this function will get called
// again for the next key/value or the key terminator
// which in our case is a zero .debug_str offset.
}
else
{
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
virtual Result const char *
AppendHashDataForRegularExpression (const lldb_private::RegularExpression& regex, GetStringForKeyType (KeyType key) const override;
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const
{
pair.key = m_data.GetU32 (hash_data_offset_ptr);
// If the key is zero, this terminates our chain of HashData objects
// for this hash value.
if (pair.key == 0)
return eResultEndOfHashData;
// There definitely should be a string for this string offset, if
// there isn't, there is something wrong, return and error
const char *strp_cstr = m_string_table.PeekCStr (pair.key);
if (strp_cstr == NULL)
return eResultError;
const uint32_t count = m_data.GetU32 (hash_data_offset_ptr);
const size_t min_total_hash_data_size = count * m_header.header_data.GetMinimumHashDataByteSize();
if (count > 0 && m_data.ValidOffsetForDataOfSize (*hash_data_offset_ptr, min_total_hash_data_size))
{
const bool match = regex.Execute(strp_cstr);
if (!match && m_header.header_data.HashDataHasFixedByteSize()) bool
{ ReadHashData (uint32_t hash_data_offset, HashData &hash_data) const override;
// If the regex doesn't match and we have fixed size data,
// we can just add the total byte size of all HashData objects
// to the hash data offset and be done...
*hash_data_offset_ptr += min_total_hash_data_size;
}
else
{
// If the string does match, or we don't have fixed size data
// then we need to read the hash data as a stream. If the
// string matches we also append all HashData objects to the
// value array.
for (uint32_t i=0; i<count; ++i)
{
DIEInfo die_info;
if (m_header.Read(m_data, hash_data_offset_ptr, die_info))
{
// Only happened if the HashData of the string matched...
if (match)
pair.value.push_back (die_info);
}
else
{
// Something went wrong while reading the data
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
}
// Return the correct response depending on if the string matched
// or not...
if (match)
return eResultKeyMatch; // The key (cstring) matches and we have lookup results!
else
return eResultKeyMismatch; // The key doesn't match, this function will get called
// again for the next key/value or the key terminator
// which in our case is a zero .debug_str offset.
}
else
{
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
size_t size_t
AppendAllDIEsThatMatchingRegex (const lldb_private::RegularExpression& regex, AppendAllDIEsThatMatchingRegex (const lldb_private::RegularExpression& regex,
DIEInfoArray &die_info_array) const DIEInfoArray &die_info_array) const;
{
const uint32_t hash_count = m_header.hashes_count;
Pair pair;
for (uint32_t offset_idx=0; offset_idx<hash_count; ++offset_idx)
{
lldb::offset_t hash_data_offset = GetHashDataOffset (offset_idx);
while (hash_data_offset != UINT32_MAX)
{
const lldb::offset_t prev_hash_data_offset = hash_data_offset;
Result hash_result = AppendHashDataForRegularExpression (regex, &hash_data_offset, pair);
if (prev_hash_data_offset == hash_data_offset)
break;
// Check the result of getting our hash data
switch (hash_result)
{
case eResultKeyMatch:
case eResultKeyMismatch:
// Whether we matches or not, it doesn't matter, we
// keep looking.
break;
case eResultEndOfHashData:
case eResultError:
hash_data_offset = UINT32_MAX;
break;
}
}
}
die_info_array.swap (pair.value);
return die_info_array.size();
}
size_t size_t
AppendAllDIEsInRange (const uint32_t die_offset_start, AppendAllDIEsInRange (const uint32_t die_offset_start,
const uint32_t die_offset_end, const uint32_t die_offset_end,
DIEInfoArray &die_info_array) const DIEInfoArray &die_info_array) const;
{
const uint32_t hash_count = m_header.hashes_count;
for (uint32_t offset_idx=0; offset_idx<hash_count; ++offset_idx)
{
bool done = false;
lldb::offset_t hash_data_offset = GetHashDataOffset (offset_idx);
while (!done && hash_data_offset != UINT32_MAX)
{
KeyType key = m_data.GetU32 (&hash_data_offset);
// If the key is zero, this terminates our chain of HashData objects
// for this hash value.
if (key == 0)
break;
const uint32_t count = m_data.GetU32 (&hash_data_offset);
for (uint32_t i=0; i<count; ++i)
{
DIEInfo die_info;
if (m_header.Read(m_data, &hash_data_offset, die_info))
{
if (die_info.offset == 0)
done = true;
if (die_offset_start <= die_info.offset && die_info.offset < die_offset_end)
die_info_array.push_back(die_info);
}
}
}
}
return die_info_array.size();
}
size_t size_t
FindByName (const char *name, DIEArray &die_offsets) FindByName (const char *name, DIEArray &die_offsets);
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
DWARFMappedHash::ExtractDIEArray (die_info_array, die_offsets);
return die_info_array.size();
}
size_t size_t
FindByNameAndTag (const char *name, FindByNameAndTag (const char *name, const dw_tag_t tag, DIEArray &die_offsets);
const dw_tag_t tag,
DIEArray &die_offsets)
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
DWARFMappedHash::ExtractDIEArray (die_info_array, tag, die_offsets);
return die_info_array.size();
}
size_t size_t
FindByNameAndTagAndQualifiedNameHash (const char *name, FindByNameAndTagAndQualifiedNameHash (const char *name,
const dw_tag_t tag, const dw_tag_t tag,
const uint32_t qualified_name_hash, const uint32_t qualified_name_hash,
DIEArray &die_offsets) DIEArray &die_offsets);
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
DWARFMappedHash::ExtractDIEArray (die_info_array, tag, qualified_name_hash, die_offsets);
return die_info_array.size();
}
size_t size_t
FindCompleteObjCClassByName (const char *name, DIEArray &die_offsets, bool must_be_implementation) FindCompleteObjCClassByName (const char *name,
{ DIEArray &die_offsets,
DIEInfoArray die_info_array; bool must_be_implementation);
if (FindByName(name, die_info_array))
{ protected:
if (must_be_implementation && GetHeader().header_data.ContainsAtom (eAtomTypeTypeFlags)) Result
{ AppendHashDataForRegularExpression (const lldb_private::RegularExpression& regex,
// If we have two atoms, then we have the DIE offset and lldb::offset_t* hash_data_offset_ptr,
// the type flags so we can find the objective C class Pair &pair) const;
// efficiently.
DWARFMappedHash::ExtractTypesFromDIEArray (die_info_array,
UINT32_MAX,
eTypeFlagClassIsImplementation,
die_offsets);
}
else
{
// We don't only want the one true definition, so try and see
// what we can find, and only return class or struct DIEs.
// If we do have the full implementation, then return it alone,
// else return all possible matches.
const bool return_implementation_only_if_available = true;
DWARFMappedHash::ExtractClassOrStructDIEArray (die_info_array,
return_implementation_only_if_available,
die_offsets);
}
}
return die_offsets.size();
}
size_t size_t
FindByName (const char *name, DIEInfoArray &die_info_array) FindByName (const char *name, DIEInfoArray &die_info_array);
{
Pair kv_pair; Result
size_t old_size = die_info_array.size(); GetHashDataForName (const char *name,
if (Find (name, kv_pair)) lldb::offset_t* hash_data_offset_ptr,
{ Pair &pair) const;
die_info_array.swap(kv_pair.value);
return die_info_array.size() - old_size;
}
return 0;
}
protected:
const lldb_private::DWARFDataExtractor &m_data; const lldb_private::DWARFDataExtractor &m_data;
const lldb_private::DWARFDataExtractor &m_string_table; const lldb_private::DWARFDataExtractor &m_string_table;
std::string m_name; std::string m_name;
}; };
static void
ExtractDIEArray (const DIEInfoArray &die_info_array, DIEArray &die_offsets);
protected:
static void
ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
DIEArray &die_offsets);
static void
ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
const uint32_t qualified_name_hash,
DIEArray &die_offsets);
static void
ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,
bool return_implementation_only_if_available,
DIEArray &die_offsets);
static void
ExtractTypesFromDIEArray (const DIEInfoArray &die_info_array,
uint32_t type_flag_mask,
uint32_t type_flag_value,
DIEArray &die_offsets);
static const char *
GetAtomTypeName (uint16_t atom);
}; };
#endif // SymbolFileDWARF_HashedNameToDIE_h_ #endif // SymbolFileDWARF_HashedNameToDIE_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

//===-- HashedNameToDIE.cpp -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "HashedNameToDIE.h"
void
DWARFMappedHash::ExtractDIEArray (const DIEInfoArray &die_info_array, DIEArray &die_offsets)
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
die_offsets.push_back (die_info_array[i].offset);
}
void
DWARFMappedHash::ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
DIEArray &die_offsets)
{
if (tag == 0)
{
ExtractDIEArray (die_info_array, die_offsets);
}
else
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
const dw_tag_t die_tag = die_info_array[i].tag;
bool tag_matches = die_tag == 0 || tag == die_tag;
if (!tag_matches)
{
if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
}
if (tag_matches)
die_offsets.push_back (die_info_array[i].offset);
}
}
}
void
DWARFMappedHash::ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
const uint32_t qualified_name_hash,
DIEArray &die_offsets)
{
if (tag == 0)
{
ExtractDIEArray (die_info_array, die_offsets);
}
else
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
if (qualified_name_hash != die_info_array[i].qualified_name_hash)
continue;
const dw_tag_t die_tag = die_info_array[i].tag;
bool tag_matches = die_tag == 0 || tag == die_tag;
if (!tag_matches)
{
if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
}
if (tag_matches)
die_offsets.push_back (die_info_array[i].offset);
}
}
}
void
DWARFMappedHash::ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,
bool return_implementation_only_if_available,
DIEArray &die_offsets)
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
const dw_tag_t die_tag = die_info_array[i].tag;
if (die_tag == 0 || die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
{
if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation)
{
if (return_implementation_only_if_available)
{
// We found the one true definition for this class, so
// only return that
die_offsets.clear();
die_offsets.push_back (die_info_array[i].offset);
return;
}
else
{
// Put the one true definition as the first entry so it
// matches first
die_offsets.insert (die_offsets.begin(), die_info_array[i].offset);
}
}
else
{
die_offsets.push_back (die_info_array[i].offset);
}
}
}
}
void
DWARFMappedHash::ExtractTypesFromDIEArray (const DIEInfoArray &die_info_array,
uint32_t type_flag_mask,
uint32_t type_flag_value,
DIEArray &die_offsets)
{
const size_t count = die_info_array.size();
for (size_t i=0; i<count; ++i)
{
if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value)
die_offsets.push_back (die_info_array[i].offset);
}
}
const char *
DWARFMappedHash::GetAtomTypeName (uint16_t atom)
{
switch (atom)
{
case eAtomTypeNULL: return "NULL";
case eAtomTypeDIEOffset: return "die-offset";
case eAtomTypeCUOffset: return "cu-offset";
case eAtomTypeTag: return "die-tag";
case eAtomTypeNameFlags: return "name-flags";
case eAtomTypeTypeFlags: return "type-flags";
case eAtomTypeQualNameHash: return "qualified-name-hash";
}
return "<invalid>";
}
DWARFMappedHash::DIEInfo::DIEInfo () :
offset (DW_INVALID_OFFSET),
tag (0),
type_flags (0),
qualified_name_hash (0)
{
}
DWARFMappedHash::DIEInfo::DIEInfo (dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h) :
offset (o),
tag (t),
type_flags (f),
qualified_name_hash (h)
{
}
DWARFMappedHash::Prologue::Prologue (dw_offset_t _die_base_offset) :
die_base_offset (_die_base_offset),
atoms(),
atom_mask (0),
min_hash_data_byte_size(0),
hash_data_has_fixed_byte_size(true)
{
// Define an array of DIE offsets by first defining an array,
// and then define the atom type for the array, in this case
// we have an array of DIE offsets
AppendAtom (eAtomTypeDIEOffset, DW_FORM_data4);
}
void
DWARFMappedHash::Prologue::ClearAtoms ()
{
hash_data_has_fixed_byte_size = true;
min_hash_data_byte_size = 0;
atom_mask = 0;
atoms.clear();
}
bool
DWARFMappedHash::Prologue::ContainsAtom (AtomType atom_type) const
{
return (atom_mask & (1u << atom_type)) != 0;
}
void
DWARFMappedHash::Prologue::Clear ()
{
die_base_offset = 0;
ClearAtoms ();
}
void
DWARFMappedHash::Prologue::AppendAtom (AtomType type, dw_form_t form)
{
atoms.push_back ({type, form});
atom_mask |= 1u << type;
switch (form)
{
case DW_FORM_indirect:
case DW_FORM_exprloc:
case DW_FORM_flag_present:
case DW_FORM_ref_sig8:
assert (!"Unhandled atom form");
break;
case DW_FORM_string:
case DW_FORM_block:
case DW_FORM_block1:
case DW_FORM_sdata:
case DW_FORM_udata:
case DW_FORM_ref_udata:
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
hash_data_has_fixed_byte_size = false;
// Fall through to the cases below...
case DW_FORM_flag:
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_sec_offset:
min_hash_data_byte_size += 1;
break;
case DW_FORM_block2:
hash_data_has_fixed_byte_size = false;
// Fall through to the cases below...
case DW_FORM_data2:
case DW_FORM_ref2:
min_hash_data_byte_size += 2;
break;
case DW_FORM_block4:
hash_data_has_fixed_byte_size = false;
// Fall through to the cases below...
case DW_FORM_data4:
case DW_FORM_ref4:
case DW_FORM_addr:
case DW_FORM_ref_addr:
case DW_FORM_strp:
min_hash_data_byte_size += 4;
break;
case DW_FORM_data8:
case DW_FORM_ref8:
min_hash_data_byte_size += 8;
break;
}
}
lldb::offset_t
DWARFMappedHash::Prologue::Read (const lldb_private::DataExtractor &data,
lldb::offset_t offset)
{
ClearAtoms ();
die_base_offset = data.GetU32 (&offset);
const uint32_t atom_count = data.GetU32 (&offset);
if (atom_count == 0x00060003u)
{
// Old format, deal with contents of old pre-release format
while (data.GetU32(&offset))
/* do nothing */;
// Hardcode to the only known value for now.
AppendAtom (eAtomTypeDIEOffset, DW_FORM_data4);
}
else
{
for (uint32_t i=0; i<atom_count; ++i)
{
AtomType type = (AtomType)data.GetU16 (&offset);
dw_form_t form = (dw_form_t)data.GetU16 (&offset);
AppendAtom (type, form);
}
}
return offset;
}
size_t
DWARFMappedHash::Prologue::GetByteSize () const
{
// Add an extra count to the atoms size for the zero termination Atom that gets
// written to disk
return sizeof(die_base_offset) + sizeof(uint32_t) + atoms.size() * sizeof(Atom);
}
size_t
DWARFMappedHash::Prologue::GetMinimumHashDataByteSize () const
{
return min_hash_data_byte_size;
}
bool
DWARFMappedHash::Prologue::HashDataHasFixedByteSize() const
{
return hash_data_has_fixed_byte_size;
}
size_t
DWARFMappedHash::Header::GetByteSize (const HeaderData &header_data)
{
return header_data.GetByteSize();
}
lldb::offset_t
DWARFMappedHash::Header::Read (lldb_private::DataExtractor &data, lldb::offset_t offset)
{
offset = MappedHash::Header<Prologue>::Read (data, offset);
if (offset != UINT32_MAX)
{
offset = header_data.Read (data, offset);
}
return offset;
}
bool
DWARFMappedHash::Header::Read (const lldb_private::DWARFDataExtractor &data,
lldb::offset_t *offset_ptr,
DIEInfo &hash_data) const
{
const size_t num_atoms = header_data.atoms.size();
if (num_atoms == 0)
return false;
for (size_t i=0; i<num_atoms; ++i)
{
DWARFFormValue form_value (NULL, header_data.atoms[i].form);
if (!form_value.ExtractValue(data, offset_ptr))
return false;
switch (header_data.atoms[i].type)
{
case eAtomTypeDIEOffset: // DIE offset, check form for encoding
hash_data.offset = (dw_offset_t)form_value.Reference (header_data.die_base_offset);
break;
case eAtomTypeTag: // DW_TAG value for the DIE
hash_data.tag = (dw_tag_t)form_value.Unsigned ();
case eAtomTypeTypeFlags: // Flags from enum TypeFlags
hash_data.type_flags = (uint32_t)form_value.Unsigned ();
break;
case eAtomTypeQualNameHash: // Flags from enum TypeFlags
hash_data.qualified_name_hash = form_value.Unsigned ();
break;
default:
// We can always skip atoms we don't know about
break;
}
}
return true;
}
void
DWARFMappedHash::Header::Dump (lldb_private::Stream& strm, const DIEInfo &hash_data) const
{
const size_t num_atoms = header_data.atoms.size();
for (size_t i=0; i<num_atoms; ++i)
{
if (i > 0)
strm.PutCString (", ");
DWARFFormValue form_value (NULL, header_data.atoms[i].form);
switch (header_data.atoms[i].type)
{
case eAtomTypeDIEOffset: // DIE offset, check form for encoding
strm.Printf ("{0x%8.8x}", hash_data.offset);
break;
case eAtomTypeTag: // DW_TAG value for the DIE
{
const char *tag_cstr = lldb_private::DW_TAG_value_to_name (hash_data.tag);
if (tag_cstr)
strm.PutCString (tag_cstr);
else
strm.Printf ("DW_TAG_(0x%4.4x)", hash_data.tag);
}
break;
case eAtomTypeTypeFlags: // Flags from enum TypeFlags
strm.Printf ("0x%2.2x", hash_data.type_flags);
if (hash_data.type_flags)
{
strm.PutCString (" (");
if (hash_data.type_flags & eTypeFlagClassIsImplementation)
strm.PutCString (" implementation");
strm.PutCString (" )");
}
break;
case eAtomTypeQualNameHash: // Flags from enum TypeFlags
strm.Printf ("0x%8.8x", hash_data.qualified_name_hash);
break;
default:
strm.Printf ("AtomType(0x%x)", header_data.atoms[i].type);
break;
}
}
}
DWARFMappedHash::MemoryTable::MemoryTable (lldb_private::DWARFDataExtractor &table_data,
const lldb_private::DWARFDataExtractor &string_table,
const char *name) :
MappedHash::MemoryTable<uint32_t, Header, DIEInfoArray> (table_data),
m_data (table_data),
m_string_table (string_table),
m_name (name)
{
}
const char *
DWARFMappedHash::MemoryTable::GetStringForKeyType (KeyType key) const
{
// The key in the DWARF table is the .debug_str offset for the string
return m_string_table.PeekCStr (key);
}
bool
DWARFMappedHash::MemoryTable::ReadHashData (uint32_t hash_data_offset, HashData &hash_data) const
{
lldb::offset_t offset = hash_data_offset;
offset += 4; // Skip string table offset that contains offset of hash name in .debug_str
const uint32_t count = m_data.GetU32 (&offset);
if (count > 0)
{
hash_data.resize(count);
for (uint32_t i=0; i<count; ++i)
{
if (!m_header.Read(m_data, &offset, hash_data[i]))
return false;
}
}
else
hash_data.clear();
return true;
}
DWARFMappedHash::MemoryTable::Result
DWARFMappedHash::MemoryTable::GetHashDataForName (const char *name,
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const
{
pair.key = m_data.GetU32 (hash_data_offset_ptr);
pair.value.clear();
// If the key is zero, this terminates our chain of HashData objects
// for this hash value.
if (pair.key == 0)
return eResultEndOfHashData;
// There definitely should be a string for this string offset, if
// there isn't, there is something wrong, return and error
const char *strp_cstr = m_string_table.PeekCStr (pair.key);
if (strp_cstr == NULL)
{
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
const uint32_t count = m_data.GetU32 (hash_data_offset_ptr);
const size_t min_total_hash_data_size = count * m_header.header_data.GetMinimumHashDataByteSize();
if (count > 0 && m_data.ValidOffsetForDataOfSize (*hash_data_offset_ptr, min_total_hash_data_size))
{
// We have at least one HashData entry, and we have enough
// data to parse at least "count" HashData entries.
// First make sure the entire C string matches...
const bool match = strcmp (name, strp_cstr) == 0;
if (!match && m_header.header_data.HashDataHasFixedByteSize())
{
// If the string doesn't match and we have fixed size data,
// we can just add the total byte size of all HashData objects
// to the hash data offset and be done...
*hash_data_offset_ptr += min_total_hash_data_size;
}
else
{
// If the string does match, or we don't have fixed size data
// then we need to read the hash data as a stream. If the
// string matches we also append all HashData objects to the
// value array.
for (uint32_t i=0; i<count; ++i)
{
DIEInfo die_info;
if (m_header.Read(m_data, hash_data_offset_ptr, die_info))
{
// Only happened if the HashData of the string matched...
if (match)
pair.value.push_back (die_info);
}
else
{
// Something went wrong while reading the data
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
}
// Return the correct response depending on if the string matched
// or not...
if (match)
return eResultKeyMatch; // The key (cstring) matches and we have lookup results!
else
return eResultKeyMismatch; // The key doesn't match, this function will get called
// again for the next key/value or the key terminator
// which in our case is a zero .debug_str offset.
}
else
{
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
DWARFMappedHash::MemoryTable::Result
DWARFMappedHash::MemoryTable::AppendHashDataForRegularExpression (
const lldb_private::RegularExpression& regex,
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const
{
pair.key = m_data.GetU32 (hash_data_offset_ptr);
// If the key is zero, this terminates our chain of HashData objects
// for this hash value.
if (pair.key == 0)
return eResultEndOfHashData;
// There definitely should be a string for this string offset, if
// there isn't, there is something wrong, return and error
const char *strp_cstr = m_string_table.PeekCStr (pair.key);
if (strp_cstr == NULL)
return eResultError;
const uint32_t count = m_data.GetU32 (hash_data_offset_ptr);
const size_t min_total_hash_data_size = count * m_header.header_data.GetMinimumHashDataByteSize();
if (count > 0 && m_data.ValidOffsetForDataOfSize (*hash_data_offset_ptr, min_total_hash_data_size))
{
const bool match = regex.Execute(strp_cstr);
if (!match && m_header.header_data.HashDataHasFixedByteSize())
{
// If the regex doesn't match and we have fixed size data,
// we can just add the total byte size of all HashData objects
// to the hash data offset and be done...
*hash_data_offset_ptr += min_total_hash_data_size;
}
else
{
// If the string does match, or we don't have fixed size data
// then we need to read the hash data as a stream. If the
// string matches we also append all HashData objects to the
// value array.
for (uint32_t i=0; i<count; ++i)
{
DIEInfo die_info;
if (m_header.Read(m_data, hash_data_offset_ptr, die_info))
{
// Only happened if the HashData of the string matched...
if (match)
pair.value.push_back (die_info);
}
else
{
// Something went wrong while reading the data
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
}
// Return the correct response depending on if the string matched
// or not...
if (match)
return eResultKeyMatch; // The key (cstring) matches and we have lookup results!
else
return eResultKeyMismatch; // The key doesn't match, this function will get called
// again for the next key/value or the key terminator
// which in our case is a zero .debug_str offset.
}
else
{
*hash_data_offset_ptr = UINT32_MAX;
return eResultError;
}
}
size_t
DWARFMappedHash::MemoryTable::AppendAllDIEsThatMatchingRegex (
const lldb_private::RegularExpression& regex,
DIEInfoArray &die_info_array) const
{
const uint32_t hash_count = m_header.hashes_count;
Pair pair;
for (uint32_t offset_idx=0; offset_idx<hash_count; ++offset_idx)
{
lldb::offset_t hash_data_offset = GetHashDataOffset (offset_idx);
while (hash_data_offset != UINT32_MAX)
{
const lldb::offset_t prev_hash_data_offset = hash_data_offset;
Result hash_result = AppendHashDataForRegularExpression (regex, &hash_data_offset, pair);
if (prev_hash_data_offset == hash_data_offset)
break;
// Check the result of getting our hash data
switch (hash_result)
{
case eResultKeyMatch:
case eResultKeyMismatch:
// Whether we matches or not, it doesn't matter, we
// keep looking.
break;
case eResultEndOfHashData:
case eResultError:
hash_data_offset = UINT32_MAX;
break;
}
}
}
die_info_array.swap (pair.value);
return die_info_array.size();
}
size_t
DWARFMappedHash::MemoryTable::AppendAllDIEsInRange (const uint32_t die_offset_start,
const uint32_t die_offset_end,
DIEInfoArray &die_info_array) const
{
const uint32_t hash_count = m_header.hashes_count;
for (uint32_t offset_idx=0; offset_idx<hash_count; ++offset_idx)
{
bool done = false;
lldb::offset_t hash_data_offset = GetHashDataOffset (offset_idx);
while (!done && hash_data_offset != UINT32_MAX)
{
KeyType key = m_data.GetU32 (&hash_data_offset);
// If the key is zero, this terminates our chain of HashData objects
// for this hash value.
if (key == 0)
break;
const uint32_t count = m_data.GetU32 (&hash_data_offset);
for (uint32_t i=0; i<count; ++i)
{
DIEInfo die_info;
if (m_header.Read(m_data, &hash_data_offset, die_info))
{
if (die_info.offset == 0)
done = true;
if (die_offset_start <= die_info.offset && die_info.offset < die_offset_end)
die_info_array.push_back(die_info);
}
}
}
}
return die_info_array.size();
}
size_t
DWARFMappedHash::MemoryTable::FindByName (const char *name, DIEArray &die_offsets)
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
DWARFMappedHash::ExtractDIEArray (die_info_array, die_offsets);
return die_info_array.size();
}
size_t
DWARFMappedHash::MemoryTable::FindByNameAndTag (const char *name,
const dw_tag_t tag,
DIEArray &die_offsets)
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
DWARFMappedHash::ExtractDIEArray (die_info_array, tag, die_offsets);
return die_info_array.size();
}
size_t
DWARFMappedHash::MemoryTable::FindByNameAndTagAndQualifiedNameHash (const char *name,
const dw_tag_t tag,
const uint32_t qualified_name_hash,
DIEArray &die_offsets)
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
DWARFMappedHash::ExtractDIEArray (die_info_array, tag, qualified_name_hash, die_offsets);
return die_info_array.size();
}
size_t
DWARFMappedHash::MemoryTable::FindCompleteObjCClassByName (const char *name,
DIEArray &die_offsets,
bool must_be_implementation)
{
DIEInfoArray die_info_array;
if (FindByName(name, die_info_array))
{
if (must_be_implementation && GetHeader().header_data.ContainsAtom (eAtomTypeTypeFlags))
{
// If we have two atoms, then we have the DIE offset and
// the type flags so we can find the objective C class
// efficiently.
DWARFMappedHash::ExtractTypesFromDIEArray (die_info_array,
UINT32_MAX,
eTypeFlagClassIsImplementation,
die_offsets);
}
else
{
// We don't only want the one true definition, so try and see
// what we can find, and only return class or struct DIEs.
// If we do have the full implementation, then return it alone,
// else return all possible matches.
const bool return_implementation_only_if_available = true;
DWARFMappedHash::ExtractClassOrStructDIEArray (die_info_array,
return_implementation_only_if_available,
die_offsets);
}
}
return die_offsets.size();
}
size_t
DWARFMappedHash::MemoryTable::FindByName (const char *name, DIEInfoArray &die_info_array)
{
Pair kv_pair;
size_t old_size = die_info_array.size();
if (Find (name, kv_pair))
{
die_info_array.swap(kv_pair.value);
return die_info_array.size() - old_size;
}
return 0;
}

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Show First 20 Lines • Show All 1,520 Lines • ▼ Show 20 LinesSymbolFileDWARF::CompleteType (CompilerType &clang_type)
Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION)); Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
if (log) if (log)
GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log, GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log,
"0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
dwarf_die.GetID(), dwarf_die.GetID(),
dwarf_die.GetTagAsCString(), dwarf_die.GetTagAsCString(),
type->GetName().AsCString()); type->GetName().AsCString());
assert (clang_type); assert (clang_type);
DWARFAttributes attributes;
DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser(); DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
if (dwarf_ast) if (dwarf_ast)
return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, clang_type); return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, clang_type);
return false; return false;
} }
Type* Type*
SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed) SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed)
{ {
if (die) if (die)
{ {
▲ Show 20 Lines • Show All 2,789 Lines • Show Last 20 Lines