Home | History | Annotate | Download | only in MCDisassembler
      1 //===- llvm/MC/MCSymbolizer.h - MCSymbolizer class --------------*- 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 // This file contains the declaration of the MCSymbolizer class, which is used
     11 // to symbolize instructions decoded from an object, that is, transform their
     12 // immediate operands to MCExprs.
     13 //
     14 //===----------------------------------------------------------------------===//
     15 
     16 #ifndef LLVM_MC_MCDISASSEMBLER_MCSYMBOLIZER_H
     17 #define LLVM_MC_MCDISASSEMBLER_MCSYMBOLIZER_H
     18 
     19 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
     20 #include <algorithm>
     21 #include <cstdint>
     22 #include <memory>
     23 
     24 namespace llvm {
     25 
     26 class MCContext;
     27 class MCInst;
     28 class raw_ostream;
     29 
     30 /// \brief Symbolize and annotate disassembled instructions.
     31 ///
     32 /// For now this mimics the old symbolization logic (from both ARM and x86), that
     33 /// relied on user-provided (C API) callbacks to do the actual symbol lookup in
     34 /// the object file. This was moved to MCExternalSymbolizer.
     35 /// A better API would not rely on actually calling the two methods here from
     36 /// inside each disassembler, but would use the instr info to determine what
     37 /// operands are actually symbolizable, and in what way. I don't think this
     38 /// information exists right now.
     39 class MCSymbolizer {
     40 protected:
     41   MCContext &Ctx;
     42   std::unique_ptr<MCRelocationInfo> RelInfo;
     43 
     44 public:
     45   /// \brief Construct an MCSymbolizer, taking ownership of \p RelInfo.
     46   MCSymbolizer(MCContext &Ctx, std::unique_ptr<MCRelocationInfo> RelInfo)
     47     : Ctx(Ctx), RelInfo(std::move(RelInfo)) {
     48   }
     49 
     50   MCSymbolizer(const MCSymbolizer &) = delete;
     51   MCSymbolizer &operator=(const MCSymbolizer &) = delete;
     52   virtual ~MCSymbolizer();
     53 
     54   /// \brief Try to add a symbolic operand instead of \p Value to the MCInst.
     55   ///
     56   /// Instead of having a difficult to read immediate, a symbolic operand would
     57   /// represent this immediate in a more understandable way, for instance as a
     58   /// symbol or an offset from a symbol. Relocations can also be used to enrich
     59   /// the symbolic expression.
     60   /// \param Inst      - The MCInst where to insert the symbolic operand.
     61   /// \param cStream   - Stream to print comments and annotations on.
     62   /// \param Value     - Operand value, pc-adjusted by the caller if necessary.
     63   /// \param Address   - Load address of the instruction.
     64   /// \param IsBranch  - Is the instruction a branch?
     65   /// \param Offset    - Byte offset of the operand inside the inst.
     66   /// \param InstSize  - Size of the instruction in bytes.
     67   /// \return Whether a symbolic operand was added.
     68   virtual bool tryAddingSymbolicOperand(MCInst &Inst, raw_ostream &cStream,
     69                                         int64_t Value, uint64_t Address,
     70                                         bool IsBranch, uint64_t Offset,
     71                                         uint64_t InstSize) = 0;
     72 
     73   /// \brief Try to add a comment on the PC-relative load.
     74   /// For instance, in Mach-O, this is used to add annotations to instructions
     75   /// that use C string literals, as found in __cstring.
     76   virtual void tryAddingPcLoadReferenceComment(raw_ostream &cStream,
     77                                                int64_t Value,
     78                                                uint64_t Address) = 0;
     79 };
     80 
     81 } // end namespace llvm
     82 
     83 #endif // LLVM_MC_MCDISASSEMBLER_MCSYMBOLIZER_H
     84