caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dda73336ad22bd0b5ecda17040c50fb10fcbe5fb
clang-p2996/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp
Chelsea Cassanova f1ef910b97 [lldb][Progress] Separate title and details (#77547) 
Per this RFC:
https://discourse.llvm.org/t/rfc-improve-lldb-progress-reporting/75717
on improving progress reports, this commit separates the title field and
details field so that the title specifies the category that the progress
report falls under. The details field is added as a part of the
constructor for progress reports and by default is an empty string. In addition, changes the total amount of progress completed into a std::optional. Also
updates the test to check for details being correctly reported from the
event structured data dictionary.
2024-01-16 07:57:18 -08:00

738 lines
26 KiB
C++
Raw Blame History

//===-- ManualDWARFIndex.cpp ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "Plugins/SymbolFile/DWARF/ManualDWARFIndex.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
#include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
#include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
#include "lldb/Core/DataFileCache.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/Progress.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Utility/DataEncoder.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/Timer.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/ThreadPool.h"
#include <optional>
using namespace lldb_private;
using namespace lldb;
using namespace lldb_private::dwarf;
using namespace lldb_private::plugin::dwarf;
void ManualDWARFIndex::Index() {
if (m_indexed)
return;
m_indexed = true;
ElapsedTime elapsed(m_index_time);
LLDB_SCOPED_TIMERF("%p", static_cast<void *>(m_dwarf));
if (LoadFromCache()) {
m_dwarf->SetDebugInfoIndexWasLoadedFromCache();
return;
}
DWARFDebugInfo &main_info = m_dwarf->DebugInfo();
SymbolFileDWARFDwo *dwp_dwarf = m_dwarf->GetDwpSymbolFile().get();
DWARFDebugInfo *dwp_info = dwp_dwarf ? &dwp_dwarf->DebugInfo() : nullptr;
std::vector<DWARFUnit *> units_to_index;
units_to_index.reserve(main_info.GetNumUnits() +
(dwp_info ? dwp_info->GetNumUnits() : 0));
// Process all units in the main file, as well as any type units in the dwp
// file. Type units in dwo files are handled when we reach the dwo file in
// IndexUnit.
for (size_t U = 0; U < main_info.GetNumUnits(); ++U) {
DWARFUnit *unit = main_info.GetUnitAtIndex(U);
if (unit && m_units_to_avoid.count(unit->GetOffset()) == 0)
units_to_index.push_back(unit);
}
if (dwp_info && dwp_info->ContainsTypeUnits()) {
for (size_t U = 0; U < dwp_info->GetNumUnits(); ++U) {
if (auto *tu = llvm::dyn_cast<DWARFTypeUnit>(dwp_info->GetUnitAtIndex(U)))
units_to_index.push_back(tu);
}
}
if (units_to_index.empty())
return;
StreamString module_desc;
m_module.GetDescription(module_desc.AsRawOstream(),
lldb::eDescriptionLevelBrief);
// Include 2 passes per unit to index for extracting DIEs from the unit and
// indexing the unit, and then 8 extra entries for finalizing each index set.
const uint64_t total_progress = units_to_index.size() * 2 + 8;
Progress progress("Manually indexing DWARF", module_desc.GetData(),
total_progress);
std::vector<IndexSet> sets(units_to_index.size());
// Keep memory down by clearing DIEs for any units if indexing
// caused us to load the unit's DIEs.
std::vector<std::optional<DWARFUnit::ScopedExtractDIEs>> clear_cu_dies(
units_to_index.size());
auto parser_fn = [&](size_t cu_idx) {
IndexUnit(*units_to_index[cu_idx], dwp_dwarf, sets[cu_idx]);
progress.Increment();
};
auto extract_fn = [&](size_t cu_idx) {
clear_cu_dies[cu_idx] = units_to_index[cu_idx]->ExtractDIEsScoped();
progress.Increment();
};
// Share one thread pool across operations to avoid the overhead of
// recreating the threads.
llvm::ThreadPoolTaskGroup task_group(Debugger::GetThreadPool());
// Create a task runner that extracts dies for each DWARF unit in a
// separate thread.
// First figure out which units didn't have their DIEs already
// parsed and remember this. If no DIEs were parsed prior to this index
// function call, we are going to want to clear the CU dies after we are
// done indexing to make sure we don't pull in all DWARF dies, but we need
// to wait until all units have been indexed in case a DIE in one
// unit refers to another and the indexes accesses those DIEs.
for (size_t i = 0; i < units_to_index.size(); ++i)
task_group.async(extract_fn, i);
task_group.wait();
// Now create a task runner that can index each DWARF unit in a
// separate thread so we can index quickly.
for (size_t i = 0; i < units_to_index.size(); ++i)
task_group.async(parser_fn, i);
task_group.wait();
auto finalize_fn = [this, &sets, &progress](NameToDIE(IndexSet::*index)) {
NameToDIE &result = m_set.*index;
for (auto &set : sets)
result.Append(set.*index);
result.Finalize();
progress.Increment();
};
task_group.async(finalize_fn, &IndexSet::function_basenames);
task_group.async(finalize_fn, &IndexSet::function_fullnames);
task_group.async(finalize_fn, &IndexSet::function_methods);
task_group.async(finalize_fn, &IndexSet::function_selectors);
task_group.async(finalize_fn, &IndexSet::objc_class_selectors);
task_group.async(finalize_fn, &IndexSet::globals);
task_group.async(finalize_fn, &IndexSet::types);
task_group.async(finalize_fn, &IndexSet::namespaces);
task_group.wait();
SaveToCache();
}
void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp,
IndexSet &set) {
Log *log = GetLog(DWARFLog::Lookups);
if (log) {
m_module.LogMessage(
log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[{0:x16}]",
unit.GetOffset());
}
const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
// First check if the unit has a DWO ID. If it does then we only want to index
// the .dwo file or nothing at all. If we have a compile unit where we can't
// locate the .dwo/.dwp file we don't want to index anything from the skeleton
// compile unit because it is usally has no children unless
// -fsplit-dwarf-inlining was used at compile time. This option will add a
// copy of all DW_TAG_subprogram and any contained DW_TAG_inline_subroutine
// DIEs so that symbolication will still work in the absence of the .dwo/.dwp
// file, but the functions have no return types and all arguments and locals
// have been removed. So we don't want to index any of these hacked up
// function types. Types can still exist in the skeleton compile unit DWARF
// though as some functions have template parameter types and other things
// that cause extra copies of types to be included, but we should find these
// types in the .dwo file only as methods could have return types removed and
// we don't have to index incomplete types from the skeleton compile unit.
if (unit.GetDWOId()) {
// Index the .dwo or dwp instead of the skeleton unit.
if (SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile()) {
// Type units in a dwp file are indexed separately, so we just need to
// process the split unit here. However, if the split unit is in a dwo
// file, then we need to process type units here.
if (dwo_symbol_file == dwp) {
IndexUnitImpl(unit.GetNonSkeletonUnit(), cu_language, set);
} else {
DWARFDebugInfo &dwo_info = dwo_symbol_file->DebugInfo();
for (size_t i = 0; i < dwo_info.GetNumUnits(); ++i)
IndexUnitImpl(*dwo_info.GetUnitAtIndex(i), cu_language, set);
}
return;
}
// This was a DWARF5 skeleton CU and the .dwo file couldn't be located.
if (unit.GetVersion() >= 5 && unit.IsSkeletonUnit())
return;
// Either this is a DWARF 4 + fission CU with the .dwo file
// missing, or it's a -gmodules pch or pcm. Try to detect the
// latter by checking whether the first DIE is a DW_TAG_module.
// If it's a pch/pcm, continue indexing it.
if (unit.GetDIE(unit.GetFirstDIEOffset()).GetFirstChild().Tag() !=
llvm::dwarf::DW_TAG_module)
return;
}
// We have a normal compile unit which we want to index.
IndexUnitImpl(unit, cu_language, set);
}
void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
const LanguageType cu_language,
IndexSet &set) {
for (const DWARFDebugInfoEntry &die : unit.dies()) {
const dw_tag_t tag = die.Tag();
switch (tag) {
case DW_TAG_array_type:
case DW_TAG_base_type:
case DW_TAG_class_type:
case DW_TAG_constant:
case DW_TAG_enumeration_type:
case DW_TAG_inlined_subroutine:
case DW_TAG_namespace:
case DW_TAG_imported_declaration:
case DW_TAG_string_type:
case DW_TAG_structure_type:
case DW_TAG_subprogram:
case DW_TAG_subroutine_type:
case DW_TAG_typedef:
case DW_TAG_union_type:
case DW_TAG_unspecified_type:
case DW_TAG_variable:
break;
default:
continue;
}
const char *name = nullptr;
const char *mangled_cstr = nullptr;
bool is_declaration = false;
bool has_address = false;
bool has_location_or_const_value = false;
bool is_global_or_static_variable = false;
DWARFFormValue specification_die_form;
DWARFAttributes attributes = die.GetAttributes(&unit);
for (size_t i = 0; i < attributes.Size(); ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value;
switch (attr) {
default:
break;
case DW_AT_name:
if (attributes.ExtractFormValueAtIndex(i, form_value))
name = form_value.AsCString();
break;
case DW_AT_declaration:
if (attributes.ExtractFormValueAtIndex(i, form_value))
is_declaration = form_value.Unsigned() != 0;
break;
case DW_AT_MIPS_linkage_name:
case DW_AT_linkage_name:
if (attributes.ExtractFormValueAtIndex(i, form_value))
mangled_cstr = form_value.AsCString();
break;
case DW_AT_low_pc:
case DW_AT_high_pc:
case DW_AT_ranges:
has_address = true;
break;
case DW_AT_entry_pc:
has_address = true;
break;
case DW_AT_location:
case DW_AT_const_value:
has_location_or_const_value = true;
is_global_or_static_variable = die.IsGlobalOrStaticScopeVariable();
break;
case DW_AT_specification:
if (attributes.ExtractFormValueAtIndex(i, form_value))
specification_die_form = form_value;
break;
}
}
DIERef ref = *DWARFDIE(&unit, &die).GetDIERef();
switch (tag) {
case DW_TAG_inlined_subroutine:
case DW_TAG_subprogram:
if (has_address) {
if (name) {
bool is_objc_method = false;
if (cu_language == eLanguageTypeObjC ||
cu_language == eLanguageTypeObjC_plus_plus) {
std::optional<const ObjCLanguage::MethodName> objc_method =
ObjCLanguage::MethodName::Create(name, true);
if (objc_method) {
is_objc_method = true;
ConstString class_name_with_category(
objc_method->GetClassNameWithCategory());
ConstString objc_selector_name(objc_method->GetSelector());
ConstString objc_fullname_no_category_name(
objc_method->GetFullNameWithoutCategory().c_str());
ConstString class_name_no_category(objc_method->GetClassName());
set.function_fullnames.Insert(ConstString(name), ref);
if (class_name_with_category)
set.objc_class_selectors.Insert(class_name_with_category, ref);
if (class_name_no_category &&
class_name_no_category != class_name_with_category)
set.objc_class_selectors.Insert(class_name_no_category, ref);
if (objc_selector_name)
set.function_selectors.Insert(objc_selector_name, ref);
if (objc_fullname_no_category_name)
set.function_fullnames.Insert(objc_fullname_no_category_name,
ref);
}
}
// If we have a mangled name, then the DW_AT_name attribute is
// usually the method name without the class or any parameters
bool is_method = DWARFDIE(&unit, &die).IsMethod();
if (is_method)
set.function_methods.Insert(ConstString(name), ref);
else
set.function_basenames.Insert(ConstString(name), ref);
if (!is_method && !mangled_cstr && !is_objc_method)
set.function_fullnames.Insert(ConstString(name), ref);
}
if (mangled_cstr) {
// Make sure our mangled name isn't the same string table entry as
// our name. If it starts with '_', then it is ok, else compare the
// string to make sure it isn't the same and we don't end up with
// duplicate entries
if (name && name != mangled_cstr &&
((mangled_cstr[0] == '_') ||
(::strcmp(name, mangled_cstr) != 0))) {
set.function_fullnames.Insert(ConstString(mangled_cstr), ref);
}
}
}
break;
case DW_TAG_array_type:
case DW_TAG_base_type:
case DW_TAG_class_type:
case DW_TAG_constant:
case DW_TAG_enumeration_type:
case DW_TAG_string_type:
case DW_TAG_structure_type:
case DW_TAG_subroutine_type:
case DW_TAG_typedef:
case DW_TAG_union_type:
case DW_TAG_unspecified_type:
if (name && !is_declaration)
set.types.Insert(ConstString(name), ref);
if (mangled_cstr && !is_declaration)
set.types.Insert(ConstString(mangled_cstr), ref);
break;
case DW_TAG_namespace:
case DW_TAG_imported_declaration:
if (name)
set.namespaces.Insert(ConstString(name), ref);
break;
case DW_TAG_variable:
if (name && has_location_or_const_value && is_global_or_static_variable) {
set.globals.Insert(ConstString(name), ref);
// Be sure to include variables by their mangled and demangled names if
// they have any since a variable can have a basename "i", a mangled
// named "_ZN12_GLOBAL__N_11iE" and a demangled mangled name
// "(anonymous namespace)::i"...
// Make sure our mangled name isn't the same string table entry as our
// name. If it starts with '_', then it is ok, else compare the string
// to make sure it isn't the same and we don't end up with duplicate
// entries
if (mangled_cstr && name != mangled_cstr &&
((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) {
set.globals.Insert(ConstString(mangled_cstr), ref);
}
}
break;
default:
continue;
}
}
}
void ManualDWARFIndex::GetGlobalVariables(
ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.globals.Find(basename,
DIERefCallback(callback, basename.GetStringRef()));
}
void ManualDWARFIndex::GetGlobalVariables(
const RegularExpression &regex,
llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.globals.Find(regex, DIERefCallback(callback, regex.GetText()));
}
void ManualDWARFIndex::GetGlobalVariables(
DWARFUnit &unit, llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.globals.FindAllEntriesForUnit(unit, DIERefCallback(callback));
}
void ManualDWARFIndex::GetObjCMethods(
ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.objc_class_selectors.Find(
class_name, DIERefCallback(callback, class_name.GetStringRef()));
}
void ManualDWARFIndex::GetCompleteObjCClass(
ConstString class_name, bool must_be_implementation,
llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.types.Find(class_name,
DIERefCallback(callback, class_name.GetStringRef()));
}
void ManualDWARFIndex::GetTypes(
ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.types.Find(name, DIERefCallback(callback, name.GetStringRef()));
}
void ManualDWARFIndex::GetTypes(
const DWARFDeclContext &context,
llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
auto name = context[0].name;
m_set.types.Find(ConstString(name),
DIERefCallback(callback, llvm::StringRef(name)));
}
void ManualDWARFIndex::GetNamespaces(
ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
m_set.namespaces.Find(name, DIERefCallback(callback, name.GetStringRef()));
}
void ManualDWARFIndex::GetFunctions(
const Module::LookupInfo &lookup_info, SymbolFileDWARF &dwarf,
const CompilerDeclContext &parent_decl_ctx,
llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
ConstString name = lookup_info.GetLookupName();
FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
if (name_type_mask & eFunctionNameTypeFull) {
if (!m_set.function_fullnames.Find(
name, DIERefCallback(
[&](DWARFDIE die) {
if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx,
die))
return true;
return callback(die);
},
name.GetStringRef())))
return;
}
if (name_type_mask & eFunctionNameTypeBase) {
if (!m_set.function_basenames.Find(
name, DIERefCallback(
[&](DWARFDIE die) {
if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx,
die))
return true;
return callback(die);
},
name.GetStringRef())))
return;
}
if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
if (!m_set.function_methods.Find(
name, DIERefCallback(callback, name.GetStringRef())))
return;
}
if (name_type_mask & eFunctionNameTypeSelector &&
!parent_decl_ctx.IsValid()) {
if (!m_set.function_selectors.Find(
name, DIERefCallback(callback, name.GetStringRef())))
return;
}
}
void ManualDWARFIndex::GetFunctions(
const RegularExpression &regex,
llvm::function_ref<bool(DWARFDIE die)> callback) {
Index();
if (!m_set.function_basenames.Find(regex,
DIERefCallback(callback, regex.GetText())))
return;
if (!m_set.function_fullnames.Find(regex,
DIERefCallback(callback, regex.GetText())))
return;
}
void ManualDWARFIndex::Dump(Stream &s) {
s.Format("Manual DWARF index for ({0}) '{1:F}':",
m_module.GetArchitecture().GetArchitectureName(),
m_module.GetObjectFile()->GetFileSpec());
s.Printf("\nFunction basenames:\n");
m_set.function_basenames.Dump(&s);
s.Printf("\nFunction fullnames:\n");
m_set.function_fullnames.Dump(&s);
s.Printf("\nFunction methods:\n");
m_set.function_methods.Dump(&s);
s.Printf("\nFunction selectors:\n");
m_set.function_selectors.Dump(&s);
s.Printf("\nObjective-C class selectors:\n");
m_set.objc_class_selectors.Dump(&s);
s.Printf("\nGlobals and statics:\n");
m_set.globals.Dump(&s);
s.Printf("\nTypes:\n");
m_set.types.Dump(&s);
s.Printf("\nNamespaces:\n");
m_set.namespaces.Dump(&s);
}
constexpr llvm::StringLiteral kIdentifierManualDWARFIndex("DIDX");
// Define IDs for the different tables when encoding and decoding the
// ManualDWARFIndex NameToDIE objects so we can avoid saving any empty maps.
enum DataID {
kDataIDFunctionBasenames = 1u,
kDataIDFunctionFullnames,
kDataIDFunctionMethods,
kDataIDFunctionSelectors,
kDataIDFunctionObjcClassSelectors,
kDataIDGlobals,
kDataIDTypes,
kDataIDNamespaces,
kDataIDEnd = 255u,
};
// Version 2 changes the encoding of DIERef objects used in the DWARF manual
// index name tables. See DIERef class for details.
constexpr uint32_t CURRENT_CACHE_VERSION = 2;
bool ManualDWARFIndex::IndexSet::Decode(const DataExtractor &data,
lldb::offset_t *offset_ptr) {
StringTableReader strtab;
// We now decode the string table for all strings in the data cache file.
if (!strtab.Decode(data, offset_ptr))
return false;
llvm::StringRef identifier((const char *)data.GetData(offset_ptr, 4), 4);
if (identifier != kIdentifierManualDWARFIndex)
return false;
const uint32_t version = data.GetU32(offset_ptr);
if (version != CURRENT_CACHE_VERSION)
return false;
bool done = false;
while (!done) {
switch (data.GetU8(offset_ptr)) {
default:
// If we got here, this is not expected, we expect the data IDs to match
// one of the values from the DataID enumeration.
return false;
case kDataIDFunctionBasenames:
if (!function_basenames.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDFunctionFullnames:
if (!function_fullnames.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDFunctionMethods:
if (!function_methods.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDFunctionSelectors:
if (!function_selectors.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDFunctionObjcClassSelectors:
if (!objc_class_selectors.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDGlobals:
if (!globals.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDTypes:
if (!types.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDNamespaces:
if (!namespaces.Decode(data, offset_ptr, strtab))
return false;
break;
case kDataIDEnd:
// We got to the end of our NameToDIE encodings.
done = true;
break;
}
}
// Success!
return true;
}
void ManualDWARFIndex::IndexSet::Encode(DataEncoder &encoder) const {
ConstStringTable strtab;
// Encoder the DWARF index into a separate encoder first. This allows us
// gather all of the strings we willl need in "strtab" as we will need to
// write the string table out before the symbol table.
DataEncoder index_encoder(encoder.GetByteOrder(),
encoder.GetAddressByteSize());
index_encoder.AppendData(kIdentifierManualDWARFIndex);
// Encode the data version.
index_encoder.AppendU32(CURRENT_CACHE_VERSION);
if (!function_basenames.IsEmpty()) {
index_encoder.AppendU8(kDataIDFunctionBasenames);
function_basenames.Encode(index_encoder, strtab);
}
if (!function_fullnames.IsEmpty()) {
index_encoder.AppendU8(kDataIDFunctionFullnames);
function_fullnames.Encode(index_encoder, strtab);
}
if (!function_methods.IsEmpty()) {
index_encoder.AppendU8(kDataIDFunctionMethods);
function_methods.Encode(index_encoder, strtab);
}
if (!function_selectors.IsEmpty()) {
index_encoder.AppendU8(kDataIDFunctionSelectors);
function_selectors.Encode(index_encoder, strtab);
}
if (!objc_class_selectors.IsEmpty()) {
index_encoder.AppendU8(kDataIDFunctionObjcClassSelectors);
objc_class_selectors.Encode(index_encoder, strtab);
}
if (!globals.IsEmpty()) {
index_encoder.AppendU8(kDataIDGlobals);
globals.Encode(index_encoder, strtab);
}
if (!types.IsEmpty()) {
index_encoder.AppendU8(kDataIDTypes);
types.Encode(index_encoder, strtab);
}
if (!namespaces.IsEmpty()) {
index_encoder.AppendU8(kDataIDNamespaces);
namespaces.Encode(index_encoder, strtab);
}
index_encoder.AppendU8(kDataIDEnd);
// Now that all strings have been gathered, we will emit the string table.
strtab.Encode(encoder);
// Followed by the symbol table data.
encoder.AppendData(index_encoder.GetData());
}
bool ManualDWARFIndex::Decode(const DataExtractor &data,
lldb::offset_t *offset_ptr,
bool &signature_mismatch) {
signature_mismatch = false;
CacheSignature signature;
if (!signature.Decode(data, offset_ptr))
return false;
if (CacheSignature(m_dwarf->GetObjectFile()) != signature) {
signature_mismatch = true;
return false;
}
IndexSet set;
if (!set.Decode(data, offset_ptr))
return false;
m_set = std::move(set);
return true;
}
bool ManualDWARFIndex::Encode(DataEncoder &encoder) const {
CacheSignature signature(m_dwarf->GetObjectFile());
if (!signature.Encode(encoder))
return false;
m_set.Encode(encoder);
return true;
}
std::string ManualDWARFIndex::GetCacheKey() {
std::string key;
llvm::raw_string_ostream strm(key);
// DWARF Index can come from different object files for the same module. A
// module can have one object file as the main executable and might have
// another object file in a separate symbol file, or we might have a .dwo file
// that claims its module is the main executable.
ObjectFile *objfile = m_dwarf->GetObjectFile();
strm << objfile->GetModule()->GetCacheKey() << "-dwarf-index-"
<< llvm::format_hex(objfile->GetCacheHash(), 10);
return strm.str();
}
bool ManualDWARFIndex::LoadFromCache() {
DataFileCache *cache = Module::GetIndexCache();
if (!cache)
return false;
ObjectFile *objfile = m_dwarf->GetObjectFile();
if (!objfile)
return false;
std::unique_ptr<llvm::MemoryBuffer> mem_buffer_up =
cache->GetCachedData(GetCacheKey());
if (!mem_buffer_up)
return false;
DataExtractor data(mem_buffer_up->getBufferStart(),
mem_buffer_up->getBufferSize(),
endian::InlHostByteOrder(),
objfile->GetAddressByteSize());
bool signature_mismatch = false;
lldb::offset_t offset = 0;
const bool result = Decode(data, &offset, signature_mismatch);
if (signature_mismatch)
cache->RemoveCacheFile(GetCacheKey());
return result;
}
void ManualDWARFIndex::SaveToCache() {
DataFileCache *cache = Module::GetIndexCache();
if (!cache)
return; // Caching is not enabled.
ObjectFile *objfile = m_dwarf->GetObjectFile();
if (!objfile)
return;
DataEncoder file(endian::InlHostByteOrder(), objfile->GetAddressByteSize());
// Encode will return false if the object file doesn't have anything to make
// a signature from.
if (Encode(file)) {
if (cache->SetCachedData(GetCacheKey(), file.GetData()))
m_dwarf->SetDebugInfoIndexWasSavedToCache();
}
}
Reference in New Issue View Git Blame Copy Permalink