Coverage Report

Created: 2017-09-19 22:28

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/MC/MCDisassembler/MCSymbolizer.h
Line
Count
Source (jump to first uncovered line)
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
0
    : Ctx(Ctx), RelInfo(std::move(RelInfo)) {
48
0
  }
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