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