contrib/llvm/tools/lldb/source/API/SBInstruction.cpp

   1 //===-- SBInstruction.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBInstruction.h"
  11
  12 #include "lldb/API/SBAddress.h"
  13 #include "lldb/API/SBFrame.h"
  14 #include "lldb/API/SBInstruction.h"
  15 #include "lldb/API/SBStream.h"
  16 #include "lldb/API/SBTarget.h"
  17
  18 #include "lldb/Core/ArchSpec.h"
  19 #include "lldb/Core/DataBufferHeap.h"
  20 #include "lldb/Core/DataExtractor.h"
  21 #include "lldb/Core/Disassembler.h"
  22 #include "lldb/Core/EmulateInstruction.h"
  23 #include "lldb/Core/StreamFile.h"
  24 #include "lldb/Target/ExecutionContext.h"
  25 #include "lldb/Target/StackFrame.h"
  26 #include "lldb/Target/Target.h"
  27
  28 using namespace lldb;
  29 using namespace lldb_private;
  30
  31 SBInstruction::SBInstruction ()
  32 {
  33 }
  34
  35 SBInstruction::SBInstruction (const lldb::InstructionSP& inst_sp) :
  36     m_opaque_sp (inst_sp)
  37 {
  38 }
  39
  40 SBInstruction::SBInstruction(const SBInstruction &rhs) :
  41     m_opaque_sp (rhs.m_opaque_sp)
  42 {
  43 }
  44
  45 const SBInstruction &
  46 SBInstruction::operator = (const SBInstruction &rhs)
  47 {
  48     if (this != &rhs)
  49         m_opaque_sp = rhs.m_opaque_sp;
  50     return *this;
  51 }
  52
  53 SBInstruction::~SBInstruction ()
  54 {
  55 }
  56
  57 bool
  58 SBInstruction::IsValid()
  59 {
  60     return (m_opaque_sp.get() != NULL);
  61 }
  62
  63 SBAddress
  64 SBInstruction::GetAddress()
  65 {
  66     SBAddress sb_addr;
  67     if (m_opaque_sp && m_opaque_sp->GetAddress().IsValid())
  68         sb_addr.SetAddress(&m_opaque_sp->GetAddress());
  69     return sb_addr;
  70 }
  71
  72 const char *
  73 SBInstruction::GetMnemonic(SBTarget target)
  74 {
  75     if (m_opaque_sp)
  76     {
  77         Mutex::Locker api_locker;
  78         ExecutionContext exe_ctx;
  79         TargetSP target_sp (target.GetSP());
  80         if (target_sp)
  81         {
  82             api_locker.Lock (target_sp->GetAPIMutex());
  83             target_sp->CalculateExecutionContext (exe_ctx);
  84             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
  85         }
  86         return m_opaque_sp->GetMnemonic(&exe_ctx);
  87     }
  88     return NULL;
  89 }
  90
  91 const char *
  92 SBInstruction::GetOperands(SBTarget target)
  93 {
  94     if (m_opaque_sp)
  95     {
  96         Mutex::Locker api_locker;
  97         ExecutionContext exe_ctx;
  98         TargetSP target_sp (target.GetSP());
  99         if (target_sp)
 100         {
 101             api_locker.Lock (target_sp->GetAPIMutex());
 102             target_sp->CalculateExecutionContext (exe_ctx);
 103             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
 104         }
 105         return m_opaque_sp->GetOperands(&exe_ctx);
 106     }
 107     return NULL;
 108 }
 109
 110 const char *
 111 SBInstruction::GetComment(SBTarget target)
 112 {
 113     if (m_opaque_sp)
 114     {
 115         Mutex::Locker api_locker;
 116         ExecutionContext exe_ctx;
 117         TargetSP target_sp (target.GetSP());
 118         if (target_sp)
 119         {
 120             api_locker.Lock (target_sp->GetAPIMutex());
 121             target_sp->CalculateExecutionContext (exe_ctx);
 122             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
 123         }
 124         return m_opaque_sp->GetComment(&exe_ctx);
 125     }
 126     return NULL;
 127 }
 128
 129 size_t
 130 SBInstruction::GetByteSize ()
 131 {
 132     if (m_opaque_sp)
 133         return m_opaque_sp->GetOpcode().GetByteSize();
 134     return 0;
 135 }
 136
 137 SBData
 138 SBInstruction::GetData (SBTarget target)
 139 {
 140     lldb::SBData sb_data;
 141     if (m_opaque_sp)
 142     {
 143         DataExtractorSP data_extractor_sp (new DataExtractor());
 144         if (m_opaque_sp->GetData (*data_extractor_sp))
 145         {
 146             sb_data.SetOpaque (data_extractor_sp);
 147         }
 148     }
 149     return sb_data;
 150 }
 151
 152
 153
 154 bool
 155 SBInstruction::DoesBranch ()
 156 {
 157     if (m_opaque_sp)
 158         return m_opaque_sp->DoesBranch ();
 159     return false;
 160 }
 161
 162 void
 163 SBInstruction::SetOpaque (const lldb::InstructionSP &inst_sp)
 164 {
 165     m_opaque_sp = inst_sp;
 166 }
 167
 168 bool
 169 SBInstruction::GetDescription (lldb::SBStream &s)
 170 {
 171     if (m_opaque_sp)
 172     {
 173         // Use the "ref()" instead of the "get()" accessor in case the SBStream
 174         // didn't have a stream already created, one will get created...
 175         m_opaque_sp->Dump (&s.ref(), 0, true, false, NULL);
 176         return true;
 177     }
 178     return false;
 179 }
 180
 181 void
 182 SBInstruction::Print (FILE *out)
 183 {
 184     if (out == NULL)
 185         return;
 186
 187     if (m_opaque_sp)
 188     {
 189         StreamFile out_stream (out, false);
 190         m_opaque_sp->Dump (&out_stream, 0, true, false, NULL);
 191     }
 192 }
 193
 194 bool
 195 SBInstruction::EmulateWithFrame (lldb::SBFrame &frame, uint32_t evaluate_options)
 196 {
 197     if (m_opaque_sp)
 198     {
 199         lldb::StackFrameSP frame_sp (frame.GetFrameSP());
 200
 201         if (frame_sp)
 202         {
 203             lldb_private::ExecutionContext exe_ctx;
 204             frame_sp->CalculateExecutionContext (exe_ctx);
 205             lldb_private::Target *target = exe_ctx.GetTargetPtr();
 206             lldb_private::ArchSpec arch = target->GetArchitecture();
 207
 208             return m_opaque_sp->Emulate (arch,
 209                                          evaluate_options,
 210                                          (void *) frame_sp.get(),
 211                                          &lldb_private::EmulateInstruction::ReadMemoryFrame,
 212                                          &lldb_private::EmulateInstruction::WriteMemoryFrame,
 213                                          &lldb_private::EmulateInstruction::ReadRegisterFrame,
 214                                          &lldb_private::EmulateInstruction::WriteRegisterFrame);
 215         }
 216     }
 217     return false;
 218 }
 219
 220 bool
 221 SBInstruction::DumpEmulation (const char *triple)
 222 {
 223     if (m_opaque_sp && triple)
 224     {
 225         lldb_private::ArchSpec arch (triple, NULL);
 226
 227         return m_opaque_sp->DumpEmulation (arch);
 228
 229     }
 230     return false;
 231 }
 232
 233 bool
 234 SBInstruction::TestEmulation (lldb::SBStream &output_stream,  const char *test_file)
 235 {
 236     if (!m_opaque_sp.get())
 237         m_opaque_sp.reset (new PseudoInstruction());
 238
 239     return m_opaque_sp->TestEmulation (output_stream.get(), test_file);
 240 }
 241
 242 lldb::AddressClass
 243 SBInstruction::GetAddressClass ()
 244 {
 245     if (m_opaque_sp.get())
 246         return m_opaque_sp->GetAddressClass();
 247     return eAddressClassInvalid;
 248 }