1 //===-- Disassembler.h ------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef liblldb_Disassembler_h_
11 #define liblldb_Disassembler_h_
18 // Other libraries and framework includes
20 #include "lldb/lldb-private.h"
21 #include "lldb/Core/Address.h"
22 #include "lldb/Core/ArchSpec.h"
23 #include "lldb/Core/EmulateInstruction.h"
24 #include "lldb/Core/Opcode.h"
25 #include "lldb/Core/PluginInterface.h"
26 #include "lldb/Interpreter/OptionValue.h"
28 namespace lldb_private {
33 Instruction (const Address &address,
34 lldb::AddressClass addr_class = lldb::eAddressClassInvalid);
46 GetMnemonic (const ExecutionContext* exe_ctx)
48 CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
49 return m_opcode_name.c_str();
52 GetOperands (const ExecutionContext* exe_ctx)
54 CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
55 return m_mnemonics.c_str();
59 GetComment (const ExecutionContext* exe_ctx)
61 CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
62 return m_comment.c_str();
66 CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx) = 0;
72 SetAddress (const Address &addr)
74 // Invalidate the address class to lazily discover
76 m_address_class = lldb::eAddressClassInvalid;
82 uint32_t max_opcode_byte_size,
85 const ExecutionContext* exe_ctx);
91 Decode (const Disassembler &disassembler,
92 const DataExtractor& data,
93 lldb::offset_t data_offset) = 0;
96 SetDescription (const char *) {} // May be overridden in sub-classes that have descriptions.
99 ReadArray (FILE *in_file, Stream *out_stream, OptionValue::Type data_type);
102 ReadDictionary (FILE *in_file, Stream *out_stream);
105 DumpEmulation (const ArchSpec &arch);
108 TestEmulation (Stream *stream, const char *test_file_name);
111 Emulate (const ArchSpec &arch,
112 uint32_t evaluate_options,
114 EmulateInstruction::ReadMemoryCallback read_mem_callback,
115 EmulateInstruction::WriteMemoryCallback write_mem_calback,
116 EmulateInstruction::ReadRegisterCallback read_reg_callback,
117 EmulateInstruction::WriteRegisterCallback write_reg_callback);
126 GetData (DataExtractor &data);
129 Address m_address; // The section offset address of this instruction
130 // We include an address class in the Instruction class to
131 // allow the instruction specify the eAddressClassCodeAlternateISA
132 // (currently used for thumb), and also to specify data (eAddressClassData).
133 // The usual value will be eAddressClassCode, but often when
134 // disassembling memory, you might run into data. This can
135 // help us to disassemble appropriately.
137 lldb::AddressClass m_address_class; // Use GetAddressClass () accessor function!
139 Opcode m_opcode; // The opcode for this instruction
140 std::string m_opcode_name;
141 std::string m_mnemonics;
142 std::string m_comment;
143 bool m_calculated_strings;
146 CalculateMnemonicOperandsAndCommentIfNeeded (const ExecutionContext* exe_ctx)
148 if (!m_calculated_strings)
150 m_calculated_strings = true;
151 CalculateMnemonicOperandsAndComment(exe_ctx);
157 class InstructionList
167 GetMaxOpcocdeByteSize () const;
170 GetInstructionAtIndex (size_t idx) const;
173 GetIndexOfNextBranchInstruction(uint32_t start) const;
176 GetIndexOfInstructionAtLoadAddress (lldb::addr_t load_addr, Target &target);
179 GetIndexOfInstructionAtAddress (const Address &addr);
185 Append (lldb::InstructionSP &inst_sp);
191 const ExecutionContext* exe_ctx);
194 typedef std::vector<lldb::InstructionSP> collection;
195 typedef collection::iterator iterator;
196 typedef collection::const_iterator const_iterator;
198 collection m_instructions;
201 class PseudoInstruction :
206 PseudoInstruction ();
209 ~PseudoInstruction ();
215 CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx)
217 // TODO: fill this in and put opcode name into Instruction::m_opcode_name,
218 // mnemonic into Instruction::m_mnemonics, and any comment into
219 // Instruction::m_comment
223 Decode (const Disassembler &disassembler,
224 const DataExtractor &data,
225 lldb::offset_t data_offset);
228 SetOpcode (size_t opcode_size, void *opcode_data);
231 SetDescription (const char *description);
234 std::string m_description;
236 DISALLOW_COPY_AND_ASSIGN (PseudoInstruction);
240 public std::enable_shared_from_this<Disassembler>,
241 public PluginInterface
248 eOptionShowBytes = (1u << 0),
249 eOptionRawOuput = (1u << 1),
250 eOptionMarkPCSourceLine = (1u << 2), // Mark the source line that contains the current PC (mixed mode only)
251 eOptionMarkPCAddress = (1u << 3) // Mark the disassembly line the contains the PC
254 enum HexImmediateStyle
260 // FindPlugin should be lax about the flavor string (it is too annoying to have various internal uses of the
261 // disassembler fail because the global flavor string gets set wrong. Instead, if you get a flavor string you
262 // don't understand, use the default. Folks who care to check can use the FlavorValidForArchSpec method on the
263 // disassembler they got back.
264 static lldb::DisassemblerSP
265 FindPlugin (const ArchSpec &arch, const char *flavor, const char *plugin_name);
267 // This version will use the value in the Target settings if flavor is NULL;
268 static lldb::DisassemblerSP
269 FindPluginForTarget(const lldb::TargetSP target_sp, const ArchSpec &arch, const char *flavor, const char *plugin_name);
271 static lldb::DisassemblerSP
272 DisassembleRange (const ArchSpec &arch,
273 const char *plugin_name,
275 const ExecutionContext &exe_ctx,
276 const AddressRange &disasm_range,
277 bool prefer_file_cache);
279 static lldb::DisassemblerSP
280 DisassembleBytes (const ArchSpec &arch,
281 const char *plugin_name,
283 const Address &start,
286 uint32_t max_num_instructions,
287 bool data_from_file);
290 Disassemble (Debugger &debugger,
291 const ArchSpec &arch,
292 const char *plugin_name,
294 const ExecutionContext &exe_ctx,
295 const AddressRange &range,
296 uint32_t num_instructions,
297 uint32_t num_mixed_context_lines,
302 Disassemble (Debugger &debugger,
303 const ArchSpec &arch,
304 const char *plugin_name,
306 const ExecutionContext &exe_ctx,
307 const Address &start,
308 uint32_t num_instructions,
309 uint32_t num_mixed_context_lines,
314 Disassemble (Debugger &debugger,
315 const ArchSpec &arch,
316 const char *plugin_name,
318 const ExecutionContext &exe_ctx,
319 SymbolContextList &sc_list,
320 uint32_t num_instructions,
321 uint32_t num_mixed_context_lines,
326 Disassemble (Debugger &debugger,
327 const ArchSpec &arch,
328 const char *plugin_name,
330 const ExecutionContext &exe_ctx,
331 const ConstString &name,
333 uint32_t num_instructions,
334 uint32_t num_mixed_context_lines,
339 Disassemble (Debugger &debugger,
340 const ArchSpec &arch,
341 const char *plugin_name,
343 const ExecutionContext &exe_ctx,
344 uint32_t num_instructions,
345 uint32_t num_mixed_context_lines,
349 //------------------------------------------------------------------
350 // Constructors and Destructors
351 //------------------------------------------------------------------
352 Disassembler(const ArchSpec &arch, const char *flavor);
353 virtual ~Disassembler();
355 typedef const char * (*SummaryCallback)(const Instruction& inst, ExecutionContext *exe_context, void *user_data);
358 PrintInstructions (Disassembler *disasm_ptr,
360 const ArchSpec &arch,
361 const ExecutionContext &exe_ctx,
362 uint32_t num_instructions,
363 uint32_t num_mixed_context_lines,
368 ParseInstructions (const ExecutionContext *exe_ctx,
369 const AddressRange &range,
370 Stream *error_strm_ptr,
371 bool prefer_file_cache);
374 ParseInstructions (const ExecutionContext *exe_ctx,
375 const Address &range,
376 uint32_t num_instructions,
377 bool prefer_file_cache);
380 DecodeInstructions (const Address &base_addr,
381 const DataExtractor& data,
382 lldb::offset_t data_offset,
383 size_t num_instructions,
385 bool data_from_file) = 0;
388 GetInstructionList ();
390 const InstructionList &
391 GetInstructionList () const;
394 GetArchitecture () const
402 return m_flavor.c_str();
406 FlavorValidForArchSpec (const lldb_private::ArchSpec &arch, const char *flavor) = 0;
409 //------------------------------------------------------------------
410 // Classes that inherit from Disassembler can see and modify these
411 //------------------------------------------------------------------
412 const ArchSpec m_arch;
413 InstructionList m_instruction_list;
414 lldb::addr_t m_base_addr;
415 std::string m_flavor;
418 //------------------------------------------------------------------
419 // For Disassembler only
420 //------------------------------------------------------------------
421 DISALLOW_COPY_AND_ASSIGN (Disassembler);
424 } // namespace lldb_private
426 #endif // liblldb_Disassembler_h_