c14ee32db5
shared pointers. Changed the ExecutionContext over to use shared pointers for the target, process, thread and frame since these objects can easily go away at any time and any object that was holding onto an ExecutionContext was running the risk of using a bad object. Now that the shared pointers for target, process, thread and frame are just a single pointer (they all use the instrusive shared pointers) the execution context is much safer and still the same size. Made the shared pointers in the the ExecutionContext class protected and made accessors for all of the various ways to get at the pointers, references, and shared pointers. llvm-svn: 140298
160 lines
3.8 KiB
C++
160 lines
3.8 KiB
C++
//===-- SBInstruction.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/SBInstruction.h"
|
|
|
|
#include "lldb/API/SBAddress.h"
|
|
#include "lldb/API/SBFrame.h"
|
|
#include "lldb/API/SBInstruction.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBTarget.h"
|
|
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/Disassembler.h"
|
|
#include "lldb/Core/EmulateInstruction.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/StackFrame.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
SBInstruction::SBInstruction ()
|
|
{
|
|
}
|
|
|
|
SBInstruction::SBInstruction (const lldb::InstructionSP& inst_sp) :
|
|
m_opaque_sp (inst_sp)
|
|
{
|
|
}
|
|
|
|
SBInstruction::SBInstruction(const SBInstruction &rhs) :
|
|
m_opaque_sp (rhs.m_opaque_sp)
|
|
{
|
|
}
|
|
|
|
const SBInstruction &
|
|
SBInstruction::operator = (const SBInstruction &rhs)
|
|
{
|
|
if (this != &rhs)
|
|
m_opaque_sp = rhs.m_opaque_sp;
|
|
return *this;
|
|
}
|
|
|
|
SBInstruction::~SBInstruction ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
SBInstruction::IsValid()
|
|
{
|
|
return (m_opaque_sp.get() != NULL);
|
|
}
|
|
|
|
SBAddress
|
|
SBInstruction::GetAddress()
|
|
{
|
|
SBAddress sb_addr;
|
|
if (m_opaque_sp && m_opaque_sp->GetAddress().IsValid())
|
|
sb_addr.SetAddress(&m_opaque_sp->GetAddress());
|
|
return sb_addr;
|
|
}
|
|
|
|
size_t
|
|
SBInstruction::GetByteSize ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetOpcode().GetByteSize();
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
SBInstruction::DoesBranch ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->DoesBranch ();
|
|
return false;
|
|
}
|
|
|
|
void
|
|
SBInstruction::SetOpaque (const lldb::InstructionSP &inst_sp)
|
|
{
|
|
m_opaque_sp = inst_sp;
|
|
}
|
|
|
|
bool
|
|
SBInstruction::GetDescription (lldb::SBStream &s)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
// Use the "ref()" instead of the "get()" accessor in case the SBStream
|
|
// didn't have a stream already created, one will get created...
|
|
m_opaque_sp->Dump (&s.ref(), 0, true, false, NULL, false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
SBInstruction::Print (FILE *out)
|
|
{
|
|
if (out == NULL)
|
|
return;
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
StreamFile out_stream (out, false);
|
|
m_opaque_sp->Dump (&out_stream, 0, true, false, NULL, false);
|
|
}
|
|
}
|
|
|
|
bool
|
|
SBInstruction::EmulateWithFrame (lldb::SBFrame &frame, uint32_t evaluate_options)
|
|
{
|
|
if (m_opaque_sp && frame.get())
|
|
{
|
|
lldb_private::ExecutionContext exe_ctx;
|
|
frame->CalculateExecutionContext (exe_ctx);
|
|
lldb_private::Target *target = exe_ctx.GetTargetPtr();
|
|
lldb_private::ArchSpec arch = target->GetArchitecture();
|
|
|
|
return m_opaque_sp->Emulate (arch,
|
|
evaluate_options,
|
|
(void *) frame.get(),
|
|
&lldb_private::EmulateInstruction::ReadMemoryFrame,
|
|
&lldb_private::EmulateInstruction::WriteMemoryFrame,
|
|
&lldb_private::EmulateInstruction::ReadRegisterFrame,
|
|
&lldb_private::EmulateInstruction::WriteRegisterFrame);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBInstruction::DumpEmulation (const char *triple)
|
|
{
|
|
if (m_opaque_sp && triple)
|
|
{
|
|
lldb_private::ArchSpec arch (triple, NULL);
|
|
|
|
return m_opaque_sp->DumpEmulation (arch);
|
|
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBInstruction::TestEmulation (lldb::SBStream &output_stream, const char *test_file)
|
|
{
|
|
if (!m_opaque_sp.get())
|
|
m_opaque_sp.reset (new PseudoInstruction());
|
|
|
|
return m_opaque_sp->TestEmulation (output_stream.get(), test_file);
|
|
}
|