llvm-project/lldb/source/API/SBSymbolContext.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

272 lines
8.6 KiB
C++
Raw Normal View History

//===-- SBSymbolContext.cpp -------------------------------------*- C++ -*-===//
//
// 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/API/SBSymbolContext.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
using namespace lldb;
using namespace lldb_private;
SBSymbolContext::SBSymbolContext() : m_opaque_up() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
}
SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
(const lldb_private::SymbolContext *), sc_ptr);
if (sc_ptr)
m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
}
SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
SBSymbolContext::~SBSymbolContext() {}
const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return LLDB_RECORD_RESULT(*this);
}
void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
if (sc_ptr)
m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
else
m_opaque_up->Clear(true);
}
bool SBSymbolContext::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
return this->operator bool();
}
SBSymbolContext::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
return m_opaque_up != nullptr;
}
SBModule SBSymbolContext::GetModule() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
SBModule sb_module;
ModuleSP module_sp;
if (m_opaque_up) {
module_sp = m_opaque_up->module_sp;
sb_module.SetSP(module_sp);
}
return LLDB_RECORD_RESULT(sb_module);
}
SBCompileUnit SBSymbolContext::GetCompileUnit() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
GetCompileUnit);
return LLDB_RECORD_RESULT(
SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr));
}
SBFunction SBSymbolContext::GetFunction() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
Function *function = nullptr;
if (m_opaque_up)
function = m_opaque_up->function;
SBFunction sb_function(function);
return LLDB_RECORD_RESULT(sb_function);
}
SBBlock SBSymbolContext::GetBlock() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
return LLDB_RECORD_RESULT(
SBBlock(m_opaque_up ? m_opaque_up->block : nullptr));
}
SBLineEntry SBSymbolContext::GetLineEntry() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
SBLineEntry sb_line_entry;
if (m_opaque_up)
sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
return LLDB_RECORD_RESULT(sb_line_entry);
}
SBSymbol SBSymbolContext::GetSymbol() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
Symbol *symbol = nullptr;
if (m_opaque_up)
symbol = m_opaque_up->symbol;
SBSymbol sb_symbol(symbol);
return LLDB_RECORD_RESULT(sb_symbol);
}
void SBSymbolContext::SetModule(lldb::SBModule module) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
module);
ref().module_sp = module.GetSP();
}
void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
(lldb::SBCompileUnit), compile_unit);
ref().comp_unit = compile_unit.get();
}
void SBSymbolContext::SetFunction(lldb::SBFunction function) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
function);
ref().function = function.get();
}
void SBSymbolContext::SetBlock(lldb::SBBlock block) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
Removed all of the "#ifndef SWIG" from the SB header files since we are using interface (.i) files for each class. Changed the FindFunction class from: uint32_t SBTarget::FindFunctions (const char *name, uint32_t name_type_mask, bool append, lldb::SBSymbolContextList& sc_list) uint32_t SBModule::FindFunctions (const char *name, uint32_t name_type_mask, bool append, lldb::SBSymbolContextList& sc_list) To: lldb::SBSymbolContextList SBTarget::FindFunctions (const char *name, uint32_t name_type_mask = lldb::eFunctionNameTypeAny); lldb::SBSymbolContextList SBModule::FindFunctions (const char *name, uint32_t name_type_mask = lldb::eFunctionNameTypeAny); This makes the API easier to use from python. Also added the ability to append a SBSymbolContext or a SBSymbolContextList to a SBSymbolContextList. Exposed properties for lldb.SBSymbolContextList in python: lldb.SBSymbolContextList.modules => list() or all lldb.SBModule objects in the list lldb.SBSymbolContextList.compile_units => list() or all lldb.SBCompileUnits objects in the list lldb.SBSymbolContextList.functions => list() or all lldb.SBFunction objects in the list lldb.SBSymbolContextList.blocks => list() or all lldb.SBBlock objects in the list lldb.SBSymbolContextList.line_entries => list() or all lldb.SBLineEntry objects in the list lldb.SBSymbolContextList.symbols => list() or all lldb.SBSymbol objects in the list This allows a call to the SBTarget::FindFunctions(...) and SBModule::FindFunctions(...) and then the result can be used to extract the desired information: sc_list = lldb.target.FindFunctions("erase") for function in sc_list.functions: print function for symbol in sc_list.symbols: print symbol Exposed properties for the lldb.SBSymbolContext objects in python: lldb.SBSymbolContext.module => lldb.SBModule lldb.SBSymbolContext.compile_unit => lldb.SBCompileUnit lldb.SBSymbolContext.function => lldb.SBFunction lldb.SBSymbolContext.block => lldb.SBBlock lldb.SBSymbolContext.line_entry => lldb.SBLineEntry lldb.SBSymbolContext.symbol => lldb.SBSymbol Exposed properties for the lldb.SBBlock objects in python: lldb.SBBlock.parent => lldb.SBBlock for the parent block that contains lldb.SBBlock.sibling => lldb.SBBlock for the sibling block to the current block lldb.SBBlock.first_child => lldb.SBBlock for the first child block to the current block lldb.SBBlock.call_site => for inline functions, return a lldb.declaration object that gives the call site file, line and column lldb.SBBlock.name => for inline functions this is the name of the inline function that this block represents lldb.SBBlock.inlined_block => returns the inlined function block that contains this block (might return itself if the current block is an inlined block) lldb.SBBlock.range[int] => access the address ranges for a block by index, a list() with start and end address is returned lldb.SBBlock.ranges => an array or all address ranges for this block lldb.SBBlock.num_ranges => the number of address ranges for this blcok SBFunction objects can now get the SBType and the SBBlock that represents the top scope of the function. SBBlock objects can now get the variable list from the current block. The value list returned allows varaibles to be viewed prior with no process if code wants to check the variables in a function. There are two ways to get a variable list from a SBBlock: lldb::SBValueList SBBlock::GetVariables (lldb::SBFrame& frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic); lldb::SBValueList SBBlock::GetVariables (lldb::SBTarget& target, bool arguments, bool locals, bool statics); When a SBFrame is used, the values returned will be locked down to the frame and the values will be evaluated in the context of that frame. When a SBTarget is used, global an static variables can be viewed without a running process. llvm-svn: 149853
2012-02-06 09:44:54 +08:00
ref().block = block.GetPtr();
}
void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
line_entry);
if (line_entry.IsValid())
ref().line_entry = line_entry.ref();
else
ref().line_entry.Clear();
}
void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
symbol);
ref().symbol = symbol.get();
}
lldb_private::SymbolContext *SBSymbolContext::operator->() const {
return m_opaque_up.get();
}
const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
assert(m_opaque_up.get());
return *m_opaque_up;
}
lldb_private::SymbolContext &SBSymbolContext::operator*() {
if (m_opaque_up == nullptr)
m_opaque_up.reset(new SymbolContext);
return *m_opaque_up;
}
lldb_private::SymbolContext &SBSymbolContext::ref() {
if (m_opaque_up == nullptr)
m_opaque_up.reset(new SymbolContext);
return *m_opaque_up;
}
lldb_private::SymbolContext *SBSymbolContext::get() const {
return m_opaque_up.get();
}
bool SBSymbolContext::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
if (m_opaque_up) {
m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
} else
strm.PutCString("No value");
return true;
}
SBSymbolContext
SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
SBAddress &parent_frame_addr) const {
LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
GetParentOfInlinedScope,
(const lldb::SBAddress &, lldb::SBAddress &),
curr_frame_pc, parent_frame_addr);
SBSymbolContext sb_sc;
if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
parent_frame_addr.ref()))
return LLDB_RECORD_RESULT(sb_sc);
}
return LLDB_RECORD_RESULT(SBSymbolContext());
}
namespace lldb_private {
namespace repro {
template <>
void RegisterMethods<SBSymbolContext>(Registry &R) {
LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
(const lldb_private::SymbolContext *));
LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
LLDB_REGISTER_METHOD(
const lldb::SBSymbolContext &,
SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
());
LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
(lldb::SBCompileUnit));
LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
(lldb::SBFunction));
LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
(lldb::SBLineEntry));
LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
(lldb::SBStream &));
LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
GetParentOfInlinedScope,
(const lldb::SBAddress &, lldb::SBAddress &));
}
}
}