This is an archive of the discontinued LLVM Phabricator instance.

Paths

Table of Contentst

-
lldb/trunk/source/Plugins/SymbolFile/DWARF/
-
trunk/
-
source/
-
Plugins/
-
SymbolFile/
-
DWARF/
-
DWARFCompileUnit.h
-
DWARFCompileUnit.cpp
-
DWARFDebugInfoEntry.cpp
-
DWARFUnit.h
-
DWARFUnit.cpp
-
SymbolFileDWARF.h
-
SymbolFileDWARF.cpp
-
SymbolFileDWARFDebugMap.h

Differential D45170

Cleanup DWARFCompileUnit and DWARFUnit in preparation for adding DWARFTypeUnit
ClosedPublic

Authored by clayborg on Apr 2 2018, 9:45 AM.

Download Raw Diff

Details

Reviewers

labath
davide
aprantl
jasonmolenda

Commits

rG118bcd9ce247: Cleanup DWARFCompileUnit and DWARFUnit in preparation for adding DWARFTypeUnit
rLLDB329305: Cleanup DWARFCompileUnit and DWARFUnit in preparation for adding DWARFTypeUnit
rL329305: Cleanup DWARFCompileUnit and DWARFUnit in preparation for adding DWARFTypeUnit

Summary

Many things that were in DWARFCompileUnit actually need to be in DWARFUnit. This patch moves all DWARFUnit specific things over into DWARFUnit and fixes the layering. This is in preparation for adding DWARFTypeUnit for the .debug_types patch.

Diff Detail

Repository: rL LLVM

Event Timeline

clayborg created this revision.Apr 2 2018, 9:45 AM

Herald added a subscriber: JDevlieghere. · View Herald TranscriptApr 2 2018, 9:45 AM

Thanks Greg. This is a very large patch, but it seems mostly churn. I'll try to find the time to review it carefully tomorrow.

Yes this is just moving all ivars from DWARFCompileUnit to DWARFUnit, moving all functions that used those accessors to DWARFUnit and remove the indirection through DWARFCompileUnit that was in DWARFUnit using:

virtual DWARFCompileUnit &Data() = 0;

No real functional change, just fixing layering and moving code. Also a renaming from GetCompileUnitDIEOnly to GetUnitDIEOnly.

ping

I have only one general question and otherwise I'm fine with this: Does this bring LLDB's DWARF parser closer to the structure of LLVM's? We still want to long-term replace LLDB's DWARF parser with LLVM's so every refactoring should aim at making their interfaces more similar.

In D45170#1057067, @aprantl wrote:

I have only one general question and otherwise I'm fine with this: Does this bring LLDB's DWARF parser closer to the structure of LLVM's? We still want to long-term replace LLDB's DWARF parser with LLVM's so every refactoring should aim at making their interfaces more similar.

It does indeed. Very close.

That's great! Let's go for it then. Could you please doxygen'ify the comments?

This revision is now accepted and ready to land.Apr 5 2018, 8:45 AM

Closed by commit rL329305: Cleanup DWARFCompileUnit and DWARFUnit in preparation for adding DWARFTypeUnit (authored by gclayton). · Explain WhyApr 5 2018, 8:55 AM

This revision was automatically updated to reflect the committed changes.

Herald added a subscriber: llvm-commits. · View Herald TranscriptApr 5 2018, 8:55 AM

I disagree with this patch as DWARFUnit was a lightweight wrapper for DWARFPartialUnit. Now I will have to create some new lightweight superclass like DWARFAbstractUnit.
My patch prepared it for:

DWARFUnit->DWARFCompileUnit
DWARFUnit->DWARFPartialUnit

And I planned the type units should be implemented like:

DWARFUnit->DWARFSomeNameUnit->DWARFCompileUnit
DWARFUnit->DWARFSomeNameUnit->DWARFTypeUnit
DWARFUnit->DWARFPartialUnit

This patch just reused + changed my abstraction for a completely different purpose and I will have to reimplement it again under a different name. Or what do you suggest?

I have reverted this commit after approval by Davide Italiano and Adrian Prantl at:

https://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180402/040176.html

The revert:

git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@329423 91177308-0d34-0410-b5e6-96231b3b80d8
GIT commit a4b4ca0aef594f71e44478c2f16ca9fd53938ec6

jankratochvil mentioned this in rL338224: Remove friend class declarations from DWARFUnit and DWARFCompileUnit.Jul 29 2018, 12:32 PM

Revision Contents

Path

Size

lldb/

trunk/

source/

Plugins/

SymbolFile/

DWARF/

DWARFCompileUnit.h

106 lines

DWARFCompileUnit.cpp

580 lines

DWARFDebugInfoEntry.cpp

4 lines

67 lines

622 lines

2 lines

12 lines

SymbolFileDWARFDebugMap.h

2 lines

Diff 141169

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

	Show All 12 Lines
	#include "DWARFUnit.h"			#include "DWARFUnit.h"

	class DWARFCompileUnit : public DWARFUnit {			class DWARFCompileUnit : public DWARFUnit {
	friend class DWARFUnit;			friend class DWARFUnit;

	public:			public:
	static DWARFUnitSP Extract(SymbolFileDWARF *dwarf2Data,			static DWARFUnitSP Extract(SymbolFileDWARF *dwarf2Data,
	lldb::offset_t *offset_ptr);			lldb::offset_t *offset_ptr);
				void Dump(lldb_private::Stream *s) const override;
	size_t ExtractDIEsIfNeeded(bool cu_die_only);
	DWARFDIE LookupAddress(const dw_addr_t address);
	size_t AppendDIEsWithTag(const dw_tag_t tag,
	DWARFDIECollection &matching_dies,
	uint32_t depth = UINT32_MAX) const;
	bool Verify(lldb_private::Stream *s) const;
	void Dump(lldb_private::Stream *s) const;
	lldb::user_id_t GetID() const;
	dw_offset_t GetAbbrevOffset() const;
	void SetAddrBase(dw_addr_t addr_base, dw_addr_t ranges_base, dw_offset_t base_obj_offset);
	void ClearDIEs(bool keep_compile_unit_die);
	void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
	DWARFDebugAranges *debug_aranges);

	lldb_private::TypeSystem *GetTypeSystem();

	DWARFDIE
	GetCompileUnitDIEOnly() { return DWARFDIE(this, GetCompileUnitDIEPtrOnly()); }

	DWARFDIE
	DIE() { return DWARFDIE(this, DIEPtr()); }

	void AddDIE(DWARFDebugInfoEntry &die) {
	// The average bytes per DIE entry has been seen to be
	// around 14-20 so lets pre-reserve half of that since
	// we are now stripping the NULL tags.

	// Only reserve the memory if we are adding children of
	// the main compile unit DIE. The compile unit DIE is always
	// the first entry, so if our size is 1, then we are adding
	// the first compile unit child DIE and should reserve
	// the memory.
	if (m_die_array.empty())
	m_die_array.reserve(GetDebugInfoSize() / 24);
	m_die_array.push_back(die);
	}

	void AddCompileUnitDIE(DWARFDebugInfoEntry &die);

	void SetUserData(void *d);

	const DWARFDebugAranges &GetFunctionAranges();

	DWARFProducer GetProducer();

	uint32_t GetProducerVersionMajor();

	uint32_t GetProducerVersionMinor();

	uint32_t GetProducerVersionUpdate();

	lldb::LanguageType GetLanguageType();

	bool GetIsOptimized();

	protected:
	virtual DWARFCompileUnit &Data() override { return *this; }
	virtual const DWARFCompileUnit &Data() const override { return *this; }

	SymbolFileDWARF *m_dwarf2Data;
	std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
	const DWARFAbbreviationDeclarationSet *m_abbrevs;
	void *m_user_data = nullptr;
	DWARFDebugInfoEntry::collection
	m_die_array; // The compile unit debug information entry item
	std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap; // A table similar to
	// the .debug_aranges
	// table, but this one
	// points to the exact
	// DW_TAG_subprogram
	// DIEs
	dw_addr_t m_base_addr = 0;
	dw_offset_t m_length;
	uint16_t m_version;
	uint8_t m_addr_size;
	DWARFProducer m_producer = eProducerInvalid;
	uint32_t m_producer_version_major = 0;
	uint32_t m_producer_version_minor = 0;
	uint32_t m_producer_version_update = 0;
	lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
	bool m_is_dwarf64;
	lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
	dw_addr_t m_addr_base = 0; // Value of DW_AT_addr_base
	dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
	// If this is a dwo compile unit this is the offset of the base compile unit
	// in the main object file
	dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;

	void ParseProducerInfo();

	private:			private:
	DWARFCompileUnit(SymbolFileDWARF *dwarf2Data);			DWARFCompileUnit(SymbolFileDWARF *dwarf2Data);

	const DWARFDebugInfoEntry *GetCompileUnitDIEPtrOnly() {
	ExtractDIEsIfNeeded(true);
	if (m_die_array.empty())
	return NULL;
	return &m_die_array[0];
	}

	const DWARFDebugInfoEntry *DIEPtr() {
	ExtractDIEsIfNeeded(false);
	if (m_die_array.empty())
	return NULL;
	return &m_die_array[0];
	}

	DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);			DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
	};			};

	#endif // SymbolFileDWARF_DWARFCompileUnit_h_			#endif // SymbolFileDWARF_DWARFCompileUnit_h_

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

//===-- DWARFCompileUnit.cpp ------------------------------------- C++ --===//		//===-- DWARFCompileUnit.cpp ------------------------------------- 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.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "DWARFCompileUnit.h"		#include "DWARFCompileUnit.h"

#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Mangled.h"
#include "lldb/Core/Module.h"
#include "lldb/Host/StringConvert.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Utility/Timer.h"

#include "DWARFDIECollection.h"
#include "DWARFDebugAbbrev.h"
#include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h"
#include "DWARFFormValue.h"
#include "LogChannelDWARF.h"
#include "NameToDIE.h"
#include "SymbolFileDWARF.h"		#include "SymbolFileDWARF.h"
#include "SymbolFileDWARFDebugMap.h"
#include "SymbolFileDWARFDwo.h"

using namespace lldb;		using namespace lldb;
using namespace lldb_private;		using namespace lldb_private;
using namespace std;

extern int g_verbose;		extern int g_verbose;

DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)		DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
: m_dwarf2Data(dwarf2Data) {}		: DWARFUnit(dwarf2Data) {}

DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,		DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
lldb::offset_t *offset_ptr) {		lldb::offset_t *offset_ptr) {
// std::make_shared would require the ctor to be public.		// std::make_shared would require the ctor to be public.
std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));		std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));
// Out of memory?		// Out of memory?
if (cu_sp.get() == NULL)		if (cu_sp.get() == NULL)
return nullptr;		return nullptr;
Show All 26 Lines	if (debug_info.ValidOffset(*offset_ptr)) {

// reset the offset to where we tried to parse from if anything went wrong		// reset the offset to where we tried to parse from if anything went wrong
*offset_ptr = cu_sp->m_offset;		*offset_ptr = cu_sp->m_offset;
}		}

return nullptr;		return nullptr;
}		}

void DWARFCompileUnit::ClearDIEs(bool keep_compile_unit_die) {
if (m_die_array.size() > 1) {
// std::vectors never get any smaller when resized to a smaller size,
// or when clear() or erase() are called, the size will report that it
// is smaller, but the memory allocated remains intact (call capacity()
// to see this). So we need to create a temporary vector and swap the
// contents which will cause just the internal pointers to be swapped
// so that when "tmp_array" goes out of scope, it will destroy the
// contents.

// Save at least the compile unit DIE
DWARFDebugInfoEntry::collection tmp_array;
m_die_array.swap(tmp_array);
if (keep_compile_unit_die)
m_die_array.push_back(tmp_array.front());
}

if (m_dwo_symbol_file)
m_dwo_symbol_file->GetCompileUnit()->ClearDIEs(keep_compile_unit_die);
}

//----------------------------------------------------------------------
// ParseCompileUnitDIEsIfNeeded
//
// Parses a compile unit and indexes its DIEs if it hasn't already been
// done.
//----------------------------------------------------------------------
size_t DWARFCompileUnit::ExtractDIEsIfNeeded(bool cu_die_only) {
const size_t initial_die_array_size = m_die_array.size();
if ((cu_die_only && initial_die_array_size > 0) \|\| initial_die_array_size > 1)
return 0; // Already parsed

static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(
func_cat,
"%8.8x: DWARFCompileUnit::ExtractDIEsIfNeeded( cu_die_only = %i )",
m_offset, cu_die_only);

// Set the offset to that of the first DIE and calculate the start of the
// next compilation unit header.
lldb::offset_t offset = GetFirstDIEOffset();
lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();

DWARFDebugInfoEntry die;
// Keep a flat array of the DIE for binary lookup by DIE offset
if (!cu_die_only) {
Log *log(
LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO \| DWARF_LOG_LOOKUPS));
if (log) {
m_dwarf2Data->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
log, "DWARFCompileUnit::ExtractDIEsIfNeeded () for compile unit at "
".debug_info[0x%8.8x]",
GetOffset());
}
}

uint32_t depth = 0;
// We are in our compile unit, parse starting at the offset
// we were told to parse
const DWARFDataExtractor &debug_info_data =
m_dwarf2Data->get_debug_info_data();
std::vector<uint32_t> die_index_stack;
die_index_stack.reserve(32);
die_index_stack.push_back(0);
bool prev_die_had_children = false;
DWARFFormValue::FixedFormSizes fixed_form_sizes =
DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
m_is_dwarf64);
while (offset < next_cu_offset &&
die.FastExtract(debug_info_data, this, fixed_form_sizes, &offset)) {
// if (log)
// log->Printf("0x%8.8x: %.s%s%s",
// die.GetOffset(),
// depth * 2, depth * 2, "",
// DW_TAG_value_to_name (die.Tag()),
// die.HasChildren() ? " *" : "");

const bool null_die = die.IsNULL();
if (depth == 0) {
if (initial_die_array_size == 0)
AddCompileUnitDIE(die);
uint64_t base_addr = die.GetAttributeValueAsAddress(
m_dwarf2Data, this, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
if (base_addr == LLDB_INVALID_ADDRESS)
base_addr = die.GetAttributeValueAsAddress(m_dwarf2Data, this,
DW_AT_entry_pc, 0);
SetBaseAddress(base_addr);
if (cu_die_only)
return 1;
} else {
if (null_die) {
if (prev_die_had_children) {
// This will only happen if a DIE says is has children
// but all it contains is a NULL tag. Since we are removing
// the NULL DIEs from the list (saves up to 25% in C++ code),
// we need a way to let the DIE know that it actually doesn't
// have children.
if (!m_die_array.empty())
m_die_array.back().SetEmptyChildren(true);
}
} else {
die.SetParentIndex(m_die_array.size() - die_index_stack[depth - 1]);

if (die_index_stack.back())
m_die_array[die_index_stack.back()].SetSiblingIndex(
m_die_array.size() - die_index_stack.back());

// Only push the DIE if it isn't a NULL DIE
m_die_array.push_back(die);
}
}

if (null_die) {
// NULL DIE.
if (!die_index_stack.empty())
die_index_stack.pop_back();

if (depth > 0)
--depth;
if (depth == 0)
break; // We are done with this compile unit!

prev_die_had_children = false;
} else {
die_index_stack.back() = m_die_array.size() - 1;
// Normal DIE
const bool die_has_children = die.HasChildren();
if (die_has_children) {
die_index_stack.push_back(0);
++depth;
}
prev_die_had_children = die_has_children;
}
}

// Give a little bit of info if we encounter corrupt DWARF (our offset
// should always terminate at or before the start of the next compilation
// unit header).
if (offset > next_cu_offset) {
m_dwarf2Data->GetObjectFile()->GetModule()->ReportWarning(
"DWARF compile unit extends beyond its bounds cu 0x%8.8x at "
"0x%8.8" PRIx64 "\n",
GetOffset(), offset);
}

// Since std::vector objects will double their size, we really need to
// make a new array with the perfect size so we don't end up wasting
// space. So here we copy and swap to make sure we don't have any extra
// memory taken up.

if (m_die_array.size() < m_die_array.capacity()) {
DWARFDebugInfoEntry::collection exact_size_die_array(m_die_array.begin(),
m_die_array.end());
exact_size_die_array.swap(m_die_array);
}
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
if (log && log->GetVerbose()) {
StreamString strm;
Dump(&strm);
if (m_die_array.empty())
strm.Printf("error: no DIE for compile unit");
else
m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX);
log->PutString(strm.GetString());
}

if (!m_dwo_symbol_file)
return m_die_array.size();

DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only);
return m_die_array.size() + dwo_die_count -
1; // We have 2 CU die, but we want to count it only as one
}

void DWARFCompileUnit::AddCompileUnitDIE(DWARFDebugInfoEntry &die) {
assert(m_die_array.empty() && "Compile unit DIE already added");
AddDIE(die);

const DWARFDebugInfoEntry &cu_die = m_die_array.front();
std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
m_dwarf2Data->GetDwoSymbolFileForCompileUnit(*this, cu_die);
if (!dwo_symbol_file)
return;

DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
if (!dwo_cu)
return; // Can't fetch the compile unit from the dwo file.

DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
if (!dwo_cu_die.IsValid())
return; // Can't fetch the compile unit DIE from the dwo file.

uint64_t main_dwo_id = cu_die.GetAttributeValueAsUnsigned(
m_dwarf2Data, this, DW_AT_GNU_dwo_id, 0);
uint64_t sub_dwo_id =
dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0);
if (main_dwo_id != sub_dwo_id)
return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to
// a differectn compilation.

m_dwo_symbol_file = std::move(dwo_symbol_file);

dw_addr_t addr_base = cu_die.GetAttributeValueAsUnsigned(
m_dwarf2Data, this, DW_AT_GNU_addr_base, 0);
dw_addr_t ranges_base = cu_die.GetAttributeValueAsUnsigned(
m_dwarf2Data, this, DW_AT_GNU_ranges_base, 0);
dwo_cu->SetAddrBase(addr_base, ranges_base, m_offset);
}

dw_offset_t DWARFCompileUnit::GetAbbrevOffset() const {
return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
}

bool DWARFCompileUnit::Verify(Stream *s) const {
const DWARFDataExtractor &debug_info = m_dwarf2Data->get_debug_info_data();
bool valid_offset = debug_info.ValidOffset(m_offset);
bool length_OK = debug_info.ValidOffset(GetNextCompileUnitOffset() - 1);
bool version_OK = SymbolFileDWARF::SupportedVersion(m_version);
bool abbr_offset_OK =
m_dwarf2Data->get_debug_abbrev_data().ValidOffset(GetAbbrevOffset());
bool addr_size_OK = ((m_addr_size == 4) \|\| (m_addr_size == 8));
if (valid_offset && length_OK && version_OK && addr_size_OK &&
abbr_offset_OK) {
return true;
} else {
s->Printf(" 0x%8.8x: ", m_offset);
DumpDataExtractor(m_dwarf2Data->get_debug_info_data(), s, m_offset,
lldb::eFormatHex, 1, Size(), 32, LLDB_INVALID_ADDRESS, 0,
0);
s->EOL();
if (valid_offset) {
if (!length_OK)
s->Printf(" The length (0x%8.8x) for this compile unit is too "
"large for the .debug_info provided.\n",
m_length);
if (!version_OK)
s->Printf(" The 16 bit compile unit header version is not "
"supported.\n");
if (!abbr_offset_OK)
s->Printf(" The offset into the .debug_abbrev section (0x%8.8x) "
"is not valid.\n",
GetAbbrevOffset());
if (!addr_size_OK)
s->Printf(" The address size is unsupported: 0x%2.2x\n",
m_addr_size);
} else
s->Printf(" The start offset of the compile unit header in the "
".debug_info is invalid.\n");
}
return false;
}

void DWARFCompileUnit::Dump(Stream *s) const {		void DWARFCompileUnit::Dump(Stream *s) const {
s->Printf("0x%8.8x: Compile Unit: length = 0x%8.8x, version = 0x%4.4x, "		s->Printf("0x%8.8x: Compile Unit: length = 0x%8.8x, version = 0x%4.4x, "
"abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "		"abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
"{0x%8.8x})\n",		"{0x%8.8x})\n",
m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size,		m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size,
GetNextCompileUnitOffset());		GetNextCompileUnitOffset());
}		}

lldb::user_id_t DWARFCompileUnit::GetID() const {
dw_offset_t local_id =
m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset;
if (m_dwarf2Data)
return DIERef(local_id, local_id).GetUID(m_dwarf2Data);
else
return local_id;
}

void DWARFCompileUnit::BuildAddressRangeTable(
SymbolFileDWARF dwarf2Data, DWARFDebugAranges debug_aranges) {
// This function is usually called if there in no .debug_aranges section
// in order to produce a compile unit level set of address ranges that
// is accurate.

size_t num_debug_aranges = debug_aranges->GetNumRanges();

// First get the compile unit DIE only and check if it has a DW_AT_ranges
const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly();

const dw_offset_t cu_offset = GetOffset();
if (die) {
DWARFRangeList ranges;
const size_t num_ranges =
die->GetAttributeAddressRanges(dwarf2Data, this, ranges, false);
if (num_ranges > 0) {
// This compile unit has DW_AT_ranges, assume this is correct if it
// is present since clang no longer makes .debug_aranges by default
// and it emits DW_AT_ranges for DW_TAG_compile_units. GCC also does
// this with recent GCC builds.
for (size_t i = 0; i < num_ranges; ++i) {
const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
range.GetRangeEnd());
}

return; // We got all of our ranges from the DW_AT_ranges attribute
}
}
// We don't have a DW_AT_ranges attribute, so we need to parse the DWARF

// If the DIEs weren't parsed, then we don't want all dies for all compile
// units
// to stay loaded when they weren't needed. So we can end up parsing the DWARF
// and then throwing them all away to keep memory usage down.
const bool clear_dies = ExtractDIEsIfNeeded(false) > 1;

die = DIEPtr();
if (die)
die->BuildAddressRangeTable(dwarf2Data, this, debug_aranges);

if (debug_aranges->GetNumRanges() == num_debug_aranges) {
// We got nothing from the functions, maybe we have a line tables only
// situation. Check the line tables and build the arange table from this.
SymbolContext sc;
sc.comp_unit = dwarf2Data->GetCompUnitForDWARFCompUnit(this);
if (sc.comp_unit) {
SymbolFileDWARFDebugMap *debug_map_sym_file =
m_dwarf2Data->GetDebugMapSymfile();
if (debug_map_sym_file == NULL) {
LineTable *line_table = sc.comp_unit->GetLineTable();

if (line_table) {
LineTable::FileAddressRanges file_ranges;
const bool append = true;
const size_t num_ranges =
line_table->GetContiguousFileAddressRanges(file_ranges, append);
for (uint32_t idx = 0; idx < num_ranges; ++idx) {
const LineTable::FileAddressRanges::Entry &range =
file_ranges.GetEntryRef(idx);
debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
range.GetRangeEnd());
}
}
} else
debug_map_sym_file->AddOSOARanges(dwarf2Data, debug_aranges);
}
}

if (debug_aranges->GetNumRanges() == num_debug_aranges) {
// We got nothing from the functions, maybe we have a line tables only
// situation. Check the line tables and build the arange table from this.
SymbolContext sc;
sc.comp_unit = dwarf2Data->GetCompUnitForDWARFCompUnit(this);
if (sc.comp_unit) {
LineTable *line_table = sc.comp_unit->GetLineTable();

if (line_table) {
LineTable::FileAddressRanges file_ranges;
const bool append = true;
const size_t num_ranges =
line_table->GetContiguousFileAddressRanges(file_ranges, append);
for (uint32_t idx = 0; idx < num_ranges; ++idx) {
const LineTable::FileAddressRanges::Entry &range =
file_ranges.GetEntryRef(idx);
debug_aranges->AppendRange(GetOffset(), range.GetRangeBase(),
range.GetRangeEnd());
}
}
}
}

// Keep memory down by clearing DIEs if this generate function
// caused them to be parsed
if (clear_dies)
ClearDIEs(true);
}

const DWARFDebugAranges &DWARFCompileUnit::GetFunctionAranges() {
if (m_func_aranges_ap.get() == NULL) {
m_func_aranges_ap.reset(new DWARFDebugAranges());
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES));

if (log) {
m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage(
log, "DWARFCompileUnit::GetFunctionAranges() for compile unit at "
".debug_info[0x%8.8x]",
GetOffset());
}
const DWARFDebugInfoEntry *die = DIEPtr();
if (die)
die->BuildFunctionAddressRangeTable(m_dwarf2Data, this,
m_func_aranges_ap.get());

if (m_dwo_symbol_file) {
DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
const DWARFDebugInfoEntry *dwo_die = dwo_cu->DIEPtr();
if (dwo_die)
dwo_die->BuildFunctionAddressRangeTable(m_dwo_symbol_file.get(), dwo_cu,
m_func_aranges_ap.get());
}

const bool minimize = false;
m_func_aranges_ap->Sort(minimize);
}
return *m_func_aranges_ap.get();
}

DWARFDIE
DWARFCompileUnit::LookupAddress(const dw_addr_t address) {
if (DIE()) {
const DWARFDebugAranges &func_aranges = GetFunctionAranges();

// Re-check the aranges auto pointer contents in case it was created above
if (!func_aranges.IsEmpty())
return GetDIE(func_aranges.FindAddress(address));
}
return DWARFDIE();
}

size_t DWARFCompileUnit::AppendDIEsWithTag(const dw_tag_t tag,
DWARFDIECollection &dies,
uint32_t depth) const {
size_t old_size = dies.Size();
DWARFDebugInfoEntry::const_iterator pos;
DWARFDebugInfoEntry::const_iterator end = m_die_array.end();
for (pos = m_die_array.begin(); pos != end; ++pos) {
if (pos->Tag() == tag)
dies.Append(DWARFDIE(this, &(*pos)));
}

// Return the number of DIEs added to the collection
return dies.Size() - old_size;
}

// void
// DWARFCompileUnit::AddGlobalDIEByIndex (uint32_t die_idx)
//{
// m_global_die_indexes.push_back (die_idx);
//}
//
//
// void
// DWARFCompileUnit::AddGlobal (const DWARFDebugInfoEntry* die)
//{
// // Indexes to all file level global and static variables
// m_global_die_indexes;
//
// if (m_die_array.empty())
// return;
//
// const DWARFDebugInfoEntry* first_die = &m_die_array[0];
// const DWARFDebugInfoEntry* end = first_die + m_die_array.size();
// if (first_die <= die && die < end)
// m_global_die_indexes.push_back (die - first_die);
//}

void DWARFCompileUnit::ParseProducerInfo() {
m_producer_version_major = UINT32_MAX;
m_producer_version_minor = UINT32_MAX;
m_producer_version_update = UINT32_MAX;

const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly();
if (die) {

const char *producer_cstr = die->GetAttributeValueAsString(
m_dwarf2Data, this, DW_AT_producer, NULL);
if (producer_cstr) {
RegularExpression llvm_gcc_regex(
llvm::StringRef("^4\\.[012]\\.[01] \\(Based on Apple "
"Inc\\. build [0-9]+\\) \\(LLVM build "
"[\\.0-9]+\\)$"));
if (llvm_gcc_regex.Execute(llvm::StringRef(producer_cstr))) {
m_producer = eProducerLLVMGCC;
} else if (strstr(producer_cstr, "clang")) {
static RegularExpression g_clang_version_regex(
llvm::StringRef("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)"));
RegularExpression::Match regex_match(3);
if (g_clang_version_regex.Execute(llvm::StringRef(producer_cstr),
&regex_match)) {
std::string str;
if (regex_match.GetMatchAtIndex(producer_cstr, 1, str))
m_producer_version_major =
StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
if (regex_match.GetMatchAtIndex(producer_cstr, 2, str))
m_producer_version_minor =
StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
if (regex_match.GetMatchAtIndex(producer_cstr, 3, str))
m_producer_version_update =
StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
}
m_producer = eProducerClang;
} else if (strstr(producer_cstr, "GNU"))
m_producer = eProducerGCC;
}
}
if (m_producer == eProducerInvalid)
m_producer = eProcucerOther;
}

DWARFProducer DWARFCompileUnit::GetProducer() {
if (m_producer == eProducerInvalid)
ParseProducerInfo();
return m_producer;
}

uint32_t DWARFCompileUnit::GetProducerVersionMajor() {
if (m_producer_version_major == 0)
ParseProducerInfo();
return m_producer_version_major;
}

uint32_t DWARFCompileUnit::GetProducerVersionMinor() {
if (m_producer_version_minor == 0)
ParseProducerInfo();
return m_producer_version_minor;
}

uint32_t DWARFCompileUnit::GetProducerVersionUpdate() {
if (m_producer_version_update == 0)
ParseProducerInfo();
return m_producer_version_update;
}

LanguageType DWARFCompileUnit::GetLanguageType() {
if (m_language_type != eLanguageTypeUnknown)
return m_language_type;

const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly();
if (die)
m_language_type = LanguageTypeFromDWARF(die->GetAttributeValueAsUnsigned(
m_dwarf2Data, this, DW_AT_language, 0));
return m_language_type;
}

bool DWARFCompileUnit::GetIsOptimized() {
if (m_is_optimized == eLazyBoolCalculate) {
const DWARFDebugInfoEntry *die = GetCompileUnitDIEPtrOnly();
if (die) {
m_is_optimized = eLazyBoolNo;
if (die->GetAttributeValueAsUnsigned(m_dwarf2Data, this,
DW_AT_APPLE_optimized, 0) == 1) {
m_is_optimized = eLazyBoolYes;
}
}
}
if (m_is_optimized == eLazyBoolYes) {
return true;
} else {
return false;
}
}

TypeSystem *DWARFCompileUnit::GetTypeSystem() {
if (m_dwarf2Data)
return m_dwarf2Data->GetTypeSystemForLanguage(GetLanguageType());
else
return nullptr;
}

void DWARFCompileUnit::SetUserData(void *d) {
m_user_data = d;
if (m_dwo_symbol_file)
m_dwo_symbol_file->GetCompileUnit()->SetUserData(d);
}

void DWARFCompileUnit::SetAddrBase(dw_addr_t addr_base,
dw_addr_t ranges_base,
dw_offset_t base_obj_offset) {
m_addr_base = addr_base;
m_ranges_base = ranges_base;
m_base_obj_offset = base_obj_offset;
}

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

Show First 20 Lines • Show All 634 Lines • ▼ Show 20 Lines	if (debug_info_data.ValidOffset(offset)) {
} else {		} else {
s.Printf("NULL\n");		s.Printf("NULL\n");
}		}
}		}
}		}

void DWARFDebugInfoEntry::DumpLocation(SymbolFileDWARF *dwarf2Data,		void DWARFDebugInfoEntry::DumpLocation(SymbolFileDWARF *dwarf2Data,
DWARFUnit *cu, Stream &s) const {		DWARFUnit *cu, Stream &s) const {
const DWARFDIE cu_die = cu->GetCompileUnitDIEOnly();		const DWARFDIE cu_die = cu->GetUnitDIEOnly();
const char *cu_name = NULL;		const char *cu_name = NULL;
if (cu_die)		if (cu_die)
cu_name = cu_die.GetName();		cu_name = cu_die.GetName();
const char *obj_file_name = NULL;		const char *obj_file_name = NULL;
ObjectFile *obj_file = dwarf2Data->GetObjectFile();		ObjectFile *obj_file = dwarf2Data->GetObjectFile();
if (obj_file)		if (obj_file)
obj_file_name =		obj_file_name =
obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>");		obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>");
▲ Show 20 Lines • Show All 259 Lines • ▼ Show 20 Lines	dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(

if (!dwo_symbol_file)		if (!dwo_symbol_file)
return 0;		return 0;

DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();		DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
if (!dwo_cu)		if (!dwo_cu)
return 0;		return 0;

DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();		DWARFDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
if (!dwo_cu_die.IsValid())		if (!dwo_cu_die.IsValid())
return 0;		return 0;

return dwo_cu_die.GetDIE()->GetAttributeValue(		return dwo_cu_die.GetDIE()->GetAttributeValue(
dwo_symbol_file, dwo_cu, attr, form_value, end_attr_offset_ptr,		dwo_symbol_file, dwo_cu, attr, form_value, end_attr_offset_ptr,
check_specification_or_abstract_origin);		check_specification_or_abstract_origin);
}		}

▲ Show 20 Lines • Show All 900 Lines • Show Last 20 Lines

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

Show All 36 Lines	public:
virtual ~DWARFUnit();		virtual ~DWARFUnit();

size_t ExtractDIEsIfNeeded(bool cu_die_only);		size_t ExtractDIEsIfNeeded(bool cu_die_only);
DWARFDIE LookupAddress(const dw_addr_t address);		DWARFDIE LookupAddress(const dw_addr_t address);
size_t AppendDIEsWithTag(const dw_tag_t tag,		size_t AppendDIEsWithTag(const dw_tag_t tag,
DWARFDIECollection &matching_dies,		DWARFDIECollection &matching_dies,
uint32_t depth = UINT32_MAX) const;		uint32_t depth = UINT32_MAX) const;
bool Verify(lldb_private::Stream *s) const;		bool Verify(lldb_private::Stream *s) const;
void Dump(lldb_private::Stream *s) const;		virtual void Dump(lldb_private::Stream *s) const = 0;
// Offset of the initial length field.		// Offset of the initial length field.
dw_offset_t GetOffset() const { return m_offset; }		dw_offset_t GetOffset() const { return m_offset; }
lldb::user_id_t GetID() const;		lldb::user_id_t GetID() const;
// Size in bytes of the initial length + compile unit header.		// Size in bytes of the initial length + compile unit header.
uint32_t Size() const;		uint32_t Size() const;
bool ContainsDIEOffset(dw_offset_t die_offset) const {		bool ContainsDIEOffset(dw_offset_t die_offset) const {
return die_offset >= GetFirstDIEOffset() &&		return die_offset >= GetFirstDIEOffset() &&
die_offset < GetNextCompileUnitOffset();		die_offset < GetNextCompileUnitOffset();
}		}
dw_offset_t GetFirstDIEOffset() const { return m_offset + Size(); }		dw_offset_t GetFirstDIEOffset() const { return m_offset + Size(); }
dw_offset_t GetNextCompileUnitOffset() const;		dw_offset_t GetNextCompileUnitOffset() const;
// Size of the CU data (without initial length and without header).		// Size of the CU data (without initial length and without header).
size_t GetDebugInfoSize() const;		size_t GetDebugInfoSize() const;
// Size of the CU data incl. header but without initial length.		// Size of the CU data incl. header but without initial length.
uint32_t GetLength() const;		uint32_t GetLength() const;
uint16_t GetVersion() const;		uint16_t GetVersion() const;
const DWARFAbbreviationDeclarationSet *GetAbbreviations() const;		const DWARFAbbreviationDeclarationSet *GetAbbreviations() const;
dw_offset_t GetAbbrevOffset() const;		dw_offset_t GetAbbrevOffset() const;
uint8_t GetAddressByteSize() const;		uint8_t GetAddressByteSize() const;
dw_addr_t GetBaseAddress() const;		dw_addr_t GetBaseAddress() const;
dw_addr_t GetAddrBase() const;		dw_addr_t GetAddrBase() const;
dw_addr_t GetRangesBase() const;		dw_addr_t GetRangesBase() const;
void SetAddrBase(dw_addr_t addr_base, dw_addr_t ranges_base, dw_offset_t base_obj_offset);		void SetAddrBase(dw_addr_t addr_base, dw_addr_t ranges_base,
		dw_offset_t base_obj_offset);
void ClearDIEs(bool keep_compile_unit_die);		void ClearDIEs(bool keep_compile_unit_die);
void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,		void BuildAddressRangeTable(SymbolFileDWARF *dwarf,
DWARFDebugAranges *debug_aranges);		DWARFDebugAranges *debug_aranges);

lldb::ByteOrder GetByteOrder() const;		lldb::ByteOrder GetByteOrder() const;

lldb_private::TypeSystem *GetTypeSystem();		lldb_private::TypeSystem *GetTypeSystem();

		const DWARFDebugAranges &GetFunctionAranges();

DWARFFormValue::FixedFormSizes GetFixedFormSizes();		DWARFFormValue::FixedFormSizes GetFixedFormSizes();

void SetBaseAddress(dw_addr_t base_addr);		void SetBaseAddress(dw_addr_t base_addr);

DWARFDIE		DWARFDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
GetCompileUnitDIEOnly();

DWARFDIE		DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }
DIE();

bool HasDIEsParsed() const;		bool HasDIEsParsed() const;

DWARFDIE GetDIE(dw_offset_t die_offset);		DWARFDIE GetDIE(dw_offset_t die_offset);

static uint8_t GetAddressByteSize(const DWARFUnit *cu);		static uint8_t GetAddressByteSize(const DWARFUnit *cu);

static bool IsDWARF64(const DWARFUnit *cu);		static bool IsDWARF64(const DWARFUnit *cu);

static uint8_t GetDefaultAddressSize();		static uint8_t GetDefaultAddressSize();

static void SetDefaultAddressSize(uint8_t addr_size);

void *GetUserData() const;		void *GetUserData() const;

void SetUserData(void *d);		void SetUserData(void *d);

bool Supports_DW_AT_APPLE_objc_complete_type();		bool Supports_DW_AT_APPLE_objc_complete_type();

bool DW_AT_decl_file_attributes_are_invalid();		bool DW_AT_decl_file_attributes_are_invalid();

Show All 22 Lines	public:

bool GetIsOptimized();		bool GetIsOptimized();

SymbolFileDWARFDwo *GetDwoSymbolFile() const;		SymbolFileDWARFDwo *GetDwoSymbolFile() const;

dw_offset_t GetBaseObjOffset() const;		dw_offset_t GetBaseObjOffset() const;

protected:		protected:
virtual DWARFCompileUnit &Data() = 0;		DWARFUnit(SymbolFileDWARF *dwarf);
virtual const DWARFCompileUnit &Data() const = 0;

DWARFUnit();		SymbolFileDWARF *m_dwarf = nullptr;
		std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
		const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
		void *m_user_data = nullptr;
		// The compile unit debug information entry item
		DWARFDebugInfoEntry::collection m_die_array;
		// A table similar to the .debug_aranges table, but this one points to the
		// exact DW_TAG_subprogram DIEs
		std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap;
		dw_addr_t m_base_addr = 0;
		dw_offset_t m_length = 0;
		uint16_t m_version = 0;
		uint8_t m_addr_size = 0;
		DWARFProducer m_producer = eProducerInvalid;
		uint32_t m_producer_version_major = 0;
		uint32_t m_producer_version_minor = 0;
		uint32_t m_producer_version_update = 0;
		lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
		bool m_is_dwarf64 = false;
		lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
		dw_addr_t m_addr_base = 0; // Value of DW_AT_addr_base
		dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
		// If this is a dwo compile unit this is the offset of the base compile unit
		// in the main object file
		dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;

static void		static void
IndexPrivate(DWARFUnit *dwarf_cu, const lldb::LanguageType cu_language,		IndexPrivate(DWARFUnit *dwarf_cu, const lldb::LanguageType cu_language,
const DWARFFormValue::FixedFormSizes &fixed_form_sizes,		const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
const dw_offset_t cu_offset, NameToDIE &func_basenames,		const dw_offset_t cu_offset, NameToDIE &func_basenames,
NameToDIE &func_fullnames, NameToDIE &func_methods,		NameToDIE &func_fullnames, NameToDIE &func_methods,
NameToDIE &func_selectors, NameToDIE &objc_class_selectors,		NameToDIE &func_selectors, NameToDIE &objc_class_selectors,
NameToDIE &globals, NameToDIE &types, NameToDIE &namespaces);		NameToDIE &globals, NameToDIE &types, NameToDIE &namespaces);

// Offset of the initial length field.		// Offset of the initial length field.
dw_offset_t m_offset;		dw_offset_t m_offset;

private:		private:
const DWARFDebugInfoEntry *GetCompileUnitDIEPtrOnly();		void ParseProducerInfo();

		// Get the DWARF unit DWARF debug informration entry. Parse the single DIE
		// if needed.
		const DWARFDebugInfoEntry *GetUnitDIEPtrOnly() {
		ExtractDIEsIfNeeded(true);
		if (m_die_array.empty())
		return NULL;
		return &m_die_array[0];
		}

		// Get all DWARF debug informration entries. Parse all DIEs if needed.
		const DWARFDebugInfoEntry *DIEPtr() {
		ExtractDIEsIfNeeded(false);
		if (m_die_array.empty())
		return NULL;
		return &m_die_array[0];
		}

const DWARFDebugInfoEntry *DIEPtr();		void AddUnitDIE(DWARFDebugInfoEntry &die);

DISALLOW_COPY_AND_ASSIGN(DWARFUnit);		DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
};		};

#endif // SymbolFileDWARF_DWARFUnit_h_		#endif // SymbolFileDWARF_DWARFUnit_h_

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

//===-- DWARFUnit.cpp -------------------------------------------- C++ --===//		//===-- DWARFUnit.cpp -------------------------------------------- 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.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "DWARFUnit.h"		#include "DWARFUnit.h"

#include "Plugins/Language/ObjC/ObjCLanguage.h"		#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "lldb/Core/Module.h"		#include "lldb/Core/Module.h"
		#include "lldb/Host/StringConvert.h"
		#include "lldb/Symbol/CompileUnit.h"
		#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h"		#include "lldb/Symbol/ObjectFile.h"
		#include "lldb/Utility/Timer.h"

#include "DWARFCompileUnit.h"		#include "DWARFDIECollection.h"
		#include "DWARFDebugAbbrev.h"
		#include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h"		#include "DWARFDebugInfo.h"
#include "LogChannelDWARF.h"		#include "LogChannelDWARF.h"
		#include "SymbolFileDWARFDebugMap.h"
#include "SymbolFileDWARFDwo.h"		#include "SymbolFileDWARFDwo.h"

using namespace lldb;		using namespace lldb;
using namespace lldb_private;		using namespace lldb_private;
using namespace std;		using namespace std;

extern int g_verbose;		extern int g_verbose;

DWARFUnit::DWARFUnit() {}		DWARFUnit::DWARFUnit(SymbolFileDWARF *dwarf) : m_dwarf(dwarf) {}

DWARFUnit::~DWARFUnit() {}		DWARFUnit::~DWARFUnit() {}

		//----------------------------------------------------------------------
		// ParseCompileUnitDIEsIfNeeded
		//
		// Parses a compile unit and indexes its DIEs if it hasn't already been
		// done.
		//----------------------------------------------------------------------
size_t DWARFUnit::ExtractDIEsIfNeeded(bool cu_die_only) {		size_t DWARFUnit::ExtractDIEsIfNeeded(bool cu_die_only) {
return Data().ExtractDIEsIfNeeded(cu_die_only);		const size_t initial_die_array_size = m_die_array.size();
		if ((cu_die_only && initial_die_array_size > 0) \|\| initial_die_array_size > 1)
		return 0; // Already parsed

		static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
		Timer scoped_timer(
		func_cat, "%8.8x: DWARFUnit::ExtractDIEsIfNeeded( cu_die_only = %i )",
		m_offset, cu_die_only);

		// Set the offset to that of the first DIE and calculate the start of the
		// next compilation unit header.
		lldb::offset_t offset = GetFirstDIEOffset();
		lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();

		DWARFDebugInfoEntry die;
		// Keep a flat array of the DIE for binary lookup by DIE offset
		if (!cu_die_only) {
		Log *log(
		LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO \| DWARF_LOG_LOOKUPS));
		if (log) {
		m_dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
		log,
		"DWARFUnit::ExtractDIEsIfNeeded () for compile unit at "
		".debug_info[0x%8.8x]",
		GetOffset());
		}
		}

		uint32_t depth = 0;
		// We are in our compile unit, parse starting at the offset
		// we were told to parse
		const DWARFDataExtractor &debug_info_data = m_dwarf->get_debug_info_data();
		std::vector<uint32_t> die_index_stack;
		die_index_stack.reserve(32);
		die_index_stack.push_back(0);
		bool prev_die_had_children = false;
		DWARFFormValue::FixedFormSizes fixed_form_sizes =
		DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
		m_is_dwarf64);
		while (offset < next_cu_offset &&
		die.FastExtract(debug_info_data, this, fixed_form_sizes, &offset)) {
		// if (log)
		// log->Printf("0x%8.8x: %.s%s%s",
		// die.GetOffset(),
		// depth * 2, depth * 2, "",
		// DW_TAG_value_to_name (die.Tag()),
		// die.HasChildren() ? " *" : "");

		const bool null_die = die.IsNULL();
		if (depth == 0) {
		if (initial_die_array_size == 0)
		AddUnitDIE(die);
		uint64_t base_addr = die.GetAttributeValueAsAddress(
		m_dwarf, this, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
		if (base_addr == LLDB_INVALID_ADDRESS)
		base_addr =
		die.GetAttributeValueAsAddress(m_dwarf, this, DW_AT_entry_pc, 0);
		SetBaseAddress(base_addr);
		if (cu_die_only)
		return 1;
		} else {
		if (null_die) {
		if (prev_die_had_children) {
		// This will only happen if a DIE says is has children
		// but all it contains is a NULL tag. Since we are removing
		// the NULL DIEs from the list (saves up to 25% in C++ code),
		// we need a way to let the DIE know that it actually doesn't
		// have children.
		if (!m_die_array.empty())
		m_die_array.back().SetEmptyChildren(true);
		}
		} else {
		die.SetParentIndex(m_die_array.size() - die_index_stack[depth - 1]);

		if (die_index_stack.back())
		m_die_array[die_index_stack.back()].SetSiblingIndex(
		m_die_array.size() - die_index_stack.back());

		// Only push the DIE if it isn't a NULL DIE
		m_die_array.push_back(die);
		}
		}

		if (null_die) {
		// NULL DIE.
		if (!die_index_stack.empty())
		die_index_stack.pop_back();

		if (depth > 0)
		--depth;
		if (depth == 0)
		break; // We are done with this compile unit!

		prev_die_had_children = false;
		} else {
		die_index_stack.back() = m_die_array.size() - 1;
		// Normal DIE
		const bool die_has_children = die.HasChildren();
		if (die_has_children) {
		die_index_stack.push_back(0);
		++depth;
		}
		prev_die_had_children = die_has_children;
		}
		}

		// Give a little bit of info if we encounter corrupt DWARF (our offset
		// should always terminate at or before the start of the next compilation
		// unit header).
		if (offset > next_cu_offset) {
		m_dwarf->GetObjectFile()->GetModule()->ReportWarning(
		"DWARF compile unit extends beyond its bounds cu 0x%8.8x at "
		"0x%8.8" PRIx64 "\n",
		GetOffset(), offset);
		}

		// Since std::vector objects will double their size, we really need to
		// make a new array with the perfect size so we don't end up wasting
		// space. So here we copy and swap to make sure we don't have any extra
		// memory taken up.

		if (m_die_array.size() < m_die_array.capacity()) {
		DWARFDebugInfoEntry::collection exact_size_die_array(m_die_array.begin(),
		m_die_array.end());
		exact_size_die_array.swap(m_die_array);
		}
		Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
		if (log && log->GetVerbose()) {
		StreamString strm;
		Dump(&strm);
		if (m_die_array.empty())
		strm.Printf("error: no DIE for compile unit");
		else
		m_die_array[0].Dump(m_dwarf, this, strm, UINT32_MAX);
		log->PutString(strm.GetString());
		}

		if (!m_dwo_symbol_file)
		return m_die_array.size();

		DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
		size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only);
		return m_die_array.size() + dwo_die_count -
		1; // We have 2 CU die, but we want to count it only as one
		}

		void DWARFUnit::AddUnitDIE(DWARFDebugInfoEntry &die) {
		assert(m_die_array.empty() && "Compile unit DIE already added");

		// The average bytes per DIE entry has been seen to be around 14-20 so lets
		// pre-reserve half of that since we are now stripping the NULL tags.

		// Only reserve the memory if we are adding children of the main compile unit
		// DIE. The compile unit DIE is always the first entry, so if our size is 1,
		// then we are adding the first compile unit child DIE and should reserve
		// the memory.
		m_die_array.reserve(GetDebugInfoSize() / 24);
		m_die_array.push_back(die);

		const DWARFDebugInfoEntry &cu_die = m_die_array.front();
		std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
		m_dwarf->GetDwoSymbolFileForCompileUnit(*this, cu_die);
		if (!dwo_symbol_file)
		return;

		DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
		if (!dwo_cu)
		return; // Can't fetch the compile unit from the dwo file.

		DWARFDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
		if (!dwo_cu_die.IsValid())
		return; // Can't fetch the compile unit DIE from the dwo file.

		uint64_t main_dwo_id =
		cu_die.GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_GNU_dwo_id, 0);
		uint64_t sub_dwo_id =
		dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0);
		if (main_dwo_id != sub_dwo_id)
		return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to
		// a differectn compilation.

		m_dwo_symbol_file = std::move(dwo_symbol_file);

		dw_addr_t addr_base =
		cu_die.GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_GNU_addr_base, 0);
		dw_addr_t ranges_base = cu_die.GetAttributeValueAsUnsigned(
		m_dwarf, this, DW_AT_GNU_ranges_base, 0);
		dwo_cu->SetAddrBase(addr_base, ranges_base, m_offset);
}		}

DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {		DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {
return Data().LookupAddress(address);		if (DIE()) {
		const DWARFDebugAranges &func_aranges = GetFunctionAranges();

		// Re-check the aranges auto pointer contents in case it was created above
		if (!func_aranges.IsEmpty())
		return GetDIE(func_aranges.FindAddress(address));
		}
		return DWARFDIE();
}		}

size_t DWARFUnit::AppendDIEsWithTag(const dw_tag_t tag,		size_t DWARFUnit::AppendDIEsWithTag(const dw_tag_t tag,
DWARFDIECollection &dies,		DWARFDIECollection &dies,
uint32_t depth) const {		uint32_t depth) const {
return Data().AppendDIEsWithTag(tag, dies, depth);		size_t old_size = dies.Size();
		DWARFDebugInfoEntry::const_iterator pos;
		DWARFDebugInfoEntry::const_iterator end = m_die_array.end();
		for (pos = m_die_array.begin(); pos != end; ++pos) {
		if (pos->Tag() == tag)
		dies.Append(DWARFDIE(this, &(*pos)));
}		}

bool DWARFUnit::Verify(Stream *s) const {		// Return the number of DIEs added to the collection
return Data().Verify(s);		return dies.Size() - old_size;
}		}

void DWARFUnit::Dump(Stream *s) const {
Data().Dump(s);
}

lldb::user_id_t DWARFUnit::GetID() const {		lldb::user_id_t DWARFUnit::GetID() const {
return Data().GetID();		dw_offset_t local_id =
		m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset;
		if (m_dwarf)
		return DIERef(local_id, local_id).GetUID(m_dwarf);
		else
		return local_id;
}		}

uint32_t DWARFUnit::Size() const { return IsDWARF64() ? 23 : 11; }		uint32_t DWARFUnit::Size() const { return IsDWARF64() ? 23 : 11; }

dw_offset_t DWARFUnit::GetNextCompileUnitOffset() const {		dw_offset_t DWARFUnit::GetNextCompileUnitOffset() const {
return m_offset + (IsDWARF64() ? 12 : 4) + GetLength();		return m_offset + (IsDWARF64() ? 12 : 4) + GetLength();
}		}

size_t DWARFUnit::GetDebugInfoSize() const {		size_t DWARFUnit::GetDebugInfoSize() const {
return (IsDWARF64() ? 12 : 4) + GetLength() - Size();		return (IsDWARF64() ? 12 : 4) + GetLength() - Size();
}		}

uint32_t DWARFUnit::GetLength() const { return Data().m_length; }		uint32_t DWARFUnit::GetLength() const { return m_length; }
uint16_t DWARFUnit::GetVersion() const { return Data().m_version; }		uint16_t DWARFUnit::GetVersion() const { return m_version; }

const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const {		const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const {
return Data().m_abbrevs;		return m_abbrevs;
}		}

dw_offset_t DWARFUnit::GetAbbrevOffset() const {		dw_offset_t DWARFUnit::GetAbbrevOffset() const {
return Data().GetAbbrevOffset();		return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
}		}

uint8_t DWARFUnit::GetAddressByteSize() const { return Data().m_addr_size; }		uint8_t DWARFUnit::GetAddressByteSize() const { return m_addr_size; }

dw_addr_t DWARFUnit::GetBaseAddress() const { return Data().m_base_addr; }		dw_addr_t DWARFUnit::GetBaseAddress() const { return m_base_addr; }

dw_addr_t DWARFUnit::GetAddrBase() const { return Data().m_addr_base; }		dw_addr_t DWARFUnit::GetAddrBase() const { return m_addr_base; }

dw_addr_t DWARFUnit::GetRangesBase() const { return Data().m_ranges_base; }		dw_addr_t DWARFUnit::GetRangesBase() const { return m_ranges_base; }

void DWARFUnit::SetAddrBase(dw_addr_t addr_base,		void DWARFUnit::SetAddrBase(dw_addr_t addr_base,
dw_addr_t ranges_base,		dw_addr_t ranges_base,
dw_offset_t base_obj_offset) {		dw_offset_t base_obj_offset) {
Data().SetAddrBase(addr_base, ranges_base, base_obj_offset);		m_addr_base = addr_base;
		m_ranges_base = ranges_base;
		m_base_obj_offset = base_obj_offset;
}		}

void DWARFUnit::ClearDIEs(bool keep_compile_unit_die) {		void DWARFUnit::ClearDIEs(bool keep_compile_unit_die) {
Data().ClearDIEs(keep_compile_unit_die);		if (m_die_array.size() > 1) {
		// std::vectors never get any smaller when resized to a smaller size,
		// or when clear() or erase() are called, the size will report that it
		// is smaller, but the memory allocated remains intact (call capacity()
		// to see this). So we need to create a temporary vector and swap the
		// contents which will cause just the internal pointers to be swapped
		// so that when "tmp_array" goes out of scope, it will destroy the
		// contents.

		// Save at least the compile unit DIE
		DWARFDebugInfoEntry::collection tmp_array;
		m_die_array.swap(tmp_array);
		if (keep_compile_unit_die)
		m_die_array.push_back(tmp_array.front());
		}

		if (m_dwo_symbol_file)
		m_dwo_symbol_file->GetCompileUnit()->ClearDIEs(keep_compile_unit_die);
}		}

void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,		void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
DWARFDebugAranges *debug_aranges) {		DWARFDebugAranges *debug_aranges) {
Data().BuildAddressRangeTable(dwarf2Data, debug_aranges);		// This function is usually called if there in no .debug_aranges section
		// in order to produce a compile unit level set of address ranges that
		// is accurate.

		size_t num_debug_aranges = debug_aranges->GetNumRanges();

		// First get the compile unit DIE only and check if it has a DW_AT_ranges
		const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();

		const dw_offset_t cu_offset = GetOffset();
		if (die) {
		DWARFRangeList ranges;
		const size_t num_ranges =
		die->GetAttributeAddressRanges(dwarf, this, ranges, false);
		if (num_ranges > 0) {
		// This compile unit has DW_AT_ranges, assume this is correct if it
		// is present since clang no longer makes .debug_aranges by default
		// and it emits DW_AT_ranges for DW_TAG_compile_units. GCC also does
		// this with recent GCC builds.
		for (size_t i = 0; i < num_ranges; ++i) {
		const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
		debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
		range.GetRangeEnd());
		}

		return; // We got all of our ranges from the DW_AT_ranges attribute
		}
		}
		// We don't have a DW_AT_ranges attribute, so we need to parse the DWARF

		// If the DIEs weren't parsed, then we don't want all dies for all compile
		// units
		// to stay loaded when they weren't needed. So we can end up parsing the DWARF
		// and then throwing them all away to keep memory usage down.
		const bool clear_dies = ExtractDIEsIfNeeded(false) > 1;

		die = DIEPtr();
		if (die)
		die->BuildAddressRangeTable(dwarf, this, debug_aranges);

		if (debug_aranges->GetNumRanges() == num_debug_aranges) {
		// We got nothing from the functions, maybe we have a line tables only
		// situation. Check the line tables and build the arange table from this.
		SymbolContext sc;
		sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
		if (sc.comp_unit) {
		SymbolFileDWARFDebugMap *debug_map_sym_file =
		m_dwarf->GetDebugMapSymfile();
		if (debug_map_sym_file == NULL) {
		LineTable *line_table = sc.comp_unit->GetLineTable();

		if (line_table) {
		LineTable::FileAddressRanges file_ranges;
		const bool append = true;
		const size_t num_ranges =
		line_table->GetContiguousFileAddressRanges(file_ranges, append);
		for (uint32_t idx = 0; idx < num_ranges; ++idx) {
		const LineTable::FileAddressRanges::Entry &range =
		file_ranges.GetEntryRef(idx);
		debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
		range.GetRangeEnd());
		}
		}
		} else
		debug_map_sym_file->AddOSOARanges(dwarf, debug_aranges);
		}
		}

		if (debug_aranges->GetNumRanges() == num_debug_aranges) {
		// We got nothing from the functions, maybe we have a line tables only
		// situation. Check the line tables and build the arange table from this.
		SymbolContext sc;
		sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
		if (sc.comp_unit) {
		LineTable *line_table = sc.comp_unit->GetLineTable();

		if (line_table) {
		LineTable::FileAddressRanges file_ranges;
		const bool append = true;
		const size_t num_ranges =
		line_table->GetContiguousFileAddressRanges(file_ranges, append);
		for (uint32_t idx = 0; idx < num_ranges; ++idx) {
		const LineTable::FileAddressRanges::Entry &range =
		file_ranges.GetEntryRef(idx);
		debug_aranges->AppendRange(GetOffset(), range.GetRangeBase(),
		range.GetRangeEnd());
		}
		}
		}
		}

		// Keep memory down by clearing DIEs if this generate function
		// caused them to be parsed
		if (clear_dies)
		ClearDIEs(true);
}		}

lldb::ByteOrder DWARFUnit::GetByteOrder() const {		lldb::ByteOrder DWARFUnit::GetByteOrder() const {
return Data().m_dwarf2Data->GetObjectFile()->GetByteOrder();		return m_dwarf->GetObjectFile()->GetByteOrder();
}		}

TypeSystem *DWARFUnit::GetTypeSystem() {		TypeSystem *DWARFUnit::GetTypeSystem() {
return Data().GetTypeSystem();		if (m_dwarf)
		return m_dwarf->GetTypeSystemForLanguage(GetLanguageType());
		else
		return nullptr;
}		}

DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() {		DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() {
return DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),		return DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
IsDWARF64());		IsDWARF64());
}		}

void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) {		void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; }
Data().m_base_addr = base_addr;
}

DWARFDIE DWARFUnit::GetCompileUnitDIEOnly() {
return Data().GetCompileUnitDIEOnly();
}

DWARFDIE DWARFUnit::DIE() {
return Data().DIE();
}

bool DWARFUnit::HasDIEsParsed() const { return Data().m_die_array.size() > 1; }		bool DWARFUnit::HasDIEsParsed() const { return m_die_array.size() > 1; }

//----------------------------------------------------------------------		//----------------------------------------------------------------------
// Compare function DWARFDebugAranges::Range structures		// Compare function DWARFDebugAranges::Range structures
//----------------------------------------------------------------------		//----------------------------------------------------------------------
static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,		static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,
const dw_offset_t die_offset) {		const dw_offset_t die_offset) {
return die.GetOffset() < die_offset;		return die.GetOffset() < die_offset;
}		}
Show All 9 Lines
DWARFDIE		DWARFDIE
DWARFUnit::GetDIE(dw_offset_t die_offset) {		DWARFUnit::GetDIE(dw_offset_t die_offset) {
if (die_offset != DW_INVALID_OFFSET) {		if (die_offset != DW_INVALID_OFFSET) {
if (GetDwoSymbolFile())		if (GetDwoSymbolFile())
return GetDwoSymbolFile()->GetCompileUnit()->GetDIE(die_offset);		return GetDwoSymbolFile()->GetCompileUnit()->GetDIE(die_offset);

if (ContainsDIEOffset(die_offset)) {		if (ContainsDIEOffset(die_offset)) {
ExtractDIEsIfNeeded(false);		ExtractDIEsIfNeeded(false);
DWARFDebugInfoEntry::iterator end = Data().m_die_array.end();		DWARFDebugInfoEntry::iterator end = m_die_array.end();
DWARFDebugInfoEntry::iterator pos = lower_bound(		DWARFDebugInfoEntry::iterator pos =
Data().m_die_array.begin(), end, die_offset, CompareDIEOffset);		lower_bound(m_die_array.begin(), end, die_offset, CompareDIEOffset);
if (pos != end) {		if (pos != end) {
if (die_offset == (*pos).GetOffset())		if (die_offset == (*pos).GetOffset())
return DWARFDIE(this, &(*pos));		return DWARFDIE(this, &(*pos));
}		}
} else {		} else {
// Don't specify the compile unit offset as we don't know it because the		// Don't specify the compile unit offset as we don't know it because the
// DIE belongs to		// DIE belongs to
// a different compile unit in the same symbol file.		// a different compile unit in the same symbol file.
return Data().m_dwarf2Data->DebugInfo()->GetDIEForDIEOffset(die_offset);		return m_dwarf->DebugInfo()->GetDIEForDIEOffset(die_offset);
}		}
}		}
return DWARFDIE(); // Not found		return DWARFDIE(); // Not found
}		}

static uint8_t g_default_addr_size = 4;

uint8_t DWARFUnit::GetAddressByteSize(const DWARFUnit *cu) {		uint8_t DWARFUnit::GetAddressByteSize(const DWARFUnit *cu) {
if (cu)		if (cu)
return cu->GetAddressByteSize();		return cu->GetAddressByteSize();
return DWARFCompileUnit::GetDefaultAddressSize();		return DWARFUnit::GetDefaultAddressSize();
}		}

bool DWARFUnit::IsDWARF64(const DWARFUnit *cu) {		bool DWARFUnit::IsDWARF64(const DWARFUnit *cu) {
if (cu)		if (cu)
return cu->IsDWARF64();		return cu->IsDWARF64();
return false;		return false;
}		}

uint8_t DWARFUnit::GetDefaultAddressSize() {		uint8_t DWARFUnit::GetDefaultAddressSize() { return 4; }
return g_default_addr_size;
}

void DWARFUnit::SetDefaultAddressSize(uint8_t addr_size) {
g_default_addr_size = addr_size;
}

void *DWARFUnit::GetUserData() const { return Data().m_user_data; }		void *DWARFUnit::GetUserData() const { return m_user_data; }

void DWARFUnit::SetUserData(void *d) {		void DWARFUnit::SetUserData(void *d) {
Data().SetUserData(d);		m_user_data = d;
		if (m_dwo_symbol_file)
		m_dwo_symbol_file->GetCompileUnit()->SetUserData(d);
}		}

bool DWARFUnit::Supports_DW_AT_APPLE_objc_complete_type() {		bool DWARFUnit::Supports_DW_AT_APPLE_objc_complete_type() {
if (GetProducer() == eProducerLLVMGCC)		if (GetProducer() == eProducerLLVMGCC)
return false;		return false;
return true;		return true;
}		}

Show All 11 Lines	if (major_version > 425 \|\|
return true;		return true;
else		else
return false;		return false;
}		}
return true; // Assume all other compilers didn't have incorrect ObjC bitfield		return true; // Assume all other compilers didn't have incorrect ObjC bitfield
// info		// info
}		}

SymbolFileDWARF *DWARFUnit::GetSymbolFileDWARF() const {		SymbolFileDWARF *DWARFUnit::GetSymbolFileDWARF() const { return m_dwarf; }
return Data().m_dwarf2Data;
		void DWARFUnit::ParseProducerInfo() {
		m_producer_version_major = UINT32_MAX;
		m_producer_version_minor = UINT32_MAX;
		m_producer_version_update = UINT32_MAX;

		const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
		if (die) {

		const char *producer_cstr =
		die->GetAttributeValueAsString(m_dwarf, this, DW_AT_producer, NULL);
		if (producer_cstr) {
		RegularExpression llvm_gcc_regex(
		llvm::StringRef("^4\\.[012]\\.[01] \\(Based on Apple "
		"Inc\\. build [0-9]+\\) \\(LLVM build "
		"[\\.0-9]+\\)$"));
		if (llvm_gcc_regex.Execute(llvm::StringRef(producer_cstr))) {
		m_producer = eProducerLLVMGCC;
		} else if (strstr(producer_cstr, "clang")) {
		static RegularExpression g_clang_version_regex(
		llvm::StringRef("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)"));
		RegularExpression::Match regex_match(3);
		if (g_clang_version_regex.Execute(llvm::StringRef(producer_cstr),
		&regex_match)) {
		std::string str;
		if (regex_match.GetMatchAtIndex(producer_cstr, 1, str))
		m_producer_version_major =
		StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
		if (regex_match.GetMatchAtIndex(producer_cstr, 2, str))
		m_producer_version_minor =
		StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
		if (regex_match.GetMatchAtIndex(producer_cstr, 3, str))
		m_producer_version_update =
		StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
		}
		m_producer = eProducerClang;
		} else if (strstr(producer_cstr, "GNU"))
		m_producer = eProducerGCC;
		}
		}
		if (m_producer == eProducerInvalid)
		m_producer = eProcucerOther;
}		}

DWARFProducer DWARFUnit::GetProducer() {		DWARFProducer DWARFUnit::GetProducer() {
return Data().GetProducer();		if (m_producer == eProducerInvalid)
		ParseProducerInfo();
		return m_producer;
}		}

uint32_t DWARFUnit::GetProducerVersionMajor() {		uint32_t DWARFUnit::GetProducerVersionMajor() {
return Data().GetProducerVersionMajor();		if (m_producer_version_major == 0)
		ParseProducerInfo();
		return m_producer_version_major;
}		}

uint32_t DWARFUnit::GetProducerVersionMinor() {		uint32_t DWARFUnit::GetProducerVersionMinor() {
return Data().GetProducerVersionMinor();		if (m_producer_version_minor == 0)
		ParseProducerInfo();
		return m_producer_version_minor;
}		}

uint32_t DWARFUnit::GetProducerVersionUpdate() {		uint32_t DWARFUnit::GetProducerVersionUpdate() {
return Data().GetProducerVersionUpdate();		if (m_producer_version_update == 0)
		ParseProducerInfo();
		return m_producer_version_update;
}		}

LanguageType DWARFUnit::LanguageTypeFromDWARF(uint64_t val) {		LanguageType DWARFUnit::LanguageTypeFromDWARF(uint64_t val) {
// Note: user languages between lo_user and hi_user		// Note: user languages between lo_user and hi_user
// must be handled explicitly here.		// must be handled explicitly here.
switch (val) {		switch (val) {
case DW_LANG_Mips_Assembler:		case DW_LANG_Mips_Assembler:
return eLanguageTypeMipsAssembler;		return eLanguageTypeMipsAssembler;
case DW_LANG_GOOGLE_RenderScript:		case DW_LANG_GOOGLE_RenderScript:
return eLanguageTypeExtRenderScript;		return eLanguageTypeExtRenderScript;
default:		default:
return static_cast<LanguageType>(val);		return static_cast<LanguageType>(val);
}		}
}		}

LanguageType DWARFUnit::GetLanguageType() {		LanguageType DWARFUnit::GetLanguageType() {
return Data().GetLanguageType();		if (m_language_type != eLanguageTypeUnknown)
		return m_language_type;

		const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
		if (die)
		m_language_type = LanguageTypeFromDWARF(
		die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_language, 0));
		return m_language_type;
}		}

bool DWARFUnit::IsDWARF64() const { return Data().m_is_dwarf64; }		bool DWARFUnit::IsDWARF64() const { return m_is_dwarf64; }

bool DWARFUnit::GetIsOptimized() {		bool DWARFUnit::GetIsOptimized() {
return Data().GetIsOptimized();		if (m_is_optimized == eLazyBoolCalculate) {
		const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
		if (die) {
		m_is_optimized = eLazyBoolNo;
		if (die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_APPLE_optimized,
		0) == 1) {
		m_is_optimized = eLazyBoolYes;
}		}

SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
return Data().m_dwo_symbol_file.get();
}		}

dw_offset_t DWARFUnit::GetBaseObjOffset() const {
return Data().m_base_obj_offset;
}		}
		return m_is_optimized == eLazyBoolYes;
const DWARFDebugInfoEntry *DWARFUnit::GetCompileUnitDIEPtrOnly() {
return Data().GetCompileUnitDIEPtrOnly();
}		}

const DWARFDebugInfoEntry *DWARFUnit::DIEPtr() {		SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
return Data().DIEPtr();		return m_dwo_symbol_file.get();
}		}

void DWARFUnit::Index(NameToDIE &func_basenames,		dw_offset_t DWARFUnit::GetBaseObjOffset() const { return m_base_obj_offset; }
NameToDIE &func_fullnames, NameToDIE &func_methods,
NameToDIE &func_selectors,		void DWARFUnit::Index(NameToDIE &func_basenames, NameToDIE &func_fullnames,
NameToDIE &objc_class_selectors,		NameToDIE &func_methods, NameToDIE &func_selectors,
NameToDIE &globals, NameToDIE &types,		NameToDIE &objc_class_selectors, NameToDIE &globals,
NameToDIE &namespaces) {		NameToDIE &types, NameToDIE &namespaces) {
assert(!Data().m_dwarf2Data->GetBaseCompileUnit() &&		assert(!m_dwarf->GetBaseCompileUnit() &&
"DWARFUnit associated with .dwo or .dwp "		"DWARFUnit associated with .dwo or .dwp "
"should not be indexed directly");		"should not be indexed directly");

Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));		Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));

if (log) {		if (log) {
Data().m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage(		m_dwarf->GetObjectFile()->GetModule()->LogMessage(
log,		log, "DWARFUnit::Index() for compile unit at .debug_info[0x%8.8x]",
"DWARFUnit::Index() for compile unit at .debug_info[0x%8.8x]",
GetOffset());		GetOffset());
}		}

const LanguageType cu_language = GetLanguageType();		const LanguageType cu_language = GetLanguageType();
DWARFFormValue::FixedFormSizes fixed_form_sizes =		DWARFFormValue::FixedFormSizes fixed_form_sizes =
DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),		DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
IsDWARF64());		IsDWARF64());

Show All 13 Lines
void DWARFUnit::IndexPrivate(		void DWARFUnit::IndexPrivate(
DWARFUnit *dwarf_cu, const LanguageType cu_language,		DWARFUnit *dwarf_cu, const LanguageType cu_language,
const DWARFFormValue::FixedFormSizes &fixed_form_sizes,		const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
const dw_offset_t cu_offset, NameToDIE &func_basenames,		const dw_offset_t cu_offset, NameToDIE &func_basenames,
NameToDIE &func_fullnames, NameToDIE &func_methods,		NameToDIE &func_fullnames, NameToDIE &func_methods,
NameToDIE &func_selectors, NameToDIE &objc_class_selectors,		NameToDIE &func_selectors, NameToDIE &objc_class_selectors,
NameToDIE &globals, NameToDIE &types, NameToDIE &namespaces) {		NameToDIE &globals, NameToDIE &types, NameToDIE &namespaces) {
DWARFDebugInfoEntry::const_iterator pos;		DWARFDebugInfoEntry::const_iterator pos;
DWARFDebugInfoEntry::const_iterator begin =		DWARFDebugInfoEntry::const_iterator begin = dwarf_cu->m_die_array.begin();
dwarf_cu->Data().m_die_array.begin();		DWARFDebugInfoEntry::const_iterator end = dwarf_cu->m_die_array.end();
DWARFDebugInfoEntry::const_iterator end = dwarf_cu->Data().m_die_array.end();
for (pos = begin; pos != end; ++pos) {		for (pos = begin; pos != end; ++pos) {
const DWARFDebugInfoEntry &die = *pos;		const DWARFDebugInfoEntry &die = *pos;

const dw_tag_t tag = die.Tag();		const dw_tag_t tag = die.Tag();

switch (tag) {		switch (tag) {
case DW_TAG_array_type:		case DW_TAG_array_type:
case DW_TAG_base_type:		case DW_TAG_base_type:
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines	if (num_attributes > 0) {
if (tag == DW_TAG_variable) {		if (tag == DW_TAG_variable) {
const DWARFDebugInfoEntry *parent_die = die.GetParent();		const DWARFDebugInfoEntry *parent_die = die.GetParent();
while (parent_die != NULL) {		while (parent_die != NULL) {
switch (parent_die->Tag()) {		switch (parent_die->Tag()) {
case DW_TAG_subprogram:		case DW_TAG_subprogram:
case DW_TAG_lexical_block:		case DW_TAG_lexical_block:
case DW_TAG_inlined_subroutine:		case DW_TAG_inlined_subroutine:
// Even if this is a function level static, we don't add it. We		// Even if this is a function level static, we don't add it. We
// could theoretically		// could theoretically add these if we wanted to by
// add these if we wanted to by introspecting into the		// introspecting into the DW_AT_location and seeing if the
// DW_AT_location and seeing		// location describes a hard coded address, but we don't want
// if the location describes a hard coded address, but we dont		// the performance penalty of that right now.
// want the performance
// penalty of that right now.
is_global_or_static_variable = false;		is_global_or_static_variable = false;
// if		// if (attributes.ExtractFormValueAtIndex(dwarf, i,
// (attributes.ExtractFormValueAtIndex(dwarf2Data,		// form_value)) {
// i, form_value))		// // If we have valid block data, then we have location
// {		// // expression bytesthat are fixed (not a location list).
// // If we have valid block		// const uint8_t *block_data = form_value.BlockData();
// data, then we have location		// if (block_data) {
// expression bytes		// uint32_t block_length = form_value.Unsigned();
// // that are fixed (not a
// location list).
// const uint8_t *block_data =
// form_value.BlockData();
// if (block_data)
// {
// uint32_t block_length =
// form_value.Unsigned();
// if (block_length == 1 +		// if (block_length == 1 +
// attributes.CompileUnitAtIndex(i)->GetAddressByteSize())		// attributes.CompileUnitAtIndex(i)->GetAddressByteSize()) {
// {		// if (block_data[0] == DW_OP_addr)
// if (block_data[0] ==
// DW_OP_addr)
// add_die = true;		// add_die = true;
// }		// }
// }		// }
// }		// }
parent_die = NULL; // Terminate the while loop.		parent_die = NULL; // Terminate the while loop.
break;		break;

case DW_TAG_compile_unit:		case DW_TAG_compile_unit:
is_global_or_static_variable = true;		is_global_or_static_variable = true;
parent_die = NULL; // Terminate the while loop.		parent_die = NULL; // Terminate the while loop.
break;		break;

▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines	case DW_TAG_variable:
}		}
break;		break;

default:		default:
continue;		continue;
}		}
}		}
}		}

		const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() {
		if (m_func_aranges_ap.get() == NULL) {
		m_func_aranges_ap.reset(new DWARFDebugAranges());
		Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES));

		if (log) {
		m_dwarf->GetObjectFile()->GetModule()->LogMessage(
		log,
		"DWARFUnit::GetFunctionAranges() for compile unit at "
		".debug_info[0x%8.8x]",
		GetOffset());
		}
		const DWARFDebugInfoEntry *die = DIEPtr();
		if (die)
		die->BuildFunctionAddressRangeTable(m_dwarf, this,
		m_func_aranges_ap.get());

		if (m_dwo_symbol_file) {
		DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
		const DWARFDebugInfoEntry *dwo_die = dwo_cu->DIEPtr();
		if (dwo_die)
		dwo_die->BuildFunctionAddressRangeTable(m_dwo_symbol_file.get(), dwo_cu,
		m_func_aranges_ap.get());
		}

		const bool minimize = false;
		m_func_aranges_ap->Sort(minimize);
		}
		return *m_func_aranges_ap.get();
		}

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

	Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines

	class SymbolFileDWARF : public lldb_private::SymbolFile,			class SymbolFileDWARF : public lldb_private::SymbolFile,
	public lldb_private::UserID {			public lldb_private::UserID {
	public:			public:
	friend class SymbolFileDWARFDebugMap;			friend class SymbolFileDWARFDebugMap;
	friend class SymbolFileDWARFDwo;			friend class SymbolFileDWARFDwo;
	friend class DebugMapModule;			friend class DebugMapModule;
	friend struct DIERef;			friend struct DIERef;
	friend class DWARFCompileUnit;			friend class DWARFUnit;
	friend class DWARFDIE;			friend class DWARFDIE;
	friend class DWARFASTParserClang;			friend class DWARFASTParserClang;
	friend class DWARFASTParserGo;			friend class DWARFASTParserGo;
	friend class DWARFASTParserJava;			friend class DWARFASTParserJava;
	friend class DWARFASTParserOCaml;			friend class DWARFASTParserOCaml;

	//------------------------------------------------------------------			//------------------------------------------------------------------
	// Static Functions			// Static Functions
	▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 766 Lines • ▼ Show 20 Lines	if (comp_unit) {
cu_idx);		cu_idx);
} else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {		} else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
// Let the debug map create the compile unit		// Let the debug map create the compile unit
cu_sp = m_debug_map_symfile->GetCompileUnit(this);		cu_sp = m_debug_map_symfile->GetCompileUnit(this);
dwarf_cu->SetUserData(cu_sp.get());		dwarf_cu->SetUserData(cu_sp.get());
} else {		} else {
ModuleSP module_sp(m_obj_file->GetModule());		ModuleSP module_sp(m_obj_file->GetModule());
if (module_sp) {		if (module_sp) {
const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();		const DWARFDIE cu_die = dwarf_cu->GetUnitDIEOnly();
if (cu_die) {		if (cu_die) {
FileSpec cu_file_spec{cu_die.GetName(), false};		FileSpec cu_file_spec{cu_die.GetName(), false};
if (cu_file_spec) {		if (cu_file_spec) {
// If we have a full path to the compile unit, we don't need to		// If we have a full path to the compile unit, we don't need to
// resolve		// resolve
// the file. This can be expensive e.g. when the source files are		// the file. This can be expensive e.g. when the source files are
// NFS mounted.		// NFS mounted.
if (cu_file_spec.IsRelative()) {		if (cu_file_spec.IsRelative()) {
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines	size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
return functions_added;		return functions_added;
}		}

bool SymbolFileDWARF::ParseCompileUnitSupportFiles(		bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
const SymbolContext &sc, FileSpecList &support_files) {		const SymbolContext &sc, FileSpecList &support_files) {
assert(sc.comp_unit);		assert(sc.comp_unit);
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);		DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {		if (dwarf_cu) {
const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();		const DWARFDIE cu_die = dwarf_cu->GetUnitDIEOnly();

if (cu_die) {		if (cu_die) {
const char *cu_comp_dir = resolveCompDir(		const char *cu_comp_dir = resolveCompDir(
cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));		cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(		const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
DW_AT_stmt_list, DW_INVALID_OFFSET);		DW_AT_stmt_list, DW_INVALID_OFFSET);
if (stmt_list != DW_INVALID_OFFSET) {		if (stmt_list != DW_INVALID_OFFSET) {
// All file indexes in DWARF are one based and a file of index zero is		// All file indexes in DWARF are one based and a file of index zero is
Show All 22 Lines	bool SymbolFileDWARF::ParseImportedModules(
assert(sc.comp_unit);		assert(sc.comp_unit);
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);		DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {		if (dwarf_cu) {
if (ClangModulesDeclVendor::LanguageSupportsClangModules(		if (ClangModulesDeclVendor::LanguageSupportsClangModules(
sc.comp_unit->GetLanguage())) {		sc.comp_unit->GetLanguage())) {
UpdateExternalModuleListIfNeeded();		UpdateExternalModuleListIfNeeded();

if (sc.comp_unit) {		if (sc.comp_unit) {
const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();		const DWARFDIE die = dwarf_cu->GetUnitDIEOnly();

if (die) {		if (die) {
for (DWARFDIE child_die = die.GetFirstChild(); child_die;		for (DWARFDIE child_die = die.GetFirstChild(); child_die;
child_die = child_die.GetSibling()) {		child_die = child_die.GetSibling()) {
if (child_die.Tag() == DW_TAG_imported_declaration) {		if (child_die.Tag() == DW_TAG_imported_declaration) {
if (DWARFDIE module_die =		if (DWARFDIE module_die =
child_die.GetReferencedDIE(DW_AT_import)) {		child_die.GetReferencedDIE(DW_AT_import)) {
if (module_die.Tag() == DW_TAG_module) {		if (module_die.Tag() == DW_TAG_module) {
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines

bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {		bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
assert(sc.comp_unit);		assert(sc.comp_unit);
if (sc.comp_unit->GetLineTable() != NULL)		if (sc.comp_unit->GetLineTable() != NULL)
return true;		return true;

DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);		DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {		if (dwarf_cu) {
const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();		const DWARFDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
if (dwarf_cu_die) {		if (dwarf_cu_die) {
const dw_offset_t cu_line_offset =		const dw_offset_t cu_line_offset =
dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,		dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
DW_INVALID_OFFSET);		DW_INVALID_OFFSET);
if (cu_line_offset != DW_INVALID_OFFSET) {		if (cu_line_offset != DW_INVALID_OFFSET) {
std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));		std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
if (line_table_ap.get()) {		if (line_table_ap.get()) {
ParseDWARFLineTableCallbackInfo info;		ParseDWARFLineTableCallbackInfo info;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines

bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {		bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
assert(sc.comp_unit);		assert(sc.comp_unit);

DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);		DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu == nullptr)		if (dwarf_cu == nullptr)
return false;		return false;

const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();		const DWARFDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
if (!dwarf_cu_die)		if (!dwarf_cu_die)
return false;		return false;

lldb::offset_t sect_offset =		lldb::offset_t sect_offset =
dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);		dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
if (sect_offset == DW_INVALID_OFFSET)		if (sect_offset == DW_INVALID_OFFSET)
sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,		sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
DW_INVALID_OFFSET);		DW_INVALID_OFFSET);
▲ Show 20 Lines • Show All 494 Lines • ▼ Show 20 Lines	void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
m_fetched_external_modules = true;		m_fetched_external_modules = true;

DWARFDebugInfo *debug_info = DebugInfo();		DWARFDebugInfo *debug_info = DebugInfo();

const uint32_t num_compile_units = GetNumCompileUnits();		const uint32_t num_compile_units = GetNumCompileUnits();
for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {		for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);		DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);

const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();		const DWARFDIE die = dwarf_cu->GetUnitDIEOnly();
if (die && die.HasChildren() == false) {		if (die && die.HasChildren() == false) {
const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);		const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);

if (name) {		if (name) {
ConstString const_name(name);		ConstString const_name(name);
if (m_external_type_modules.find(const_name) ==		if (m_external_type_modules.find(const_name) ==
m_external_type_modules.end()) {		m_external_type_modules.end()) {
ModuleSP module_sp;		ModuleSP module_sp;
▲ Show 20 Lines • Show All 2,736 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines	public:
uint32_t GetPluginVersion() override;		uint32_t GetPluginVersion() override;

protected:		protected:
enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };		enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };

friend class DebugMapModule;		friend class DebugMapModule;
friend struct DIERef;		friend struct DIERef;
friend class DWARFASTParserClang;		friend class DWARFASTParserClang;
friend class DWARFCompileUnit;		friend class DWARFUnit;
friend class SymbolFileDWARF;		friend class SymbolFileDWARF;
struct OSOInfo {		struct OSOInfo {
lldb::ModuleSP module_sp;		lldb::ModuleSP module_sp;

OSOInfo() : module_sp() {}		OSOInfo() : module_sp() {}
};		};

typedef std::shared_ptr<OSOInfo> OSOInfoSP;		typedef std::shared_ptr<OSOInfo> OSOInfoSP;
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines