mirror of
https://github.com/intel/llvm.git
synced 2026-01-14 11:57:39 +08:00
5d088ba304
[lldb] Track CFA pointer metadata in StackID
In this commit:
9c8e716442 [lldb] Make StackID call Fix{Code,Data} pointers (#152796)
We made StackID keep track of the CFA without any pointer metadata in
it. This is necessary when comparing two StackIDs to determine which one
is "younger".
However, the CFA inside StackIDs is also used in other contexts through
the method StackID::GetCallFrameAddress. One notable case is
DWARFExpression: the computation of `DW_OP_call_frame_address` is done
using StackID. This feeds into many other places, e.g. expression
evaluation may require the address of a variable that is computed from
the CFA; to access the variable without faulting, we may need to
preserve the pointer metadata. As such, StackID must be able to provide
both versions of the CFA.
In the spirit of allowing consumers of pointers to decide what to do
with pointer metadata, this patch changes StackID to store both versions
of the cfa pointer. Two getter methods are provided, and all call sites
except DWARFExpression preserve their existing behavior (stripped
pointer). Other alternatives were considered:
* Just store the raw pointer. This would require changing the
comparisong operator `<` to also receive a Process, as the comparison
requires stripped pointers. It wasn't clear if all call-sites had a
non-null process, whereas we know we have a process when creating a
StackID.
* Store a weak pointer to the process inside the class, and then strip
metadata as needed. This would require a `weak_ptr::lock` in many
operations of LLDB, and it felt wasteful. It also prevents stripping
of the pointer if the process has gone away.
This patch also changes RegisterContextUnwind::ReadFrameAddress, which
is the method computing the CFA fed into StackID, to also preserve the
signature pointers.
110 lines
3.8 KiB
C++
110 lines
3.8 KiB
C++
//===-- StackID.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/Target/StackID.h"
|
|
#include "lldb/Symbol/Block.h"
|
|
#include "lldb/Symbol/Symbol.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
|
|
using namespace lldb_private;
|
|
|
|
StackID::StackID(lldb::addr_t pc, lldb::addr_t cfa,
|
|
SymbolContextScope *symbol_scope, Process *process)
|
|
: m_pc(pc), m_cfa(cfa), m_cfa_with_metadata(cfa),
|
|
m_symbol_scope(symbol_scope) {
|
|
if (process) {
|
|
m_pc = process->FixCodeAddress(m_pc);
|
|
m_cfa = process->FixDataAddress(m_cfa);
|
|
}
|
|
}
|
|
|
|
void StackID::SetPC(lldb::addr_t pc, Process *process) {
|
|
m_pc = process ? process->FixCodeAddress(pc) : pc;
|
|
}
|
|
|
|
void StackID::SetCFA(lldb::addr_t cfa, Process *process) {
|
|
m_cfa_with_metadata = cfa;
|
|
m_cfa = process ? process->FixDataAddress(cfa) : cfa;
|
|
}
|
|
|
|
void StackID::Dump(Stream *s) {
|
|
s->Printf("StackID (pc = 0x%16.16" PRIx64 ", cfa = 0x%16.16" PRIx64
|
|
", symbol_scope = %p",
|
|
m_pc, m_cfa, static_cast<void *>(m_symbol_scope));
|
|
if (m_symbol_scope) {
|
|
SymbolContext sc;
|
|
|
|
m_symbol_scope->CalculateSymbolContext(&sc);
|
|
if (sc.block)
|
|
s->Printf(" (Block {0x%8.8" PRIx64 "})", sc.block->GetID());
|
|
else if (sc.symbol)
|
|
s->Printf(" (Symbol{0x%8.8x})", sc.symbol->GetID());
|
|
}
|
|
s->PutCString(") ");
|
|
}
|
|
|
|
bool lldb_private::operator==(const StackID &lhs, const StackID &rhs) {
|
|
if (lhs.GetCallFrameAddressWithoutMetadata() !=
|
|
rhs.GetCallFrameAddressWithoutMetadata())
|
|
return false;
|
|
|
|
SymbolContextScope *lhs_scope = lhs.GetSymbolContextScope();
|
|
SymbolContextScope *rhs_scope = rhs.GetSymbolContextScope();
|
|
|
|
// Only compare the PC values if both symbol context scopes are nullptr
|
|
if (lhs_scope == nullptr && rhs_scope == nullptr)
|
|
return lhs.GetPC() == rhs.GetPC();
|
|
|
|
return lhs_scope == rhs_scope;
|
|
}
|
|
|
|
bool lldb_private::operator!=(const StackID &lhs, const StackID &rhs) {
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
bool lldb_private::operator<(const StackID &lhs, const StackID &rhs) {
|
|
const lldb::addr_t lhs_cfa = lhs.GetCallFrameAddressWithoutMetadata();
|
|
const lldb::addr_t rhs_cfa = rhs.GetCallFrameAddressWithoutMetadata();
|
|
|
|
// FIXME: We are assuming that the stacks grow downward in memory. That's not
|
|
// necessary, but true on
|
|
// all the machines we care about at present. If this changes, we'll have to
|
|
// deal with that. The ABI is the agent who knows this ordering, but the
|
|
// StackID has no access to the ABI. The most straightforward way to handle
|
|
// this is to add a "m_grows_downward" bool to the StackID, and set it in the
|
|
// constructor. But I'm not going to waste a bool per StackID on this till we
|
|
// need it.
|
|
|
|
if (lhs_cfa != rhs_cfa)
|
|
return lhs_cfa < rhs_cfa;
|
|
|
|
SymbolContextScope *lhs_scope = lhs.GetSymbolContextScope();
|
|
SymbolContextScope *rhs_scope = rhs.GetSymbolContextScope();
|
|
|
|
if (lhs_scope != nullptr && rhs_scope != nullptr) {
|
|
// Same exact scope, lhs is not less than (younger than rhs)
|
|
if (lhs_scope == rhs_scope)
|
|
return false;
|
|
|
|
SymbolContext lhs_sc;
|
|
SymbolContext rhs_sc;
|
|
lhs_scope->CalculateSymbolContext(&lhs_sc);
|
|
rhs_scope->CalculateSymbolContext(&rhs_sc);
|
|
|
|
// Items with the same function can only be compared
|
|
if (lhs_sc.function == rhs_sc.function && lhs_sc.function != nullptr &&
|
|
lhs_sc.block != nullptr && rhs_sc.function != nullptr &&
|
|
rhs_sc.block != nullptr) {
|
|
return rhs_sc.block->Contains(lhs_sc.block);
|
|
}
|
|
}
|
|
return false;
|
|
}
|