contrib/llvm/tools/lldb/include/lldb/Core/Disassembler.h

   1 //===-- Disassembler.h ------------------------------------------*- 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 #ifndef liblldb_Disassembler_h_
  11 #define liblldb_Disassembler_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <vector>
  16 #include <string>
  17
  18 // Other libraries and framework includes
  19 // Project 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"
  27
  28 namespace lldb_private {
  29
  30 class Instruction
  31 {
  32 public:
  33     Instruction (const Address &address,
  34                  lldb::AddressClass addr_class = lldb::eAddressClassInvalid);
  35
  36     virtual
  37    ~Instruction();
  38
  39     const Address &
  40     GetAddress () const
  41     {
  42         return m_address;
  43     }
  44
  45     const char *
  46     GetMnemonic (const ExecutionContext* exe_ctx)
  47     {
  48         CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
  49         return m_opcode_name.c_str();
  50     }
  51     const char *
  52     GetOperands (const ExecutionContext* exe_ctx)
  53     {
  54         CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
  55         return m_mnemonics.c_str();
  56     }
  57
  58     const char *
  59     GetComment (const ExecutionContext* exe_ctx)
  60     {
  61         CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
  62         return m_comment.c_str();
  63     }
  64
  65     virtual void
  66     CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx) = 0;
  67
  68     lldb::AddressClass
  69     GetAddressClass ();
  70
  71     void
  72     SetAddress (const Address &addr)
  73     {
  74         // Invalidate the address class to lazily discover
  75         // it if we need to.
  76         m_address_class = lldb::eAddressClassInvalid;
  77         m_address = addr;
  78     }
  79
  80     virtual void
  81     Dump (Stream *s,
  82           uint32_t max_opcode_byte_size,
  83           bool show_address,
  84           bool show_bytes,
  85           const ExecutionContext* exe_ctx);
  86
  87     virtual bool
  88     DoesBranch () = 0;
  89
  90     virtual size_t
  91     Decode (const Disassembler &disassembler,
  92             const DataExtractor& data,
  93             lldb::offset_t data_offset) = 0;
  94
  95     virtual void
  96     SetDescription (const char *) {}  // May be overridden in sub-classes that have descriptions.
  97
  98     lldb::OptionValueSP
  99     ReadArray (FILE *in_file, Stream *out_stream, OptionValue::Type data_type);
 100
 101     lldb::OptionValueSP
 102     ReadDictionary (FILE *in_file, Stream *out_stream);
 103
 104     bool
 105     DumpEmulation (const ArchSpec &arch);
 106
 107     virtual bool
 108     TestEmulation (Stream *stream, const char *test_file_name);
 109
 110     bool
 111     Emulate (const ArchSpec &arch,
 112              uint32_t evaluate_options,
 113              void *baton,
 114              EmulateInstruction::ReadMemoryCallback read_mem_callback,
 115              EmulateInstruction::WriteMemoryCallback write_mem_calback,
 116              EmulateInstruction::ReadRegisterCallback read_reg_callback,
 117              EmulateInstruction::WriteRegisterCallback write_reg_callback);
 118
 119     const Opcode &
 120     GetOpcode () const
 121     {
 122         return m_opcode;
 123     }
 124
 125     uint32_t
 126     GetData (DataExtractor &data);
 127
 128 protected:
 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.
 136 private:
 137     lldb::AddressClass m_address_class; // Use GetAddressClass () accessor function!
 138 protected:
 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;
 144
 145     void
 146     CalculateMnemonicOperandsAndCommentIfNeeded (const ExecutionContext* exe_ctx)
 147     {
 148         if (!m_calculated_strings)
 149         {
 150             m_calculated_strings = true;
 151             CalculateMnemonicOperandsAndComment(exe_ctx);
 152         }
 153     }
 154 };
 155
 156
 157 class InstructionList
 158 {
 159 public:
 160     InstructionList();
 161     ~InstructionList();
 162
 163     size_t
 164     GetSize() const;
 165
 166     uint32_t
 167     GetMaxOpcocdeByteSize () const;
 168
 169     lldb::InstructionSP
 170     GetInstructionAtIndex (size_t idx) const;
 171
 172     uint32_t
 173     GetIndexOfNextBranchInstruction(uint32_t start) const;
 174
 175     uint32_t
 176     GetIndexOfInstructionAtLoadAddress (lldb::addr_t load_addr, Target &target);
 177
 178     void
 179     Clear();
 180
 181     void
 182     Append (lldb::InstructionSP &inst_sp);
 183
 184     void
 185     Dump (Stream *s,
 186           bool show_address,
 187           bool show_bytes,
 188           const ExecutionContext* exe_ctx);
 189
 190 private:
 191     typedef std::vector<lldb::InstructionSP> collection;
 192     typedef collection::iterator iterator;
 193     typedef collection::const_iterator const_iterator;
 194
 195     collection m_instructions;
 196 };
 197
 198 class PseudoInstruction :
 199     public Instruction
 200 {
 201 public:
 202
 203     PseudoInstruction ();
 204
 205      virtual
 206      ~PseudoInstruction ();
 207
 208     virtual bool
 209     DoesBranch ();
 210
 211     virtual void
 212     CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx)
 213     {
 214         // TODO: fill this in and put opcode name into Instruction::m_opcode_name,
 215         // mnemonic into Instruction::m_mnemonics, and any comment into
 216         // Instruction::m_comment
 217     }
 218
 219     virtual size_t
 220     Decode (const Disassembler &disassembler,
 221             const DataExtractor &data,
 222             lldb::offset_t data_offset);
 223
 224     void
 225     SetOpcode (size_t opcode_size, void *opcode_data);
 226
 227     virtual void
 228     SetDescription (const char *description);
 229
 230 protected:
 231     std::string m_description;
 232
 233     DISALLOW_COPY_AND_ASSIGN (PseudoInstruction);
 234 };
 235
 236 class Disassembler :
 237     public std::enable_shared_from_this<Disassembler>,
 238     public PluginInterface
 239 {
 240 public:
 241
 242     enum
 243     {
 244         eOptionNone             = 0u,
 245         eOptionShowBytes        = (1u << 0),
 246         eOptionRawOuput         = (1u << 1),
 247         eOptionMarkPCSourceLine = (1u << 2), // Mark the source line that contains the current PC (mixed mode only)
 248         eOptionMarkPCAddress    = (1u << 3)  // Mark the disassembly line the contains the PC
 249     };
 250
 251     enum HexImmediateStyle
 252     {
 253         eHexStyleC,
 254         eHexStyleAsm,
 255     };
 256
 257     // FindPlugin should be lax about the flavor string (it is too annoying to have various internal uses of the
 258     // disassembler fail because the global flavor string gets set wrong.  Instead, if you get a flavor string you
 259     // don't understand, use the default.  Folks who care to check can use the FlavorValidForArchSpec method on the
 260     // disassembler they got back.
 261     static lldb::DisassemblerSP
 262     FindPlugin (const ArchSpec &arch, const char *flavor, const char *plugin_name);
 263
 264     // This version will use the value in the Target settings if flavor is NULL;
 265     static lldb::DisassemblerSP
 266     FindPluginForTarget(const lldb::TargetSP target_sp, const ArchSpec &arch, const char *flavor, const char *plugin_name);
 267
 268     static lldb::DisassemblerSP
 269     DisassembleRange (const ArchSpec &arch,
 270                       const char *plugin_name,
 271                       const char *flavor,
 272                       const ExecutionContext &exe_ctx,
 273                       const AddressRange &disasm_range);
 274
 275     static lldb::DisassemblerSP
 276     DisassembleBytes (const ArchSpec &arch,
 277                       const char *plugin_name,
 278                       const char *flavor,
 279                       const Address &start,
 280                       const void *bytes,
 281                       size_t length,
 282                       uint32_t max_num_instructions,
 283                       bool data_from_file);
 284
 285     static bool
 286     Disassemble (Debugger &debugger,
 287                  const ArchSpec &arch,
 288                  const char *plugin_name,
 289                  const char *flavor,
 290                  const ExecutionContext &exe_ctx,
 291                  const AddressRange &range,
 292                  uint32_t num_instructions,
 293                  uint32_t num_mixed_context_lines,
 294                  uint32_t options,
 295                  Stream &strm);
 296
 297     static bool
 298     Disassemble (Debugger &debugger,
 299                  const ArchSpec &arch,
 300                  const char *plugin_name,
 301                  const char *flavor,
 302                  const ExecutionContext &exe_ctx,
 303                  const Address &start,
 304                  uint32_t num_instructions,
 305                  uint32_t num_mixed_context_lines,
 306                  uint32_t options,
 307                  Stream &strm);
 308
 309     static size_t
 310     Disassemble (Debugger &debugger,
 311                  const ArchSpec &arch,
 312                  const char *plugin_name,
 313                  const char *flavor,
 314                  const ExecutionContext &exe_ctx,
 315                  SymbolContextList &sc_list,
 316                  uint32_t num_instructions,
 317                  uint32_t num_mixed_context_lines,
 318                  uint32_t options,
 319                  Stream &strm);
 320
 321     static bool
 322     Disassemble (Debugger &debugger,
 323                  const ArchSpec &arch,
 324                  const char *plugin_name,
 325                  const char *flavor,
 326                  const ExecutionContext &exe_ctx,
 327                  const ConstString &name,
 328                  Module *module,
 329                  uint32_t num_instructions,
 330                  uint32_t num_mixed_context_lines,
 331                  uint32_t options,
 332                  Stream &strm);
 333
 334     static bool
 335     Disassemble (Debugger &debugger,
 336                  const ArchSpec &arch,
 337                  const char *plugin_name,
 338                  const char *flavor,
 339                  const ExecutionContext &exe_ctx,
 340                  uint32_t num_instructions,
 341                  uint32_t num_mixed_context_lines,
 342                  uint32_t options,
 343                  Stream &strm);
 344
 345     //------------------------------------------------------------------
 346     // Constructors and Destructors
 347     //------------------------------------------------------------------
 348     Disassembler(const ArchSpec &arch, const char *flavor);
 349     virtual ~Disassembler();
 350
 351     typedef const char * (*SummaryCallback)(const Instruction& inst, ExecutionContext *exe_context, void *user_data);
 352
 353     static bool
 354     PrintInstructions (Disassembler *disasm_ptr,
 355                        Debugger &debugger,
 356                        const ArchSpec &arch,
 357                        const ExecutionContext &exe_ctx,
 358                        uint32_t num_instructions,
 359                        uint32_t num_mixed_context_lines,
 360                        uint32_t options,
 361                        Stream &strm);
 362
 363     size_t
 364     ParseInstructions (const ExecutionContext *exe_ctx,
 365                        const AddressRange &range,
 366                        Stream *error_strm_ptr,
 367                        bool prefer_file_cache);
 368
 369     size_t
 370     ParseInstructions (const ExecutionContext *exe_ctx,
 371                        const Address &range,
 372                        uint32_t num_instructions,
 373                        bool prefer_file_cache);
 374
 375     virtual size_t
 376     DecodeInstructions (const Address &base_addr,
 377                         const DataExtractor& data,
 378                         lldb::offset_t data_offset,
 379                         size_t num_instructions,
 380                         bool append,
 381                         bool data_from_file) = 0;
 382
 383     InstructionList &
 384     GetInstructionList ();
 385
 386     const InstructionList &
 387     GetInstructionList () const;
 388
 389     const ArchSpec &
 390     GetArchitecture () const
 391     {
 392         return m_arch;
 393     }
 394
 395     const char *
 396     GetFlavor () const
 397     {
 398         return m_flavor.c_str();
 399     }
 400
 401     virtual bool
 402     FlavorValidForArchSpec (const lldb_private::ArchSpec &arch, const char *flavor) = 0;
 403
 404 protected:
 405     //------------------------------------------------------------------
 406     // Classes that inherit from Disassembler can see and modify these
 407     //------------------------------------------------------------------
 408     const ArchSpec m_arch;
 409     InstructionList m_instruction_list;
 410     lldb::addr_t m_base_addr;
 411     std::string m_flavor;
 412
 413 private:
 414     //------------------------------------------------------------------
 415     // For Disassembler only
 416     //------------------------------------------------------------------
 417     DISALLOW_COPY_AND_ASSIGN (Disassembler);
 418 };
 419
 420 } // namespace lldb_private
 421
 422 #endif  // liblldb_Disassembler_h_