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/Module.h"
24 #include "lldb/Core/StreamFile.h"
25 #include "lldb/Target/ExecutionContext.h"
26 #include "lldb/Target/StackFrame.h"
27 #include "lldb/Target/Target.h"
28 
29 //----------------------------------------------------------------------
30 // We recently fixed a leak in one of the Instruction subclasses where
31 // the instruction will only hold a weak reference to the disassembler
32 // to avoid a cycle that was keeping both objects alive (leak) and we
33 // need the InstructionImpl class to make sure our public API behaves
34 // as users would expect. Calls in our public API allow clients to do
35 // things like:
36 //
37 // 1  lldb::SBInstruction inst;
38 // 2  inst = target.ReadInstructions(pc, 1).GetInstructionAtIndex(0)
39 // 3  if (inst.DoesBranch())
40 // 4  ...
41 //
42 // There was a temporary lldb::DisassemblerSP object created in the
43 // SBInstructionList that was returned by lldb.target.ReadInstructions()
44 // that will go away after line 2 but the "inst" object should be able
45 // to still answer questions about itself. So we make sure that any
46 // SBInstruction objects that are given out have a strong reference to
47 // the disassembler and the instruction so that the object can live and
48 // successfully respond to all queries.
49 //----------------------------------------------------------------------
50 class InstructionImpl
51 {
52 public:
53     InstructionImpl (const lldb::DisassemblerSP &disasm_sp, const lldb::InstructionSP& inst_sp) :
54         m_disasm_sp(disasm_sp),
55         m_inst_sp(inst_sp)
56     {
57     }
58 
59     lldb::InstructionSP
60     GetSP() const
61     {
62         return m_inst_sp;
63     }
64 
65     bool
66     IsValid() const
67     {
68         return (bool)m_inst_sp;
69     }
70 
71 protected:
72     lldb::DisassemblerSP m_disasm_sp; // Can be empty/invalid
73     lldb::InstructionSP m_inst_sp;
74 };
75 
76 using namespace lldb;
77 using namespace lldb_private;
78 
79 SBInstruction::SBInstruction() :
80     m_opaque_sp()
81 {
82 }
83 
84 SBInstruction::SBInstruction(const lldb::DisassemblerSP &disasm_sp, const lldb::InstructionSP& inst_sp) :
85     m_opaque_sp(new InstructionImpl(disasm_sp, inst_sp))
86 {
87 }
88 
89 SBInstruction::SBInstruction(const SBInstruction &rhs) :
90     m_opaque_sp (rhs.m_opaque_sp)
91 {
92 }
93 
94 const SBInstruction &
95 SBInstruction::operator = (const SBInstruction &rhs)
96 {
97     if (this != &rhs)
98         m_opaque_sp = rhs.m_opaque_sp;
99     return *this;
100 }
101 
102 SBInstruction::~SBInstruction ()
103 {
104 }
105 
106 bool
107 SBInstruction::IsValid()
108 {
109     return m_opaque_sp && m_opaque_sp->IsValid();
110 }
111 
112 SBAddress
113 SBInstruction::GetAddress()
114 {
115     SBAddress sb_addr;
116     lldb::InstructionSP inst_sp(GetOpaque());
117     if (inst_sp && inst_sp->GetAddress().IsValid())
118         sb_addr.SetAddress(&inst_sp->GetAddress());
119     return sb_addr;
120 }
121 
122 const char *
123 SBInstruction::GetMnemonic(SBTarget target)
124 {
125     lldb::InstructionSP inst_sp(GetOpaque());
126     if (inst_sp)
127     {
128         ExecutionContext exe_ctx;
129         TargetSP target_sp (target.GetSP());
130         std::unique_lock<std::recursive_mutex> lock;
131         if (target_sp)
132         {
133             lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
134 
135             target_sp->CalculateExecutionContext (exe_ctx);
136             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
137         }
138         return inst_sp->GetMnemonic(&exe_ctx);
139     }
140     return NULL;
141 }
142 
143 const char *
144 SBInstruction::GetOperands(SBTarget target)
145 {
146     lldb::InstructionSP inst_sp(GetOpaque());
147     if (inst_sp)
148     {
149         ExecutionContext exe_ctx;
150         TargetSP target_sp (target.GetSP());
151         std::unique_lock<std::recursive_mutex> lock;
152         if (target_sp)
153         {
154             lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
155 
156             target_sp->CalculateExecutionContext (exe_ctx);
157             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
158         }
159         return inst_sp->GetOperands(&exe_ctx);
160     }
161     return NULL;
162 }
163 
164 const char *
165 SBInstruction::GetComment(SBTarget target)
166 {
167     lldb::InstructionSP inst_sp(GetOpaque());
168     if (inst_sp)
169     {
170         ExecutionContext exe_ctx;
171         TargetSP target_sp (target.GetSP());
172         std::unique_lock<std::recursive_mutex> lock;
173         if (target_sp)
174         {
175             lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
176 
177             target_sp->CalculateExecutionContext (exe_ctx);
178             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
179         }
180         return inst_sp->GetComment(&exe_ctx);
181     }
182     return NULL;
183 }
184 
185 size_t
186 SBInstruction::GetByteSize ()
187 {
188     lldb::InstructionSP inst_sp(GetOpaque());
189     if (inst_sp)
190         return inst_sp->GetOpcode().GetByteSize();
191     return 0;
192 }
193 
194 SBData
195 SBInstruction::GetData (SBTarget target)
196 {
197     lldb::SBData sb_data;
198     lldb::InstructionSP inst_sp(GetOpaque());
199     if (inst_sp)
200     {
201         DataExtractorSP data_extractor_sp (new DataExtractor());
202         if (inst_sp->GetData (*data_extractor_sp))
203         {
204             sb_data.SetOpaque (data_extractor_sp);
205         }
206     }
207     return sb_data;
208 }
209 
210 
211 
212 bool
213 SBInstruction::DoesBranch ()
214 {
215     lldb::InstructionSP inst_sp(GetOpaque());
216     if (inst_sp)
217         return inst_sp->DoesBranch ();
218     return false;
219 }
220 
221 bool
222 SBInstruction::HasDelaySlot ()
223 {
224     lldb::InstructionSP inst_sp(GetOpaque());
225     if (inst_sp)
226         return inst_sp->HasDelaySlot ();
227     return false;
228 }
229 
230 lldb::InstructionSP
231 SBInstruction::GetOpaque ()
232 {
233     if (m_opaque_sp)
234         return m_opaque_sp->GetSP();
235     else
236         return lldb::InstructionSP();
237 }
238 
239 void
240 SBInstruction::SetOpaque (const lldb::DisassemblerSP &disasm_sp, const lldb::InstructionSP& inst_sp)
241 {
242     m_opaque_sp.reset(new InstructionImpl(disasm_sp, inst_sp));
243 }
244 
245 bool
246 SBInstruction::GetDescription (lldb::SBStream &s)
247 {
248     lldb::InstructionSP inst_sp(GetOpaque());
249     if (inst_sp)
250     {
251         SymbolContext sc;
252         const Address &addr = inst_sp->GetAddress();
253         ModuleSP module_sp (addr.GetModule());
254         if (module_sp)
255             module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything, sc);
256         // Use the "ref()" instead of the "get()" accessor in case the SBStream
257         // didn't have a stream already created, one will get created...
258         FormatEntity::Entry format;
259         FormatEntity::Parse("${addr}: ", format);
260         inst_sp->Dump (&s.ref(), 0, true, false, NULL, &sc, NULL, &format, 0);
261         return true;
262     }
263     return false;
264 }
265 
266 void
267 SBInstruction::Print (FILE *out)
268 {
269     if (out == NULL)
270         return;
271 
272     lldb::InstructionSP inst_sp(GetOpaque());
273     if (inst_sp)
274     {
275         SymbolContext sc;
276         const Address &addr = inst_sp->GetAddress();
277         ModuleSP module_sp (addr.GetModule());
278         if (module_sp)
279             module_sp->ResolveSymbolContextForAddress(addr, eSymbolContextEverything, sc);
280         StreamFile out_stream (out, false);
281         FormatEntity::Entry format;
282         FormatEntity::Parse("${addr}: ", format);
283         inst_sp->Dump (&out_stream, 0, true, false, NULL, &sc, NULL, &format, 0);
284     }
285 }
286 
287 bool
288 SBInstruction::EmulateWithFrame (lldb::SBFrame &frame, uint32_t evaluate_options)
289 {
290     lldb::InstructionSP inst_sp(GetOpaque());
291     if (inst_sp)
292     {
293         lldb::StackFrameSP frame_sp (frame.GetFrameSP());
294 
295         if (frame_sp)
296         {
297             lldb_private::ExecutionContext exe_ctx;
298             frame_sp->CalculateExecutionContext (exe_ctx);
299             lldb_private::Target *target = exe_ctx.GetTargetPtr();
300             lldb_private::ArchSpec arch = target->GetArchitecture();
301 
302             return inst_sp->Emulate(arch,
303                                     evaluate_options,
304                                     (void *) frame_sp.get(),
305                                     &lldb_private::EmulateInstruction::ReadMemoryFrame,
306                                     &lldb_private::EmulateInstruction::WriteMemoryFrame,
307                                     &lldb_private::EmulateInstruction::ReadRegisterFrame,
308                                     &lldb_private::EmulateInstruction::WriteRegisterFrame);
309         }
310     }
311     return false;
312 }
313 
314 bool
315 SBInstruction::DumpEmulation (const char *triple)
316 {
317     lldb::InstructionSP inst_sp(GetOpaque());
318     if (inst_sp && triple)
319     {
320         lldb_private::ArchSpec arch (triple, NULL);
321         return inst_sp->DumpEmulation (arch);
322     }
323     return false;
324 }
325 
326 bool
327 SBInstruction::TestEmulation (lldb::SBStream &output_stream, const char *test_file)
328 {
329     if (!m_opaque_sp)
330         SetOpaque(lldb::DisassemblerSP(), lldb::InstructionSP(new PseudoInstruction()));
331 
332     lldb::InstructionSP inst_sp(GetOpaque());
333     if (inst_sp)
334         return inst_sp->TestEmulation (output_stream.get(), test_file);
335     return false;
336 }
337 
338 lldb::AddressClass
339 SBInstruction::GetAddressClass ()
340 {
341     lldb::InstructionSP inst_sp(GetOpaque());
342     if (inst_sp)
343         return inst_sp->GetAddressClass();
344     return eAddressClassInvalid;
345 }
346