2010-06-09 00:52:24 +08:00
|
|
|
//===-- SBFrame.cpp ---------------------------------------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
// C Includes
|
|
|
|
// C++ Includes
|
2010-06-09 00:52:24 +08:00
|
|
|
#include <algorithm>
|
2016-04-30 05:00:38 +08:00
|
|
|
#include <set>
|
2015-10-31 09:22:59 +08:00
|
|
|
#include <string>
|
|
|
|
|
|
|
|
// Other libraries and framework includes
|
|
|
|
// Project includes
|
|
|
|
#include "lldb/API/SBFrame.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
#include "lldb/lldb-types.h"
|
|
|
|
|
|
|
|
#include "lldb/Core/Address.h"
|
|
|
|
#include "lldb/Core/ConstString.h"
|
2010-10-26 11:11:13 +08:00
|
|
|
#include "lldb/Core/Log.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Core/Stream.h"
|
|
|
|
#include "lldb/Core/StreamFile.h"
|
|
|
|
#include "lldb/Core/ValueObjectRegister.h"
|
|
|
|
#include "lldb/Core/ValueObjectVariable.h"
|
2015-09-26 04:35:58 +08:00
|
|
|
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
|
2015-09-16 05:13:50 +08:00
|
|
|
#include "lldb/Expression/UserExpression.h"
|
2011-06-25 12:35:01 +08:00
|
|
|
#include "lldb/Host/Host.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/Block.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Symbol/Function.h"
|
|
|
|
#include "lldb/Symbol/Symbol.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
|
|
#include "lldb/Symbol/VariableList.h"
|
|
|
|
#include "lldb/Symbol/Variable.h"
|
|
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
|
|
#include "lldb/Target/Target.h"
|
|
|
|
#include "lldb/Target/Process.h"
|
|
|
|
#include "lldb/Target/RegisterContext.h"
|
2013-11-04 17:33:30 +08:00
|
|
|
#include "lldb/Target/StackFrame.h"
|
2012-01-30 15:41:31 +08:00
|
|
|
#include "lldb/Target/StackID.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Target/Thread.h"
|
|
|
|
|
2010-06-09 15:44:37 +08:00
|
|
|
#include "lldb/API/SBDebugger.h"
|
|
|
|
#include "lldb/API/SBValue.h"
|
|
|
|
#include "lldb/API/SBAddress.h"
|
2012-10-17 05:41:58 +08:00
|
|
|
#include "lldb/API/SBExpressionOptions.h"
|
2010-09-20 13:20:02 +08:00
|
|
|
#include "lldb/API/SBStream.h"
|
2010-06-09 15:44:37 +08:00
|
|
|
#include "lldb/API/SBSymbolContext.h"
|
|
|
|
#include "lldb/API/SBThread.h"
|
2015-02-18 01:55:50 +08:00
|
|
|
#include "lldb/API/SBVariablesOptions.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
SBFrame::SBFrame () :
|
2012-04-06 00:12:35 +08:00
|
|
|
m_opaque_sp (new ExecutionContextRef())
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
SBFrame::SBFrame (const StackFrameSP &lldb_object_sp) :
|
2012-04-06 00:12:35 +08:00
|
|
|
m_opaque_sp (new ExecutionContextRef (lldb_object_sp))
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
|
|
|
{
|
|
|
|
SBStream sstr;
|
|
|
|
GetDescription (sstr);
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame::SBFrame (sp=%p) => SBFrame(%p): %s",
|
|
|
|
static_cast<void*>(lldb_object_sp.get()),
|
|
|
|
static_cast<void*>(lldb_object_sp.get()), sstr.GetData());
|
2010-10-26 11:11:13 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2010-11-06 07:17:00 +08:00
|
|
|
SBFrame::SBFrame(const SBFrame &rhs) :
|
2012-04-06 00:12:35 +08:00
|
|
|
m_opaque_sp (new ExecutionContextRef (*rhs.m_opaque_sp))
|
2010-11-06 07:17:00 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
SBFrame::~SBFrame() = default;
|
|
|
|
|
2010-11-06 07:17:00 +08:00
|
|
|
const SBFrame &
|
|
|
|
SBFrame::operator = (const SBFrame &rhs)
|
|
|
|
{
|
|
|
|
if (this != &rhs)
|
2012-04-06 00:12:35 +08:00
|
|
|
*m_opaque_sp = *rhs.m_opaque_sp;
|
2010-11-06 07:17:00 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrameSP
|
2012-01-30 15:41:31 +08:00
|
|
|
SBFrame::GetFrameSP() const
|
|
|
|
{
|
2015-10-31 09:22:59 +08:00
|
|
|
return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
|
2012-01-30 15:41:31 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
void
|
2013-11-04 17:33:30 +08:00
|
|
|
SBFrame::SetFrameSP (const StackFrameSP &lldb_object_sp)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
return m_opaque_sp->SetFrameSP(lldb_object_sp);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
SBFrame::IsValid() const
|
|
|
|
{
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2016-05-07 08:54:56 +08:00
|
|
|
|
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
|
|
|
{
|
|
|
|
Process::StopLocker stop_locker;
|
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
|
|
|
return GetFrameSP().get() != nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Without a target & process we can't have a valid stack frame.
|
|
|
|
return false;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBSymbolContext
|
|
|
|
SBFrame::GetSymbolContext (uint32_t resolve_scope) const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-06-09 00:52:24 +08:00
|
|
|
SBSymbolContext sb_sym_ctx;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext (resolve_scope));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetSymbolContext () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetSymbolContext (resolve_scope=0x%8.8x) => SBSymbolContext(%p)",
|
|
|
|
static_cast<void*>(frame), resolve_scope,
|
|
|
|
static_cast<void*>(sb_sym_ctx.get()));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_sym_ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBModule
|
|
|
|
SBFrame::GetModule () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-14 12:58:53 +08:00
|
|
|
SBModule sb_module;
|
2012-01-30 17:04:36 +08:00
|
|
|
ModuleSP module_sp;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
module_sp = frame->GetSymbolContext (eSymbolContextModule).module_sp;
|
|
|
|
sb_module.SetSP (module_sp);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetModule () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetModule () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-12-14 12:58:53 +08:00
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetModule () => SBModule(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(module_sp.get()));
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_module;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBCompileUnit
|
|
|
|
SBFrame::GetCompileUnit () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-14 12:58:53 +08:00
|
|
|
SBCompileUnit sb_comp_unit;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_comp_unit.reset (frame->GetSymbolContext (eSymbolContextCompUnit).comp_unit);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetCompileUnit () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetCompileUnit () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetCompileUnit () => SBCompileUnit(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_comp_unit.get()));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_comp_unit;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBFunction
|
|
|
|
SBFrame::GetFunction () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-14 12:58:53 +08:00
|
|
|
SBFunction sb_function;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_function.reset(frame->GetSymbolContext (eSymbolContextFunction).function);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetFunction () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetFunction () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetFunction () => SBFunction(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_function.get()));
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_function;
|
|
|
|
}
|
|
|
|
|
2010-10-05 02:37:52 +08:00
|
|
|
SBSymbol
|
|
|
|
SBFrame::GetSymbol () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-14 12:58:53 +08:00
|
|
|
SBSymbol sb_symbol;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_symbol.reset(frame->GetSymbolContext (eSymbolContextSymbol).symbol);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetSymbol () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetSymbol () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetSymbol () => SBSymbol(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_symbol.get()));
|
2010-10-05 02:37:52 +08:00
|
|
|
return sb_symbol;
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
SBBlock
|
|
|
|
SBFrame::GetBlock () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-14 12:58:53 +08:00
|
|
|
SBBlock sb_block;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_block.SetPtr (frame->GetSymbolContext (eSymbolContextBlock).block);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetBlock () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetBlock () => error: process is running",
|
|
|
|
static_cast<void*>(frame));
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetBlock () => SBBlock(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_block.GetPtr()));
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_block;
|
|
|
|
}
|
|
|
|
|
2010-09-07 12:20:48 +08:00
|
|
|
SBBlock
|
|
|
|
SBFrame::GetFrameBlock () const
|
|
|
|
{
|
2010-12-14 12:58:53 +08:00
|
|
|
SBBlock sb_block;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_block.SetPtr(frame->GetFrameBlock ());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetFrameBlock () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetFrameBlock () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetFrameBlock () => SBBlock(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_block.GetPtr()));
|
2010-09-07 12:20:48 +08:00
|
|
|
return sb_block;
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
SBLineEntry
|
|
|
|
SBFrame::GetLineEntry () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-14 12:58:53 +08:00
|
|
|
SBLineEntry sb_line_entry;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_line_entry.SetLineEntry (frame->GetSymbolContext (eSymbolContextLineEntry).line_entry);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetLineEntry () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetLineEntry () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetLineEntry () => SBLineEntry(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_line_entry.get()));
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_line_entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
SBFrame::GetFrameID () const
|
|
|
|
{
|
2012-01-30 15:41:31 +08:00
|
|
|
uint32_t frame_idx = UINT32_MAX;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-04-06 00:12:35 +08:00
|
|
|
if (frame)
|
2012-02-18 13:35:26 +08:00
|
|
|
frame_idx = frame->GetFrameIndex ();
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetFrameID () => %u",
|
|
|
|
static_cast<void*>(frame), frame_idx);
|
2010-10-30 12:51:46 +08:00
|
|
|
return frame_idx;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2015-05-28 11:27:22 +08:00
|
|
|
lldb::addr_t
|
|
|
|
SBFrame::GetCFA () const
|
|
|
|
{
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2015-05-28 11:27:22 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
return frame->GetStackID().GetCallFrameAddress();
|
|
|
|
return LLDB_INVALID_ADDRESS;
|
|
|
|
}
|
|
|
|
|
2010-12-15 02:39:31 +08:00
|
|
|
addr_t
|
2010-06-09 00:52:24 +08:00
|
|
|
SBFrame::GetPC () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-15 02:39:31 +08:00
|
|
|
addr_t addr = LLDB_INVALID_ADDRESS;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
2015-09-07 17:58:09 +08:00
|
|
|
addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress (target, eAddressClassCode);
|
2012-11-29 08:26:19 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetPC () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetPC () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetPC () => 0x%" PRIx64,
|
|
|
|
static_cast<void*>(frame), addr);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
return addr;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2010-12-15 02:39:31 +08:00
|
|
|
SBFrame::SetPC (addr_t new_pc)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
bool ret_val = false;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
ret_val = frame->GetRegisterContext()->SetPC (new_pc);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::SetPC () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::SetPC () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2012-11-30 05:49:15 +08:00
|
|
|
log->Printf ("SBFrame(%p)::SetPC (new_pc=0x%" PRIx64 ") => %i",
|
2014-04-04 12:06:10 +08:00
|
|
|
static_cast<void*>(frame), new_pc, ret_val);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
return ret_val;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2010-12-15 02:39:31 +08:00
|
|
|
addr_t
|
2010-06-09 00:52:24 +08:00
|
|
|
SBFrame::GetSP () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-30 12:51:46 +08:00
|
|
|
addr_t addr = LLDB_INVALID_ADDRESS;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
addr = frame->GetRegisterContext()->GetSP();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetSP () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetSP () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetSP () => 0x%" PRIx64,
|
|
|
|
static_cast<void*>(frame), addr);
|
2010-10-30 12:51:46 +08:00
|
|
|
|
|
|
|
return addr;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2010-12-15 02:39:31 +08:00
|
|
|
addr_t
|
2010-06-09 00:52:24 +08:00
|
|
|
SBFrame::GetFP () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-15 02:39:31 +08:00
|
|
|
addr_t addr = LLDB_INVALID_ADDRESS;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
addr = frame->GetRegisterContext()->GetFP();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetFP () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetFP () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetFP () => 0x%" PRIx64,
|
|
|
|
static_cast<void*>(frame), addr);
|
2010-10-26 11:11:13 +08:00
|
|
|
return addr;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBAddress
|
|
|
|
SBFrame::GetPCAddress () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-06-09 00:52:24 +08:00
|
|
|
SBAddress sb_addr;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
sb_addr.SetAddress (&frame->GetFrameCodeAddress());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetPCAddress () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetPCAddress () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetPCAddress () => SBAddress(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(sb_addr.get()));
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SBFrame::Clear()
|
|
|
|
{
|
2012-04-13 04:58:26 +08:00
|
|
|
m_opaque_sp->Clear();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2012-02-03 15:02:37 +08:00
|
|
|
lldb::SBValue
|
|
|
|
SBFrame::GetValueForVariablePath (const char *var_path)
|
|
|
|
{
|
|
|
|
SBValue sb_value;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (frame && target)
|
2012-02-03 15:02:37 +08:00
|
|
|
{
|
2012-04-06 10:17:47 +08:00
|
|
|
lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
|
|
|
|
sb_value = GetValueForVariablePath (var_path, use_dynamic);
|
2012-02-03 15:02:37 +08:00
|
|
|
}
|
|
|
|
return sb_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
lldb::SBValue
|
|
|
|
SBFrame::GetValueForVariablePath (const char *var_path, DynamicValueType use_dynamic)
|
|
|
|
{
|
|
|
|
SBValue sb_value;
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2015-10-31 09:22:59 +08:00
|
|
|
if (var_path == nullptr || var_path[0] == '\0')
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetValueForVariablePath called with empty variable path.");
|
|
|
|
return sb_value;
|
|
|
|
}
|
2016-05-19 13:13:57 +08:00
|
|
|
|
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2012-02-03 15:02:37 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
VariableSP var_sp;
|
|
|
|
Error error;
|
|
|
|
ValueObjectSP value_sp (frame->GetValueForVariableExpressionPath (var_path,
|
|
|
|
eNoDynamicValues,
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
|
2012-11-29 08:26:19 +08:00
|
|
|
var_sp,
|
|
|
|
error));
|
|
|
|
sb_value.SetSP(value_sp, use_dynamic);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetValueForVariablePath () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetValueForVariablePath () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2012-02-03 15:02:37 +08:00
|
|
|
}
|
|
|
|
return sb_value;
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
SBValue
|
2010-12-15 02:39:31 +08:00
|
|
|
SBFrame::FindVariable (const char *name)
|
2011-04-16 08:01:13 +08:00
|
|
|
{
|
2011-06-19 04:06:08 +08:00
|
|
|
SBValue value;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (frame && target)
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-02-18 13:35:26 +08:00
|
|
|
lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
|
2011-06-19 04:06:08 +08:00
|
|
|
value = FindVariable (name, use_dynamic);
|
|
|
|
}
|
|
|
|
return value;
|
2011-04-16 08:01:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBValue
|
2011-05-04 11:43:18 +08:00
|
|
|
SBFrame::FindVariable (const char *name, lldb::DynamicValueType use_dynamic)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-15 02:39:31 +08:00
|
|
|
VariableSP var_sp;
|
2011-04-23 07:53:53 +08:00
|
|
|
SBValue sb_value;
|
2012-11-29 08:26:19 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (name == nullptr || name[0] == '\0')
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::FindVariable called with empty name");
|
|
|
|
return sb_value;
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2012-02-04 10:27:34 +08:00
|
|
|
ValueObjectSP value_sp;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
2010-12-14 12:58:53 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
VariableList variable_list;
|
|
|
|
SymbolContext sc (frame->GetSymbolContext (eSymbolContextBlock));
|
|
|
|
|
|
|
|
if (sc.block)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const bool can_create = true;
|
|
|
|
const bool get_parent_variables = true;
|
|
|
|
const bool stop_if_block_is_inlined_function = true;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-02-25 20:23:37 +08:00
|
|
|
if (sc.block->AppendVariables (can_create,
|
2012-11-29 08:26:19 +08:00
|
|
|
get_parent_variables,
|
|
|
|
stop_if_block_is_inlined_function,
|
2016-02-25 20:23:37 +08:00
|
|
|
[frame](Variable* v) { return v->IsInScope(frame); },
|
2012-11-29 08:26:19 +08:00
|
|
|
&variable_list))
|
|
|
|
{
|
|
|
|
var_sp = variable_list.FindVariable (ConstString(name));
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2011-06-19 04:06:08 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
if (var_sp)
|
|
|
|
{
|
|
|
|
value_sp = frame->GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
|
|
|
|
sb_value.SetSP(value_sp, use_dynamic);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::FindVariable () => error: could not reconstruct frame object for this SBFrame.");
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-02-04 10:27:34 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::FindVariable () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::FindVariable (name=\"%s\") => SBValue(%p)",
|
|
|
|
static_cast<void*>(frame), name,
|
|
|
|
static_cast<void*>(value_sp.get()));
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
SBValue
|
2010-12-15 02:39:31 +08:00
|
|
|
SBFrame::FindValue (const char *name, ValueType value_type)
|
2011-04-16 08:01:13 +08:00
|
|
|
{
|
2011-06-19 04:06:08 +08:00
|
|
|
SBValue value;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (frame && target)
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-02-18 13:35:26 +08:00
|
|
|
lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
|
2011-06-19 04:06:08 +08:00
|
|
|
value = FindValue (name, value_type, use_dynamic);
|
|
|
|
}
|
|
|
|
return value;
|
2011-04-16 08:01:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBValue
|
2011-05-04 11:43:18 +08:00
|
|
|
SBFrame::FindValue (const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-12-15 02:39:31 +08:00
|
|
|
SBValue sb_value;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (name == nullptr || name[0] == '\0')
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::FindValue called with empty name.");
|
|
|
|
return sb_value;
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2012-02-04 10:27:34 +08:00
|
|
|
ValueObjectSP value_sp;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
2010-12-15 02:39:31 +08:00
|
|
|
{
|
2014-02-20 03:35:13 +08:00
|
|
|
VariableList variable_list;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
switch (value_type)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
case eValueTypeVariableGlobal: // global variable
|
|
|
|
case eValueTypeVariableStatic: // static variable
|
|
|
|
case eValueTypeVariableArgument: // function argument variables
|
|
|
|
case eValueTypeVariableLocal: // function local variables
|
2016-07-02 01:17:23 +08:00
|
|
|
case eValueTypeVariableThreadLocal: // thread local variables
|
|
|
|
{
|
|
|
|
SymbolContext sc(frame->GetSymbolContext(eSymbolContextBlock));
|
|
|
|
|
|
|
|
const bool can_create = true;
|
|
|
|
const bool get_parent_variables = true;
|
|
|
|
const bool stop_if_block_is_inlined_function = true;
|
|
|
|
|
|
|
|
if (sc.block)
|
|
|
|
sc.block->AppendVariables(can_create, get_parent_variables, stop_if_block_is_inlined_function,
|
|
|
|
[frame](Variable *v) { return v->IsInScope(frame); }, &variable_list);
|
|
|
|
if (value_type == eValueTypeVariableGlobal)
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
2016-07-02 01:17:23 +08:00
|
|
|
const bool get_file_globals = true;
|
|
|
|
VariableList *frame_vars = frame->GetVariableList(get_file_globals);
|
|
|
|
if (frame_vars)
|
|
|
|
frame_vars->AppendVariablesIfUnique(variable_list);
|
|
|
|
}
|
|
|
|
ConstString const_name(name);
|
|
|
|
VariableSP variable_sp(variable_list.FindVariable(const_name, value_type));
|
|
|
|
if (variable_sp)
|
|
|
|
{
|
|
|
|
value_sp = frame->GetValueObjectForFrameVariable(variable_sp, eNoDynamicValues);
|
|
|
|
sb_value.SetSP(value_sp, use_dynamic);
|
|
|
|
}
|
2010-12-15 02:39:31 +08:00
|
|
|
}
|
2012-11-29 08:26:19 +08:00
|
|
|
break;
|
2010-12-15 02:39:31 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
case eValueTypeRegister: // stack frame register value
|
2010-12-15 02:39:31 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
RegisterContextSP reg_ctx (frame->GetRegisterContext());
|
|
|
|
if (reg_ctx)
|
2010-12-15 02:39:31 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const uint32_t num_regs = reg_ctx->GetRegisterCount();
|
|
|
|
for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx);
|
|
|
|
if (reg_info &&
|
|
|
|
((reg_info->name && strcasecmp (reg_info->name, name) == 0) ||
|
|
|
|
(reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0)))
|
|
|
|
{
|
|
|
|
value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx);
|
|
|
|
sb_value.SetSP (value_sp);
|
|
|
|
break;
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2010-12-15 02:39:31 +08:00
|
|
|
}
|
|
|
|
}
|
2012-11-29 08:26:19 +08:00
|
|
|
break;
|
2010-12-14 12:58:53 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
case eValueTypeRegisterSet: // A collection of stack frame register values
|
2010-11-20 02:07:14 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
RegisterContextSP reg_ctx (frame->GetRegisterContext());
|
|
|
|
if (reg_ctx)
|
2010-12-15 02:39:31 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
|
|
|
|
for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const RegisterSet *reg_set = reg_ctx->GetRegisterSet (set_idx);
|
|
|
|
if (reg_set &&
|
|
|
|
((reg_set->name && strcasecmp (reg_set->name, name) == 0) ||
|
|
|
|
(reg_set->short_name && strcasecmp (reg_set->short_name, name) == 0)))
|
|
|
|
{
|
|
|
|
value_sp = ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx);
|
|
|
|
sb_value.SetSP (value_sp);
|
|
|
|
break;
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2010-12-15 02:39:31 +08:00
|
|
|
}
|
2010-11-20 02:07:14 +08:00
|
|
|
}
|
2012-11-29 08:26:19 +08:00
|
|
|
break;
|
2010-12-15 02:39:31 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
case eValueTypeConstResult: // constant result variables
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
ConstString const_name(name);
|
2015-10-01 03:57:57 +08:00
|
|
|
ExpressionVariableSP expr_var_sp (target->GetPersistentVariable (const_name));
|
2012-11-29 08:26:19 +08:00
|
|
|
if (expr_var_sp)
|
|
|
|
{
|
|
|
|
value_sp = expr_var_sp->GetValueObject();
|
|
|
|
sb_value.SetSP (value_sp, use_dynamic);
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-11-29 08:26:19 +08:00
|
|
|
break;
|
2010-12-15 02:39:31 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::FindValue () => error: could not reconstruct frame object for this SBFrame.");
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::FindValue () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::FindVariableInScope (name=\"%s\", value_type=%i) => SBValue(%p)",
|
|
|
|
static_cast<void*>(frame), name, value_type,
|
|
|
|
static_cast<void*>(value_sp.get()));
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_value;
|
|
|
|
}
|
|
|
|
|
2012-03-06 03:53:24 +08:00
|
|
|
bool
|
|
|
|
SBFrame::IsEqual (const SBFrame &that) const
|
|
|
|
{
|
2013-11-04 17:33:30 +08:00
|
|
|
lldb::StackFrameSP this_sp = GetFrameSP();
|
|
|
|
lldb::StackFrameSP that_sp = that.GetFrameSP();
|
2012-03-06 03:53:24 +08:00
|
|
|
return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
bool
|
|
|
|
SBFrame::operator == (const SBFrame &rhs) const
|
|
|
|
{
|
2012-03-06 03:53:24 +08:00
|
|
|
return IsEqual(rhs);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
SBFrame::operator != (const SBFrame &rhs) const
|
|
|
|
{
|
2012-03-06 03:53:24 +08:00
|
|
|
return !IsEqual(rhs);
|
2011-01-21 14:11:58 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
SBThread
|
|
|
|
SBFrame::GetThread () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2012-02-18 13:35:26 +08:00
|
|
|
ThreadSP thread_sp (exe_ctx.GetThreadSP());
|
|
|
|
SBThread sb_thread (thread_sp);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2010-10-27 07:49:36 +08:00
|
|
|
{
|
|
|
|
SBStream sstr;
|
|
|
|
sb_thread.GetDescription (sstr);
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetThread () => SBThread(%p): %s",
|
|
|
|
static_cast<void*>(exe_ctx.GetFramePtr()),
|
|
|
|
static_cast<void*>(thread_sp.get()), sstr.GetData());
|
2010-10-27 07:49:36 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sb_thread;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
SBFrame::Disassemble () const
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2015-10-31 09:22:59 +08:00
|
|
|
const char *disassembly = nullptr;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
disassembly = frame->Disassemble();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::Disassemble () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::Disassemble () => error: process is running");
|
2014-04-04 12:06:10 +08:00
|
|
|
}
|
2010-12-21 04:49:23 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::Disassemble () => %s",
|
|
|
|
static_cast<void*>(frame), disassembly);
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
return disassembly;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBValueList
|
|
|
|
SBFrame::GetVariables (bool arguments,
|
|
|
|
bool locals,
|
|
|
|
bool statics,
|
|
|
|
bool in_scope_only)
|
2011-04-16 08:01:13 +08:00
|
|
|
{
|
2011-06-19 04:06:08 +08:00
|
|
|
SBValueList value_list;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (frame && target)
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-02-18 13:35:26 +08:00
|
|
|
lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue();
|
2015-02-18 01:55:50 +08:00
|
|
|
const bool include_runtime_support_values = target ? target->GetDisplayRuntimeSupportValues() : false;
|
|
|
|
|
|
|
|
SBVariablesOptions options;
|
|
|
|
options.SetIncludeArguments(arguments);
|
|
|
|
options.SetIncludeLocals(locals);
|
|
|
|
options.SetIncludeStatics(statics);
|
|
|
|
options.SetInScopeOnly(in_scope_only);
|
|
|
|
options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
|
|
|
|
options.SetUseDynamic(use_dynamic);
|
|
|
|
|
|
|
|
value_list = GetVariables (options);
|
2011-06-19 04:06:08 +08:00
|
|
|
}
|
|
|
|
return value_list;
|
2011-04-16 08:01:13 +08:00
|
|
|
}
|
|
|
|
|
2015-02-11 10:35:39 +08:00
|
|
|
lldb::SBValueList
|
|
|
|
SBFrame::GetVariables (bool arguments,
|
|
|
|
bool locals,
|
|
|
|
bool statics,
|
|
|
|
bool in_scope_only,
|
|
|
|
lldb::DynamicValueType use_dynamic)
|
|
|
|
{
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2015-02-11 10:35:39 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2015-02-18 01:55:50 +08:00
|
|
|
const bool include_runtime_support_values = target ? target->GetDisplayRuntimeSupportValues() : false;
|
|
|
|
SBVariablesOptions options;
|
|
|
|
options.SetIncludeArguments(arguments);
|
|
|
|
options.SetIncludeLocals(locals);
|
|
|
|
options.SetIncludeStatics(statics);
|
|
|
|
options.SetInScopeOnly(in_scope_only);
|
|
|
|
options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
|
|
|
|
options.SetUseDynamic(use_dynamic);
|
|
|
|
return GetVariables(options);
|
2015-02-11 10:35:39 +08:00
|
|
|
}
|
|
|
|
|
2011-04-16 08:01:13 +08:00
|
|
|
SBValueList
|
2015-02-18 01:55:50 +08:00
|
|
|
SBFrame::GetVariables (const lldb::SBVariablesOptions& options)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2012-01-30 15:41:31 +08:00
|
|
|
SBValueList value_list;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-01-30 15:41:31 +08:00
|
|
|
|
2015-02-18 01:55:50 +08:00
|
|
|
const bool statics = options.GetIncludeStatics();
|
|
|
|
const bool arguments = options.GetIncludeArguments();
|
|
|
|
const bool locals = options.GetIncludeLocals();
|
|
|
|
const bool in_scope_only = options.GetInScopeOnly();
|
|
|
|
const bool include_runtime_support_values = options.GetIncludeRuntimeSupportValues();
|
|
|
|
const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
|
|
|
|
|
2010-10-26 11:11:13 +08:00
|
|
|
if (log)
|
2015-02-18 01:55:50 +08:00
|
|
|
log->Printf ("SBFrame::GetVariables (arguments=%i, locals=%i, statics=%i, in_scope_only=%i runtime=%i dynamic=%i)",
|
|
|
|
arguments, locals,
|
|
|
|
statics, in_scope_only,
|
|
|
|
include_runtime_support_values, use_dynamic);
|
2016-04-30 05:00:38 +08:00
|
|
|
|
|
|
|
std::set<VariableSP> variable_set;
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2010-12-21 04:49:23 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
size_t i;
|
2015-10-31 09:22:59 +08:00
|
|
|
VariableList *variable_list = nullptr;
|
2012-11-29 08:26:19 +08:00
|
|
|
variable_list = frame->GetVariableList(true);
|
|
|
|
if (variable_list)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const size_t num_variables = variable_list->GetSize();
|
|
|
|
if (num_variables)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
for (i = 0; i < num_variables; ++i)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
VariableSP variable_sp (variable_list->GetVariableAtIndex(i));
|
|
|
|
if (variable_sp)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
bool add_variable = false;
|
|
|
|
switch (variable_sp->GetScope())
|
|
|
|
{
|
|
|
|
case eValueTypeVariableGlobal:
|
|
|
|
case eValueTypeVariableStatic:
|
2016-07-02 01:17:23 +08:00
|
|
|
case eValueTypeVariableThreadLocal:
|
2012-11-29 08:26:19 +08:00
|
|
|
add_variable = statics;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case eValueTypeVariableArgument:
|
|
|
|
add_variable = arguments;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case eValueTypeVariableLocal:
|
|
|
|
add_variable = locals;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (add_variable)
|
|
|
|
{
|
2016-04-30 05:00:38 +08:00
|
|
|
// Only add variables once so we don't end up with duplicates
|
|
|
|
if (variable_set.find(variable_sp) == variable_set.end())
|
|
|
|
variable_set.insert(variable_sp);
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
if (in_scope_only && !variable_sp->IsInScope(frame))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable (variable_sp, eNoDynamicValues));
|
2015-02-11 10:35:39 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (!include_runtime_support_values &&
|
|
|
|
valobj_sp != nullptr &&
|
|
|
|
valobj_sp->IsRuntimeSupportValue())
|
2015-02-11 10:35:39 +08:00
|
|
|
continue;
|
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
SBValue value_sb;
|
|
|
|
value_sb.SetSP(valobj_sp,use_dynamic);
|
|
|
|
value_list.Append(value_sb);
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-11-29 08:26:19 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetVariables () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetVariables () => error: process is running");
|
2014-04-04 12:06:10 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetVariables (...) => SBValueList(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(value_list.opaque_ptr()));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return value_list;
|
|
|
|
}
|
|
|
|
|
2010-12-15 02:39:31 +08:00
|
|
|
SBValueList
|
2010-06-09 00:52:24 +08:00
|
|
|
SBFrame::GetRegisters ()
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
SBValueList value_list;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
RegisterContextSP reg_ctx (frame->GetRegisterContext());
|
|
|
|
if (reg_ctx)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
|
|
|
|
for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
|
|
|
|
{
|
|
|
|
value_list.Append(ValueObjectRegisterSet::Create (frame, reg_ctx, set_idx));
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2012-11-29 08:26:19 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetRegisters () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetRegisters () => error: process is running");
|
2014-04-04 12:06:10 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::GetRegisters () => SBValueList(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(value_list.opaque_ptr()));
|
2010-10-26 11:11:13 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return value_list;
|
|
|
|
}
|
|
|
|
|
2013-07-26 10:08:48 +08:00
|
|
|
SBValue
|
|
|
|
SBFrame::FindRegister (const char *name)
|
|
|
|
{
|
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
|
|
|
|
SBValue result;
|
|
|
|
ValueObjectSP value_sp;
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2013-07-26 10:08:48 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2013-07-26 10:08:48 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
|
|
|
{
|
|
|
|
Process::StopLocker stop_locker;
|
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
|
|
|
{
|
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
RegisterContextSP reg_ctx (frame->GetRegisterContext());
|
|
|
|
if (reg_ctx)
|
|
|
|
{
|
|
|
|
const uint32_t num_regs = reg_ctx->GetRegisterCount();
|
|
|
|
for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
|
|
|
|
{
|
|
|
|
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_idx);
|
|
|
|
if (reg_info &&
|
|
|
|
((reg_info->name && strcasecmp (reg_info->name, name) == 0) ||
|
|
|
|
(reg_info->alt_name && strcasecmp (reg_info->alt_name, name) == 0)))
|
|
|
|
{
|
|
|
|
value_sp = ValueObjectRegister::Create (frame, reg_ctx, reg_idx);
|
|
|
|
result.SetSP (value_sp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2013-07-27 06:52:30 +08:00
|
|
|
log->Printf ("SBFrame::FindRegister () => error: could not reconstruct frame object for this SBFrame.");
|
2013-07-26 10:08:48 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2013-07-27 06:52:30 +08:00
|
|
|
log->Printf ("SBFrame::FindRegister () => error: process is running");
|
2014-04-04 12:06:10 +08:00
|
|
|
}
|
2013-07-26 10:08:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::FindRegister () => SBValue(%p)",
|
|
|
|
static_cast<void*>(frame),
|
|
|
|
static_cast<void*>(value_sp.get()));
|
2013-07-26 10:08:48 +08:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-09-20 13:20:02 +08:00
|
|
|
bool
|
|
|
|
SBFrame::GetDescription (SBStream &description)
|
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2011-11-13 14:57:31 +08:00
|
|
|
Stream &strm = description.ref();
|
|
|
|
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2010-09-20 13:20:02 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
frame->DumpUsingSettingsFormat (&strm);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetDescription () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetDescription () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
|
|
|
|
2010-09-20 13:20:02 +08:00
|
|
|
}
|
|
|
|
else
|
2011-11-13 14:57:31 +08:00
|
|
|
strm.PutCString ("No value");
|
2010-09-20 13:20:02 +08:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2010-10-05 08:00:42 +08:00
|
|
|
|
2010-12-15 02:39:31 +08:00
|
|
|
SBValue
|
2010-10-05 08:00:42 +08:00
|
|
|
SBFrame::EvaluateExpression (const char *expr)
|
2011-04-16 08:01:13 +08:00
|
|
|
{
|
2011-06-19 04:06:08 +08:00
|
|
|
SBValue result;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2013-11-04 17:33:30 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (frame && target)
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-10-17 05:41:58 +08:00
|
|
|
SBExpressionOptions options;
|
|
|
|
lldb::DynamicValueType fetch_dynamic_value = frame->CalculateTarget()->GetPreferDynamicValue();
|
2012-10-17 06:58:25 +08:00
|
|
|
options.SetFetchDynamicValue (fetch_dynamic_value);
|
2012-10-17 05:41:58 +08:00
|
|
|
options.SetUnwindOnError (true);
|
2016-01-29 18:48:11 +08:00
|
|
|
options.SetIgnoreBreakpoints (true);
|
2015-11-03 03:30:40 +08:00
|
|
|
if (target->GetLanguage() != eLanguageTypeUnknown)
|
|
|
|
options.SetLanguage(target->GetLanguage());
|
|
|
|
else
|
|
|
|
options.SetLanguage(frame->GetLanguage());
|
2012-10-17 05:41:58 +08:00
|
|
|
return EvaluateExpression (expr, options);
|
2011-06-19 04:06:08 +08:00
|
|
|
}
|
|
|
|
return result;
|
2011-04-16 08:01:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBValue
|
2011-05-04 11:43:18 +08:00
|
|
|
SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value)
|
2012-05-12 07:47:32 +08:00
|
|
|
{
|
2012-10-17 05:41:58 +08:00
|
|
|
SBExpressionOptions options;
|
2012-10-17 06:58:25 +08:00
|
|
|
options.SetFetchDynamicValue (fetch_dynamic_value);
|
2012-10-17 05:41:58 +08:00
|
|
|
options.SetUnwindOnError (true);
|
2016-01-29 18:48:11 +08:00
|
|
|
options.SetIgnoreBreakpoints (true);
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2015-11-03 03:30:40 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (target && target->GetLanguage() != eLanguageTypeUnknown)
|
|
|
|
options.SetLanguage(target->GetLanguage());
|
|
|
|
else if (frame)
|
|
|
|
options.SetLanguage(frame->GetLanguage());
|
2012-10-17 05:41:58 +08:00
|
|
|
return EvaluateExpression (expr, options);
|
2012-05-12 07:47:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SBValue
|
|
|
|
SBFrame::EvaluateExpression (const char *expr, lldb::DynamicValueType fetch_dynamic_value, bool unwind_on_error)
|
2012-10-17 05:41:58 +08:00
|
|
|
{
|
|
|
|
SBExpressionOptions options;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2012-10-17 06:58:25 +08:00
|
|
|
options.SetFetchDynamicValue (fetch_dynamic_value);
|
2012-10-17 05:41:58 +08:00
|
|
|
options.SetUnwindOnError (unwind_on_error);
|
2016-01-29 18:48:11 +08:00
|
|
|
options.SetIgnoreBreakpoints (true);
|
2015-11-03 03:30:40 +08:00
|
|
|
StackFrame *frame = exe_ctx.GetFramePtr();
|
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
if (target && target->GetLanguage() != eLanguageTypeUnknown)
|
|
|
|
options.SetLanguage(target->GetLanguage());
|
|
|
|
else if (frame)
|
|
|
|
options.SetLanguage(frame->GetLanguage());
|
2012-10-17 05:41:58 +08:00
|
|
|
return EvaluateExpression (expr, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
lldb::SBValue
|
|
|
|
SBFrame::EvaluateExpression (const char *expr, const SBExpressionOptions &options)
|
2010-10-05 08:00:42 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-04-22 00:56:02 +08:00
|
|
|
#ifndef LLDB_DISABLE_PYTHON
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *expr_log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
2016-04-22 00:56:02 +08:00
|
|
|
#endif
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2014-05-05 10:47:44 +08:00
|
|
|
ExpressionResults exe_results = eExpressionSetupError;
|
2010-12-15 02:39:31 +08:00
|
|
|
SBValue expr_result;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (expr == nullptr || expr[0] == '\0')
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::EvaluateExpression called with an empty expression");
|
|
|
|
return expr_result;
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2012-02-04 10:27:34 +08:00
|
|
|
ValueObjectSP expr_value_sp;
|
2012-01-30 15:41:31 +08:00
|
|
|
|
2016-05-19 13:13:57 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
2012-08-23 05:34:33 +08:00
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr);
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-11-29 08:26:19 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
if (target && process)
|
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
2013-12-07 05:59:52 +08:00
|
|
|
if (target->GetDisplayExpressionsInCrashlogs())
|
|
|
|
{
|
|
|
|
StreamString frame_description;
|
|
|
|
frame->DumpUsingSettingsFormat (&frame_description);
|
|
|
|
Host::SetCrashDescriptionWithFormat ("SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = %u) %s",
|
|
|
|
expr, options.GetFetchDynamicValue(), frame_description.GetString().c_str());
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2013-12-07 05:59:52 +08:00
|
|
|
exe_results = target->EvaluateExpression (expr,
|
2012-11-29 08:26:19 +08:00
|
|
|
frame,
|
|
|
|
expr_value_sp,
|
|
|
|
options.ref());
|
|
|
|
expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
|
2013-12-07 05:59:52 +08:00
|
|
|
|
|
|
|
if (target->GetDisplayExpressionsInCrashlogs())
|
2015-10-31 09:22:59 +08:00
|
|
|
Host::SetCrashDescription(nullptr);
|
2012-11-29 08:26:19 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::EvaluateExpression () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::EvaluateExpression () => error: process is running");
|
2014-04-04 12:06:10 +08:00
|
|
|
}
|
2010-10-05 08:00:42 +08:00
|
|
|
}
|
2012-02-21 13:33:55 +08:00
|
|
|
|
|
|
|
#ifndef LLDB_DISABLE_PYTHON
|
2010-12-08 06:55:01 +08:00
|
|
|
if (expr_log)
|
2014-04-04 12:06:10 +08:00
|
|
|
expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is %s, summary %s **",
|
|
|
|
expr_result.GetValue(), expr_result.GetSummary());
|
|
|
|
|
2010-10-30 12:51:46 +08:00
|
|
|
if (log)
|
2014-04-04 12:06:10 +08:00
|
|
|
log->Printf ("SBFrame(%p)::EvaluateExpression (expr=\"%s\") => SBValue(%p) (execution result=%d)",
|
|
|
|
static_cast<void*>(frame), expr,
|
|
|
|
static_cast<void*>(expr_value_sp.get()), exe_results);
|
2012-02-21 13:33:55 +08:00
|
|
|
#endif
|
2010-10-30 12:51:46 +08:00
|
|
|
|
2010-10-31 11:01:06 +08:00
|
|
|
return expr_result;
|
2010-10-05 08:00:42 +08:00
|
|
|
}
|
2011-06-19 04:06:08 +08:00
|
|
|
|
|
|
|
bool
|
2015-06-25 02:35:36 +08:00
|
|
|
SBFrame::IsInlined()
|
2015-06-26 01:41:41 +08:00
|
|
|
{
|
|
|
|
return static_cast<const SBFrame*>(this)->IsInlined();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
SBFrame::IsInlined() const
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
|
2012-11-29 08:26:19 +08:00
|
|
|
Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
|
|
|
|
if (block)
|
2015-10-31 09:22:59 +08:00
|
|
|
return block->GetContainingInlinedBlock() != nullptr;
|
2012-11-29 08:26:19 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::IsInlined () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::IsInlined () => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
}
|
|
|
|
|
2011-06-19 04:06:08 +08:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
2015-06-25 02:35:36 +08:00
|
|
|
SBFrame::GetFunctionName()
|
2015-06-26 01:41:41 +08:00
|
|
|
{
|
|
|
|
return static_cast<const SBFrame*>(this)->GetFunctionName();
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
SBFrame::GetFunctionName() const
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2015-10-31 09:22:59 +08:00
|
|
|
const char *name = nullptr;
|
2016-06-10 08:37:44 +08:00
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2012-02-18 13:35:26 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
2012-11-29 08:26:19 +08:00
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-04-06 00:12:35 +08:00
|
|
|
Process::StopLocker stop_locker;
|
2012-11-29 08:26:19 +08:00
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
2011-06-19 04:06:08 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
SymbolContext sc (frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol));
|
|
|
|
if (sc.block)
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
Block *inlined_block = sc.block->GetContainingInlinedBlock ();
|
|
|
|
if (inlined_block)
|
|
|
|
{
|
|
|
|
const InlineFunctionInfo* inlined_info = inlined_block->GetInlinedFunctionInfo();
|
2015-07-09 06:32:23 +08:00
|
|
|
name = inlined_info->GetName(sc.function->GetLanguage()).AsCString();
|
2012-11-29 08:26:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (name == nullptr)
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
|
|
|
if (sc.function)
|
|
|
|
name = sc.function->GetName().GetCString();
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2011-06-19 04:06:08 +08:00
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (name == nullptr)
|
2012-11-29 08:26:19 +08:00
|
|
|
{
|
|
|
|
if (sc.symbol)
|
|
|
|
name = sc.symbol->GetName().GetCString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2012-04-06 00:12:35 +08:00
|
|
|
{
|
2012-11-29 08:26:19 +08:00
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetFunctionName () => error: could not reconstruct frame object for this SBFrame.");
|
2012-04-06 00:12:35 +08:00
|
|
|
}
|
2011-06-19 04:06:08 +08:00
|
|
|
}
|
2012-04-06 10:17:47 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
2012-11-29 08:26:19 +08:00
|
|
|
log->Printf ("SBFrame::GetFunctionName() => error: process is running");
|
2012-04-06 10:17:47 +08:00
|
|
|
|
|
|
|
}
|
2011-06-19 04:06:08 +08:00
|
|
|
}
|
|
|
|
return name;
|
|
|
|
}
|
2015-07-07 02:28:46 +08:00
|
|
|
|
|
|
|
const char *
|
|
|
|
SBFrame::GetDisplayFunctionName()
|
|
|
|
{
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
2015-10-31 09:22:59 +08:00
|
|
|
const char *name = nullptr;
|
2016-06-10 08:37:44 +08:00
|
|
|
|
|
|
|
std::unique_lock<std::recursive_mutex> lock;
|
|
|
|
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
StackFrame *frame = nullptr;
|
2015-07-07 02:28:46 +08:00
|
|
|
Target *target = exe_ctx.GetTargetPtr();
|
|
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
|
|
if (target && process)
|
|
|
|
{
|
|
|
|
Process::StopLocker stop_locker;
|
|
|
|
if (stop_locker.TryLock(&process->GetRunLock()))
|
|
|
|
{
|
|
|
|
frame = exe_ctx.GetFramePtr();
|
|
|
|
if (frame)
|
|
|
|
{
|
|
|
|
SymbolContext sc (frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol));
|
|
|
|
if (sc.block)
|
|
|
|
{
|
|
|
|
Block *inlined_block = sc.block->GetContainingInlinedBlock ();
|
|
|
|
if (inlined_block)
|
|
|
|
{
|
|
|
|
const InlineFunctionInfo* inlined_info = inlined_block->GetInlinedFunctionInfo();
|
2015-07-09 06:32:23 +08:00
|
|
|
name = inlined_info->GetDisplayName(sc.function->GetLanguage()).AsCString();
|
2015-07-07 02:28:46 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (name == nullptr)
|
2015-07-07 02:28:46 +08:00
|
|
|
{
|
|
|
|
if (sc.function)
|
|
|
|
name = sc.function->GetDisplayName().GetCString();
|
|
|
|
}
|
|
|
|
|
2015-10-31 09:22:59 +08:00
|
|
|
if (name == nullptr)
|
2015-07-07 02:28:46 +08:00
|
|
|
{
|
|
|
|
if (sc.symbol)
|
|
|
|
name = sc.symbol->GetDisplayName().GetCString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetDisplayFunctionName () => error: could not reconstruct frame object for this SBFrame.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
log->Printf ("SBFrame::GetDisplayFunctionName() => error: process is running");
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return name;
|
|
|
|
}
|