caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a86ce06fafaa051554c6a21d487fa70e998dcafe
clang-p2996/lldb/source/Symbol/Function.cpp
Pavel Labath 0081149f96 [lldb/DWARF] Fix PC value for artificial tail call frames for the "GNU" case 
Summary:
The way that the support for the GNU dialect of tail call frames was
implemented in D80519 meant that the were reporting very bogus PC values
which pointed into the middle of an instruction: the -1 trick is
necessary for the address to resolve to the right function, but we
should still be reporting a more realistic PC value -- I say "realistic"
and not "real", because it's very debatable what should be the correct
PC value for frames like this.

This patch achieves that my moving the -1 from SymbolFileDWARF into the
stack frame computation code. The idea is that SymbolFileDWARF will
merely report whether it has provided an address of the instruction
after the tail call, or the address of the call instruction itself. The
StackFrameList machinery uses this information to set the "behaves like
frame zero" property of the artificial frames (the main thing this flag
does is it controls the -1 subtraction when looking up the function
address).

This required a moderate refactor of the CallEdge class, because it was
implicitly assuming that edges pointing after the call were real calls
and those pointing the the call insn were tail calls. The class now
carries this information explicitly -- it carries three mostly
independent pieces of information:
- an address of interest in the caller
- a bit saying whether this address points to the call insn or after it
- whether this is a tail call

Reviewers: vsk, dblaikie

Subscribers: aprantl, mgrang, lldb-commits

Tags: #lldb

Differential Revision: https://reviews.llvm.org/D81010
2020-06-08 14:44:36 +02:00

661 lines
22 KiB
C++
Raw Blame History

//===-- Function.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 "lldb/Symbol/Function.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/Section.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/Log.h"
#include "llvm/Support/Casting.h"
using namespace lldb;
using namespace lldb_private;
// Basic function information is contained in the FunctionInfo class. It is
// designed to contain the name, linkage name, and declaration location.
FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)
: m_name(name), m_declaration(decl_ptr) {}
FunctionInfo::FunctionInfo(ConstString name, const Declaration *decl_ptr)
: m_name(name), m_declaration(decl_ptr) {}
FunctionInfo::~FunctionInfo() {}
void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
if (m_name)
*s << ", name = \"" << m_name << "\"";
m_declaration.Dump(s, show_fullpaths);
}
int FunctionInfo::Compare(const FunctionInfo &a, const FunctionInfo &b) {
int result = ConstString::Compare(a.GetName(), b.GetName());
if (result)
return result;
return Declaration::Compare(a.m_declaration, b.m_declaration);
}
Declaration &FunctionInfo::GetDeclaration() { return m_declaration; }
const Declaration &FunctionInfo::GetDeclaration() const {
return m_declaration;
}
ConstString FunctionInfo::GetName() const { return m_name; }
size_t FunctionInfo::MemorySize() const {
return m_name.MemorySize() + m_declaration.MemorySize();
}
InlineFunctionInfo::InlineFunctionInfo(const char *name,
llvm::StringRef mangled,
const Declaration *decl_ptr,
const Declaration *call_decl_ptr)
: FunctionInfo(name, decl_ptr), m_mangled(mangled),
m_call_decl(call_decl_ptr) {}
InlineFunctionInfo::InlineFunctionInfo(ConstString name,
const Mangled &mangled,
const Declaration *decl_ptr,
const Declaration *call_decl_ptr)
: FunctionInfo(name, decl_ptr), m_mangled(mangled),
m_call_decl(call_decl_ptr) {}
InlineFunctionInfo::~InlineFunctionInfo() {}
void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
FunctionInfo::Dump(s, show_fullpaths);
if (m_mangled)
m_mangled.Dump(s);
}
void InlineFunctionInfo::DumpStopContext(Stream *s) const {
// s->Indent("[inlined] ");
s->Indent();
if (m_mangled)
s->PutCString(m_mangled.GetName().AsCString());
else
s->PutCString(m_name.AsCString());
}
ConstString InlineFunctionInfo::GetName() const {
if (m_mangled)
return m_mangled.GetName();
return m_name;
}
ConstString InlineFunctionInfo::GetDisplayName() const {
if (m_mangled)
return m_mangled.GetDisplayDemangledName();
return m_name;
}
Declaration &InlineFunctionInfo::GetCallSite() { return m_call_decl; }
const Declaration &InlineFunctionInfo::GetCallSite() const {
return m_call_decl;
}
Mangled &InlineFunctionInfo::GetMangled() { return m_mangled; }
const Mangled &InlineFunctionInfo::GetMangled() const { return m_mangled; }
size_t InlineFunctionInfo::MemorySize() const {
return FunctionInfo::MemorySize() + m_mangled.MemorySize();
}
/// @name Call site related structures
/// @{
lldb::addr_t CallEdge::GetLoadAddress(lldb::addr_t unresolved_pc,
Function &caller, Target &target) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
const Address &caller_start_addr = caller.GetAddressRange().GetBaseAddress();
ModuleSP caller_module_sp = caller_start_addr.GetModule();
if (!caller_module_sp) {
LLDB_LOG(log, "GetLoadAddress: cannot get Module for caller");
return LLDB_INVALID_ADDRESS;
}
SectionList *section_list = caller_module_sp->GetSectionList();
if (!section_list) {
LLDB_LOG(log, "GetLoadAddress: cannot get SectionList for Module");
return LLDB_INVALID_ADDRESS;
}
Address the_addr = Address(unresolved_pc, section_list);
lldb::addr_t load_addr = the_addr.GetLoadAddress(&target);
return load_addr;
}
lldb::addr_t CallEdge::GetReturnPCAddress(Function &caller,
Target &target) const {
return GetLoadAddress(GetUnresolvedReturnPCAddress(), caller, target);
}
void DirectCallEdge::ParseSymbolFileAndResolve(ModuleList &images) {
if (resolved)
return;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
LLDB_LOG(log, "DirectCallEdge: Lazily parsing the call graph for {0}",
lazy_callee.symbol_name);
auto resolve_lazy_callee = [&]() -> Function * {
ConstString callee_name{lazy_callee.symbol_name};
SymbolContextList sc_list;
images.FindFunctionSymbols(callee_name, eFunctionNameTypeAuto, sc_list);
size_t num_matches = sc_list.GetSize();
if (num_matches == 0 || !sc_list[0].symbol) {
LLDB_LOG(log,
"DirectCallEdge: Found no symbols for {0}, cannot resolve it",
callee_name);
return nullptr;
}
Address callee_addr = sc_list[0].symbol->GetAddress();
if (!callee_addr.IsValid()) {
LLDB_LOG(log, "DirectCallEdge: Invalid symbol address");
return nullptr;
}
Function *f = callee_addr.CalculateSymbolContextFunction();
if (!f) {
LLDB_LOG(log, "DirectCallEdge: Could not find complete function");
return nullptr;
}
return f;
};
lazy_callee.def = resolve_lazy_callee();
resolved = true;
}
Function *DirectCallEdge::GetCallee(ModuleList &images, ExecutionContext &) {
ParseSymbolFileAndResolve(images);
assert(resolved && "Did not resolve lazy callee");
return lazy_callee.def;
}
Function *IndirectCallEdge::GetCallee(ModuleList &images,
ExecutionContext &exe_ctx) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
Status error;
Value callee_addr_val;
if (!call_target.Evaluate(&exe_ctx, exe_ctx.GetRegisterContext(),
/*loclist_base_addr=*/LLDB_INVALID_ADDRESS,
/*initial_value_ptr=*/nullptr,
/*object_address_ptr=*/nullptr, callee_addr_val,
&error)) {
LLDB_LOGF(log, "IndirectCallEdge: Could not evaluate expression: %s",
error.AsCString());
return nullptr;
}
addr_t raw_addr = callee_addr_val.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
if (raw_addr == LLDB_INVALID_ADDRESS) {
LLDB_LOG(log, "IndirectCallEdge: Could not extract address from scalar");
return nullptr;
}
Address callee_addr;
if (!exe_ctx.GetTargetPtr()->ResolveLoadAddress(raw_addr, callee_addr)) {
LLDB_LOG(log, "IndirectCallEdge: Could not resolve callee's load address");
return nullptr;
}
Function *f = callee_addr.CalculateSymbolContextFunction();
if (!f) {
LLDB_LOG(log, "IndirectCallEdge: Could not find complete function");
return nullptr;
}
return f;
}
/// @}
//
Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
lldb::user_id_t type_uid, const Mangled &mangled, Type *type,
const AddressRange &range)
: UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),
m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range),
m_frame_base(), m_flags(), m_prologue_byte_size(0) {
m_block.SetParentScope(this);
assert(comp_unit != nullptr);
}
Function::~Function() {}
void Function::GetStartLineSourceInfo(FileSpec &source_file,
uint32_t &line_no) {
line_no = 0;
source_file.Clear();
if (m_comp_unit == nullptr)
return;
// Initialize m_type if it hasn't been initialized already
GetType();
if (m_type != nullptr && m_type->GetDeclaration().GetLine() != 0) {
source_file = m_type->GetDeclaration().GetFile();
line_no = m_type->GetDeclaration().GetLine();
} else {
LineTable *line_table = m_comp_unit->GetLineTable();
if (line_table == nullptr)
return;
LineEntry line_entry;
if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(),
line_entry, nullptr)) {
line_no = line_entry.line;
source_file = line_entry.file;
}
}
}
void Function::GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no) {
line_no = 0;
source_file.Clear();
// The -1 is kind of cheesy, but I want to get the last line entry for the
// given function, not the first entry of the next.
Address scratch_addr(GetAddressRange().GetBaseAddress());
scratch_addr.SetOffset(scratch_addr.GetOffset() +
GetAddressRange().GetByteSize() - 1);
LineTable *line_table = m_comp_unit->GetLineTable();
if (line_table == nullptr)
return;
LineEntry line_entry;
if (line_table->FindLineEntryByAddress(scratch_addr, line_entry, nullptr)) {
line_no = line_entry.line;
source_file = line_entry.file;
}
}
llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetCallEdges() {
if (m_call_edges_resolved)
return m_call_edges;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
LLDB_LOG(log, "GetCallEdges: Attempting to parse call site info for {0}",
GetDisplayName());
m_call_edges_resolved = true;
// Find the SymbolFile which provided this function's definition.
Block &block = GetBlock(/*can_create*/true);
SymbolFile *sym_file = block.GetSymbolFile();
if (!sym_file)
return llvm::None;
// Lazily read call site information from the SymbolFile.
m_call_edges = sym_file->ParseCallEdgesInFunction(GetID());
// Sort the call edges to speed up return_pc lookups.
llvm::sort(m_call_edges, [](const std::unique_ptr<CallEdge> &LHS,
const std::unique_ptr<CallEdge> &RHS) {
return LHS->GetSortKey() < RHS->GetSortKey();
});
return m_call_edges;
}
llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetTailCallingEdges() {
// Tail calling edges are sorted at the end of the list. Find them by dropping
// all non-tail-calls.
return GetCallEdges().drop_until(
[](const std::unique_ptr<CallEdge> &edge) { return edge->IsTailCall(); });
}
CallEdge *Function::GetCallEdgeForReturnAddress(addr_t return_pc,
Target &target) {
auto edges = GetCallEdges();
auto edge_it =
llvm::partition_point(edges, [&](const std::unique_ptr<CallEdge> &edge) {
return std::make_pair(edge->IsTailCall(),
edge->GetReturnPCAddress(*this, target)) <
std::make_pair(false, return_pc);
});
if (edge_it == edges.end() ||
edge_it->get()->GetReturnPCAddress(*this, target) != return_pc)
return nullptr;
return edge_it->get();
}
Block &Function::GetBlock(bool can_create) {
if (!m_block.BlockInfoHasBeenParsed() && can_create) {
ModuleSP module_sp = CalculateSymbolContextModule();
if (module_sp) {
module_sp->GetSymbolFile()->ParseBlocksRecursive(*this);
} else {
Host::SystemLog(Host::eSystemLogError,
"error: unable to find module "
"shared pointer for function '%s' "
"in %s\n",
GetName().GetCString(),
m_comp_unit->GetPrimaryFile().GetPath().c_str());
}
m_block.SetBlockInfoHasBeenParsed(true, true);
}
return m_block;
}
CompileUnit *Function::GetCompileUnit() { return m_comp_unit; }
const CompileUnit *Function::GetCompileUnit() const { return m_comp_unit; }
void Function::GetDescription(Stream *s, lldb::DescriptionLevel level,
Target *target) {
ConstString name = GetName();
ConstString mangled = m_mangled.GetMangledName();
*s << "id = " << (const UserID &)*this;
if (name)
s->AsRawOstream() << ", name = \"" << name << '"';
if (mangled)
s->AsRawOstream() << ", mangled = \"" << mangled << '"';
*s << ", range = ";
Address::DumpStyle fallback_style;
if (level == eDescriptionLevelVerbose)
fallback_style = Address::DumpStyleModuleWithFileAddress;
else
fallback_style = Address::DumpStyleFileAddress;
GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress,
fallback_style);
}
void Function::Dump(Stream *s, bool show_context) const {
s->Printf("%p: ", static_cast<const void *>(this));
s->Indent();
*s << "Function" << static_cast<const UserID &>(*this);
m_mangled.Dump(s);
if (m_type)
s->Printf(", type = %p", static_cast<void *>(m_type));
else if (m_type_uid != LLDB_INVALID_UID)
s->Printf(", type_uid = 0x%8.8" PRIx64, m_type_uid);
s->EOL();
// Dump the root object
if (m_block.BlockInfoHasBeenParsed())
m_block.Dump(s, m_range.GetBaseAddress().GetFileAddress(), INT_MAX,
show_context);
}
void Function::CalculateSymbolContext(SymbolContext *sc) {
sc->function = this;
m_comp_unit->CalculateSymbolContext(sc);
}
ModuleSP Function::CalculateSymbolContextModule() {
SectionSP section_sp(m_range.GetBaseAddress().GetSection());
if (section_sp)
return section_sp->GetModule();
return this->GetCompileUnit()->GetModule();
}
CompileUnit *Function::CalculateSymbolContextCompileUnit() {
return this->GetCompileUnit();
}
Function *Function::CalculateSymbolContextFunction() { return this; }
lldb::DisassemblerSP Function::GetInstructions(const ExecutionContext &exe_ctx,
const char *flavor,
bool prefer_file_cache) {
ModuleSP module_sp(GetAddressRange().GetBaseAddress().GetModule());
if (module_sp && exe_ctx.HasTargetScope()) {
const bool prefer_file_cache = false;
return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
flavor, exe_ctx.GetTargetRef(),
GetAddressRange(), prefer_file_cache);
}
return lldb::DisassemblerSP();
}
bool Function::GetDisassembly(const ExecutionContext &exe_ctx,
const char *flavor, bool prefer_file_cache,
Stream &strm) {
lldb::DisassemblerSP disassembler_sp =
GetInstructions(exe_ctx, flavor, prefer_file_cache);
if (disassembler_sp) {
const bool show_address = true;
const bool show_bytes = false;
disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes,
&exe_ctx);
return true;
}
return false;
}
// Symbol *
// Function::CalculateSymbolContextSymbol ()
//{
// return // TODO: find the symbol for the function???
//}
void Function::DumpSymbolContext(Stream *s) {
m_comp_unit->DumpSymbolContext(s);
s->Printf(", Function{0x%8.8" PRIx64 "}", GetID());
}
size_t Function::MemorySize() const {
size_t mem_size = sizeof(Function) + m_block.MemorySize();
return mem_size;
}
bool Function::GetIsOptimized() {
bool result = false;
// Currently optimization is only indicted by the vendor extension
// DW_AT_APPLE_optimized which is set on a compile unit level.
if (m_comp_unit) {
result = m_comp_unit->GetIsOptimized();
}
return result;
}
bool Function::IsTopLevelFunction() {
bool result = false;
if (Language *language = Language::FindPlugin(GetLanguage()))
result = language->IsTopLevelFunction(*this);
return result;
}
ConstString Function::GetDisplayName() const {
return m_mangled.GetDisplayDemangledName();
}
CompilerDeclContext Function::GetDeclContext() {
ModuleSP module_sp = CalculateSymbolContextModule();
if (module_sp) {
if (SymbolFile *sym_file = module_sp->GetSymbolFile())
return sym_file->GetDeclContextForUID(GetID());
}
return CompilerDeclContext();
}
Type *Function::GetType() {
if (m_type == nullptr) {
SymbolContext sc;
CalculateSymbolContext(&sc);
if (!sc.module_sp)
return nullptr;
SymbolFile *sym_file = sc.module_sp->GetSymbolFile();
if (sym_file == nullptr)
return nullptr;
m_type = sym_file->ResolveTypeUID(m_type_uid);
}
return m_type;
}
const Type *Function::GetType() const { return m_type; }
CompilerType Function::GetCompilerType() {
Type *function_type = GetType();
if (function_type)
return function_type->GetFullCompilerType();
return CompilerType();
}
uint32_t Function::GetPrologueByteSize() {
if (m_prologue_byte_size == 0 &&
m_flags.IsClear(flagsCalculatedPrologueSize)) {
m_flags.Set(flagsCalculatedPrologueSize);
LineTable *line_table = m_comp_unit->GetLineTable();
uint32_t prologue_end_line_idx = 0;
if (line_table) {
LineEntry first_line_entry;
uint32_t first_line_entry_idx = UINT32_MAX;
if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(),
first_line_entry,
&first_line_entry_idx)) {
// Make sure the first line entry isn't already the end of the prologue
addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS;
addr_t line_zero_end_file_addr = LLDB_INVALID_ADDRESS;
if (first_line_entry.is_prologue_end) {
prologue_end_file_addr =
first_line_entry.range.GetBaseAddress().GetFileAddress();
prologue_end_line_idx = first_line_entry_idx;
} else {
// Check the first few instructions and look for one that has
// is_prologue_end set to true.
const uint32_t last_line_entry_idx = first_line_entry_idx + 6;
for (uint32_t idx = first_line_entry_idx + 1;
idx < last_line_entry_idx; ++idx) {
LineEntry line_entry;
if (line_table->GetLineEntryAtIndex(idx, line_entry)) {
if (line_entry.is_prologue_end) {
prologue_end_file_addr =
line_entry.range.GetBaseAddress().GetFileAddress();
prologue_end_line_idx = idx;
break;
}
}
}
}
// If we didn't find the end of the prologue in the line tables, then
// just use the end address of the first line table entry
if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {
// Check the first few instructions and look for one that has a line
// number that's different than the first entry.
uint32_t last_line_entry_idx = first_line_entry_idx + 6;
for (uint32_t idx = first_line_entry_idx + 1;
idx < last_line_entry_idx; ++idx) {
LineEntry line_entry;
if (line_table->GetLineEntryAtIndex(idx, line_entry)) {
if (line_entry.line != first_line_entry.line) {
prologue_end_file_addr =
line_entry.range.GetBaseAddress().GetFileAddress();
prologue_end_line_idx = idx;
break;
}
}
}
if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {
prologue_end_file_addr =
first_line_entry.range.GetBaseAddress().GetFileAddress() +
first_line_entry.range.GetByteSize();
prologue_end_line_idx = first_line_entry_idx;
}
}
const addr_t func_start_file_addr =
m_range.GetBaseAddress().GetFileAddress();
const addr_t func_end_file_addr =
func_start_file_addr + m_range.GetByteSize();
// Now calculate the offset to pass the subsequent line 0 entries.
uint32_t first_non_zero_line = prologue_end_line_idx;
while (true) {
LineEntry line_entry;
if (line_table->GetLineEntryAtIndex(first_non_zero_line,
line_entry)) {
if (line_entry.line != 0)
break;
}
if (line_entry.range.GetBaseAddress().GetFileAddress() >=
func_end_file_addr)
break;
first_non_zero_line++;
}
if (first_non_zero_line > prologue_end_line_idx) {
LineEntry first_non_zero_entry;
if (line_table->GetLineEntryAtIndex(first_non_zero_line,
first_non_zero_entry)) {
line_zero_end_file_addr =
first_non_zero_entry.range.GetBaseAddress().GetFileAddress();
}
}
// Verify that this prologue end file address in the function's address
// range just to be sure
if (func_start_file_addr < prologue_end_file_addr &&
prologue_end_file_addr < func_end_file_addr) {
m_prologue_byte_size = prologue_end_file_addr - func_start_file_addr;
}
if (prologue_end_file_addr < line_zero_end_file_addr &&
line_zero_end_file_addr < func_end_file_addr) {
m_prologue_byte_size +=
line_zero_end_file_addr - prologue_end_file_addr;
}
}
}
}
return m_prologue_byte_size;
}
lldb::LanguageType Function::GetLanguage() const {
lldb::LanguageType lang = m_mangled.GuessLanguage();
if (lang != lldb::eLanguageTypeUnknown)
return lang;
if (m_comp_unit)
return m_comp_unit->GetLanguage();
return lldb::eLanguageTypeUnknown;
}
ConstString Function::GetName() const {
return m_mangled.GetName();
}
ConstString Function::GetNameNoArguments() const {
return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
}
Reference in New Issue View Git Blame Copy Permalink