ceb6b1393d
it logs the function calls, their arguments and the return values. This is not complete or polished, but I am committing it now, at the request of someone who really wants to use it, even though it's not really done. It currently does not attempt to log all the functions, just the most important ones. I will be making further adjustments to the API logging code over the next few days/weeks. (Suggestions for improvements are welcome). Update the Python build scripts to re-build the swig C++ file whenever the python-extensions.swig file is modified. Correct the help for 'log enable' command (give it the correct number & type of arguments). llvm-svn: 117349
545 lines
14 KiB
C++
545 lines
14 KiB
C++
//===-- SBFrame.cpp ---------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/API/SBFrame.h"
|
|
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
#include "lldb/lldb-types.h"
|
|
|
|
#include "lldb/Core/Address.h"
|
|
#include "lldb/Core/ConstString.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Core/ValueObjectRegister.h"
|
|
#include "lldb/Core/ValueObjectVariable.h"
|
|
#include "lldb/Expression/ClangUserExpression.h"
|
|
#include "lldb/Symbol/Block.h"
|
|
#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"
|
|
#include "lldb/Target/StackFrame.h"
|
|
#include "lldb/Target/Thread.h"
|
|
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBValue.h"
|
|
#include "lldb/API/SBAddress.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBSymbolContext.h"
|
|
#include "lldb/API/SBThread.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
SBFrame::SBFrame () :
|
|
m_opaque_sp ()
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::SBFrame () ==> this = %p", this);
|
|
}
|
|
|
|
SBFrame::SBFrame (const lldb::StackFrameSP &lldb_object_sp) :
|
|
m_opaque_sp (lldb_object_sp)
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
|
|
|
|
if (log)
|
|
{
|
|
SBStream sstr;
|
|
GetDescription (sstr);
|
|
log->Printf ("SBFrame::SBFrame (const lldb::StackFrameSP &lldb_object_sp) lldb_object_sp.get() = %p "
|
|
" ==> this = %p (%s)", lldb_object_sp.get(), this, sstr.GetData());
|
|
}
|
|
}
|
|
|
|
SBFrame::~SBFrame()
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
SBFrame::SetFrame (const lldb::StackFrameSP &lldb_object_sp)
|
|
{
|
|
m_opaque_sp = lldb_object_sp;
|
|
}
|
|
|
|
|
|
bool
|
|
SBFrame::IsValid() const
|
|
{
|
|
return (m_opaque_sp.get() != NULL);
|
|
}
|
|
|
|
SBSymbolContext
|
|
SBFrame::GetSymbolContext (uint32_t resolve_scope) const
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetSymbolContext (%d)", resolve_scope);
|
|
|
|
SBSymbolContext sb_sym_ctx;
|
|
if (m_opaque_sp)
|
|
sb_sym_ctx.SetSymbolContext(&m_opaque_sp->GetSymbolContext (resolve_scope));
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetSymbolContext ==> SBSymbolContext (this = %p)", &sb_sym_ctx);
|
|
|
|
return sb_sym_ctx;
|
|
}
|
|
|
|
SBModule
|
|
SBFrame::GetModule () const
|
|
{
|
|
SBModule sb_module (m_opaque_sp->GetSymbolContext (eSymbolContextModule).module_sp);
|
|
return sb_module;
|
|
}
|
|
|
|
SBCompileUnit
|
|
SBFrame::GetCompileUnit () const
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetCompileUnit()");
|
|
|
|
SBCompileUnit sb_comp_unit(m_opaque_sp->GetSymbolContext (eSymbolContextCompUnit).comp_unit);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetCompileUnit ==> SBCompileUnit (this = %p", &sb_comp_unit);
|
|
|
|
return sb_comp_unit;
|
|
}
|
|
|
|
SBFunction
|
|
SBFrame::GetFunction () const
|
|
{
|
|
SBFunction sb_function(m_opaque_sp->GetSymbolContext (eSymbolContextFunction).function);
|
|
return sb_function;
|
|
}
|
|
|
|
SBSymbol
|
|
SBFrame::GetSymbol () const
|
|
{
|
|
SBSymbol sb_symbol(m_opaque_sp->GetSymbolContext (eSymbolContextSymbol).symbol);
|
|
return sb_symbol;
|
|
}
|
|
|
|
SBBlock
|
|
SBFrame::GetBlock () const
|
|
{
|
|
SBBlock sb_block(m_opaque_sp->GetSymbolContext (eSymbolContextBlock).block);
|
|
return sb_block;
|
|
}
|
|
|
|
SBBlock
|
|
SBFrame::GetFrameBlock () const
|
|
{
|
|
SBBlock sb_block(m_opaque_sp->GetFrameBlock ());
|
|
return sb_block;
|
|
}
|
|
|
|
SBLineEntry
|
|
SBFrame::GetLineEntry () const
|
|
{
|
|
SBLineEntry sb_line_entry(&m_opaque_sp->GetSymbolContext (eSymbolContextLineEntry).line_entry);
|
|
return sb_line_entry;
|
|
}
|
|
|
|
uint32_t
|
|
SBFrame::GetFrameID () const
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetFrameIndex ();
|
|
else
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
lldb::addr_t
|
|
SBFrame::GetPC () const
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetPC ()");
|
|
|
|
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
|
|
if (m_opaque_sp)
|
|
addr = m_opaque_sp->GetFrameCodeAddress().GetLoadAddress (&m_opaque_sp->GetThread().GetProcess().GetTarget());
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetPC ==> %p", addr);
|
|
|
|
return addr;
|
|
}
|
|
|
|
bool
|
|
SBFrame::SetPC (lldb::addr_t new_pc)
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::SetPC (%p)", new_pc);
|
|
|
|
bool ret_val = false;
|
|
if (m_opaque_sp)
|
|
ret_val = m_opaque_sp->GetRegisterContext()->SetPC (new_pc);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::SetPC ==> %s", (ret_val ? "true" : "false"));
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
lldb::addr_t
|
|
SBFrame::GetSP () const
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetRegisterContext()->GetSP();
|
|
return LLDB_INVALID_ADDRESS;
|
|
}
|
|
|
|
|
|
lldb::addr_t
|
|
SBFrame::GetFP () const
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetFP ()");
|
|
|
|
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
|
|
if (m_opaque_sp)
|
|
addr = m_opaque_sp->GetRegisterContext()->GetFP();
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetFP ==> %p", addr);
|
|
|
|
return addr;
|
|
}
|
|
|
|
|
|
SBAddress
|
|
SBFrame::GetPCAddress () const
|
|
{
|
|
SBAddress sb_addr;
|
|
if (m_opaque_sp)
|
|
sb_addr.SetAddress (&m_opaque_sp->GetFrameCodeAddress());
|
|
return sb_addr;
|
|
}
|
|
|
|
void
|
|
SBFrame::Clear()
|
|
{
|
|
m_opaque_sp.reset();
|
|
}
|
|
|
|
SBValue
|
|
SBFrame::LookupVar (const char *var_name)
|
|
{
|
|
lldb::VariableSP var_sp;
|
|
if (IsValid ())
|
|
{
|
|
lldb_private::VariableList variable_list;
|
|
SBSymbolContext sc = GetSymbolContext (eSymbolContextEverything);
|
|
|
|
SBBlock block = sc.GetBlock();
|
|
if (block.IsValid())
|
|
block.AppendVariables (true, true, &variable_list);
|
|
|
|
const uint32_t num_variables = variable_list.GetSize();
|
|
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < num_variables && !found; ++i)
|
|
{
|
|
var_sp = variable_list.GetVariableAtIndex(i);
|
|
if (var_sp
|
|
&& (var_sp.get()->GetName() == lldb_private::ConstString(var_name)))
|
|
found = true;
|
|
}
|
|
if (!found)
|
|
var_sp.reset();
|
|
}
|
|
if (var_sp)
|
|
{
|
|
SBValue sb_value (ValueObjectSP (new ValueObjectVariable (var_sp)));
|
|
return sb_value;
|
|
}
|
|
|
|
SBValue sb_value;
|
|
return sb_value;
|
|
}
|
|
|
|
SBValue
|
|
SBFrame::LookupVarInScope (const char *var_name, const char *scope)
|
|
{
|
|
lldb::VariableSP var_sp;
|
|
if (IsValid())
|
|
{
|
|
std::string scope_str = scope;
|
|
lldb::ValueType var_scope = eValueTypeInvalid;
|
|
// Convert scope_str to be all lowercase;
|
|
std::transform (scope_str.begin(), scope_str.end(), scope_str.begin(), ::tolower);
|
|
|
|
if (scope_str.compare ("global") == 0)
|
|
var_scope = eValueTypeVariableGlobal;
|
|
else if (scope_str.compare ("local") == 0)
|
|
var_scope = eValueTypeVariableLocal;
|
|
else if (scope_str.compare ("parameter") == 0)
|
|
var_scope = eValueTypeVariableArgument;
|
|
|
|
if (var_scope != eValueTypeInvalid)
|
|
{
|
|
lldb_private::VariableList variable_list;
|
|
SBSymbolContext sc = GetSymbolContext (eSymbolContextEverything);
|
|
|
|
SBBlock block = sc.GetBlock();
|
|
if (block.IsValid())
|
|
block.AppendVariables (true, true, &variable_list);
|
|
|
|
const uint32_t num_variables = variable_list.GetSize();
|
|
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < num_variables && !found; ++i)
|
|
{
|
|
var_sp = variable_list.GetVariableAtIndex(i);
|
|
if (var_sp
|
|
&& (var_sp.get()->GetName() == lldb_private::ConstString(var_name))
|
|
&& var_sp.get()->GetScope() == var_scope)
|
|
found = true;
|
|
}
|
|
if (!found)
|
|
var_sp.reset();
|
|
}
|
|
}
|
|
|
|
if (var_sp)
|
|
{
|
|
SBValue sb_value (ValueObjectSP (new ValueObjectVariable (var_sp)));
|
|
return sb_value;
|
|
}
|
|
|
|
SBValue sb_value;
|
|
return sb_value;
|
|
}
|
|
|
|
bool
|
|
SBFrame::operator == (const SBFrame &rhs) const
|
|
{
|
|
return m_opaque_sp.get() == rhs.m_opaque_sp.get();
|
|
}
|
|
|
|
bool
|
|
SBFrame::operator != (const SBFrame &rhs) const
|
|
{
|
|
return m_opaque_sp.get() != rhs.m_opaque_sp.get();
|
|
}
|
|
|
|
lldb_private::StackFrame *
|
|
SBFrame::operator->() const
|
|
{
|
|
return m_opaque_sp.get();
|
|
}
|
|
|
|
lldb_private::StackFrame *
|
|
SBFrame::get() const
|
|
{
|
|
return m_opaque_sp.get();
|
|
}
|
|
|
|
|
|
SBThread
|
|
SBFrame::GetThread () const
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetThread ()");
|
|
|
|
SBThread sb_thread (m_opaque_sp->GetThread().GetSP());
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetThread ==> SBThread (this = %p)", &sb_thread);
|
|
|
|
return sb_thread;
|
|
}
|
|
|
|
const char *
|
|
SBFrame::Disassemble () const
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
Log *verbose_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
|
|
|
|
if (verbose_log)
|
|
verbose_log->Printf ("SBFrame::Disassemble () ==> %s", m_opaque_sp->Disassemble());
|
|
else if (log)
|
|
log->Printf ("SBFrame::Disassemble ()");
|
|
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->Disassemble();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
lldb_private::StackFrame *
|
|
SBFrame::GetLLDBObjectPtr ()
|
|
{
|
|
return m_opaque_sp.get();
|
|
}
|
|
|
|
SBValueList
|
|
SBFrame::GetVariables (bool arguments,
|
|
bool locals,
|
|
bool statics,
|
|
bool in_scope_only)
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBFrame::GetVariables (bool arguments, bool locals, bool statics, bool in_scope_only)");
|
|
log->Printf (" arguments = %s, locals = %s, statics = %s, in_scope_only = %s",
|
|
(arguments ? "true" : "false"),
|
|
(locals ? "true" : "false"),
|
|
(statics ? "true" : "false"),
|
|
(in_scope_only ? "true" : "false"));
|
|
}
|
|
|
|
SBValueList value_list;
|
|
if (m_opaque_sp)
|
|
{
|
|
size_t i;
|
|
VariableList *variable_list = m_opaque_sp->GetVariableList(true);
|
|
if (variable_list)
|
|
{
|
|
const size_t num_variables = variable_list->GetSize();
|
|
if (num_variables)
|
|
{
|
|
for (i = 0; i < num_variables; ++i)
|
|
{
|
|
VariableSP variable_sp (variable_list->GetVariableAtIndex(i));
|
|
if (variable_sp)
|
|
{
|
|
bool add_variable = false;
|
|
switch (variable_sp->GetScope())
|
|
{
|
|
case eValueTypeVariableGlobal:
|
|
case eValueTypeVariableStatic:
|
|
add_variable = statics;
|
|
break;
|
|
|
|
case eValueTypeVariableArgument:
|
|
add_variable = arguments;
|
|
break;
|
|
|
|
case eValueTypeVariableLocal:
|
|
add_variable = locals;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (add_variable)
|
|
{
|
|
if (in_scope_only && !variable_sp->IsInScope(m_opaque_sp.get()))
|
|
continue;
|
|
|
|
value_list.Append(m_opaque_sp->GetValueObjectForFrameVariable (variable_sp));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBFrame::GetVariables ==> SBValueList (this = %p)", &value_list);
|
|
//uint32_t num_vars = value_list.GetSize();
|
|
//for (uint32_t i = 0; i < num_vars; ++i)
|
|
//{
|
|
// SBValue value = value_list.GetValueAtIndex (i);
|
|
// log->Printf (" %s : %s", value.GetName(), value.GetObjectDescription (*this));
|
|
//}
|
|
}
|
|
|
|
return value_list;
|
|
}
|
|
|
|
lldb::SBValueList
|
|
SBFrame::GetRegisters ()
|
|
{
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
|
|
|
|
if (log)
|
|
log->Printf ("SBFrame::GetRegisters ()");
|
|
|
|
SBValueList value_list;
|
|
if (m_opaque_sp)
|
|
{
|
|
RegisterContext *reg_ctx = m_opaque_sp->GetRegisterContext();
|
|
if (reg_ctx)
|
|
{
|
|
const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
|
|
for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx)
|
|
{
|
|
value_list.Append(ValueObjectSP (new ValueObjectRegisterSet (NULL, reg_ctx, set_idx)));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
log->Printf ("SBFrame::Registers ==> SBValueList (this = %p)", &value_list );
|
|
//uint32_t num_vars = value_list.GetSize();
|
|
//for (uint32_t i = 0; i < num_vars; ++i)
|
|
//{
|
|
// SBValue value = value_list.GetValueAtIndex (i);
|
|
// log->Printf (" %s : %s", value.GetName(), value.GetObjectDescription (*this));
|
|
//}
|
|
}
|
|
|
|
return value_list;
|
|
}
|
|
|
|
bool
|
|
SBFrame::GetDescription (SBStream &description)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
description.Printf("SBFrame: idx = %u", m_opaque_sp->GetFrameIndex());
|
|
}
|
|
else
|
|
description.Printf ("No value");
|
|
|
|
return true;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBFrame::EvaluateExpression (const char *expr)
|
|
{
|
|
lldb::SBValue expr_result_value;
|
|
if (m_opaque_sp)
|
|
{
|
|
ExecutionContext exe_ctx;
|
|
m_opaque_sp->CalculateExecutionContext (exe_ctx);
|
|
*expr_result_value = ClangUserExpression::Evaluate (exe_ctx, expr);
|
|
}
|
|
return expr_result_value;
|
|
}
|