Coverage Report

Created: 2018-11-16 02:38

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/MC/MCInst.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/MC/MCInst.h - MCInst 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 MCInst and MCOperand classes, which
11
// is the basic representation used to represent low-level machine code
12
// instructions.
13
//
14
//===----------------------------------------------------------------------===//
15
16
#ifndef LLVM_MC_MCINST_H
17
#define LLVM_MC_MCINST_H
18
19
#include "llvm/ADT/SmallVector.h"
20
#include "llvm/ADT/StringRef.h"
21
#include "llvm/Support/SMLoc.h"
22
#include <cassert>
23
#include <cstddef>
24
#include <cstdint>
25
26
namespace llvm {
27
28
class MCExpr;
29
class MCInst;
30
class MCInstPrinter;
31
class raw_ostream;
32
33
/// Instances of this class represent operands of the MCInst class.
34
/// This is a simple discriminated union.
35
0
class MCOperand {
36
  enum MachineOperandType : unsigned char {
37
    kInvalid,     ///< Uninitialized.
38
    kRegister,    ///< Register operand.
39
    kImmediate,   ///< Immediate operand.
40
    kFPImmediate, ///< Floating-point immediate operand.
41
    kExpr,        ///< Relocatable immediate operand.
42
    kInst         ///< Sub-instruction operand.
43
  };
44
  MachineOperandType Kind = kInvalid;
45
46
0
  union {
47
    unsigned RegVal;
48
    int64_t ImmVal;
49
    double FPImmVal;
50
    const MCExpr *ExprVal;
51
    const MCInst *InstVal;
52
  };
53
54
public:
55
126M
  MCOperand() : FPImmVal(0.0) {}
56
57
611k
  bool isValid() const { return Kind != kInvalid; }
58
46.8M
  bool isReg() const { return Kind == kRegister; }
59
16.2M
  bool isImm() const { return Kind == kImmediate; }
60
26.4k
  bool isFPImm() const { return Kind == kFPImmediate; }
61
54.7M
  bool isExpr() const { return Kind == kExpr; }
62
0
  bool isInst() const { return Kind == kInst; }
63
64
  /// Returns the register number.
65
50.7M
  unsigned getReg() const {
66
50.7M
    assert(isReg() && "This is not a register operand!");
67
50.7M
    return RegVal;
68
50.7M
  }
69
70
  /// Set the register number.
71
2.15k
  void setReg(unsigned Reg) {
72
2.15k
    assert(isReg() && "This is not a register operand!");
73
2.15k
    RegVal = Reg;
74
2.15k
  }
75
76
19.6M
  int64_t getImm() const {
77
19.6M
    assert(isImm() && "This is not an immediate");
78
19.6M
    return ImmVal;
79
19.6M
  }
80
81
35.1k
  void setImm(int64_t Val) {
82
35.1k
    assert(isImm() && "This is not an immediate");
83
35.1k
    ImmVal = Val;
84
35.1k
  }
85
86
252
  double getFPImm() const {
87
252
    assert(isFPImm() && "This is not an FP immediate");
88
252
    return FPImmVal;
89
252
  }
90
91
0
  void setFPImm(double Val) {
92
0
    assert(isFPImm() && "This is not an FP immediate");
93
0
    FPImmVal = Val;
94
0
  }
95
96
9.68M
  const MCExpr *getExpr() const {
97
9.68M
    assert(isExpr() && "This is not an expression");
98
9.68M
    return ExprVal;
99
9.68M
  }
100
101
8
  void setExpr(const MCExpr *Val) {
102
8
    assert(isExpr() && "This is not an expression");
103
8
    ExprVal = Val;
104
8
  }
105
106
572k
  const MCInst *getInst() const {
107
572k
    assert(isInst() && "This is not a sub-instruction");
108
572k
    return InstVal;
109
572k
  }
110
111
1.58k
  void setInst(const MCInst *Val) {
112
1.58k
    assert(isInst() && "This is not a sub-instruction");
113
1.58k
    InstVal = Val;
114
1.58k
  }
115
116
40.0M
  static MCOperand createReg(unsigned Reg) {
117
40.0M
    MCOperand Op;
118
40.0M
    Op.Kind = kRegister;
119
40.0M
    Op.RegVal = Reg;
120
40.0M
    return Op;
121
40.0M
  }
122
123
19.0M
  static MCOperand createImm(int64_t Val) {
124
19.0M
    MCOperand Op;
125
19.0M
    Op.Kind = kImmediate;
126
19.0M
    Op.ImmVal = Val;
127
19.0M
    return Op;
128
19.0M
  }
129
130
242
  static MCOperand createFPImm(double Val) {
131
242
    MCOperand Op;
132
242
    Op.Kind = kFPImmediate;
133
242
    Op.FPImmVal = Val;
134
242
    return Op;
135
242
  }
136
137
4.74M
  static MCOperand createExpr(const MCExpr *Val) {
138
4.74M
    MCOperand Op;
139
4.74M
    Op.Kind = kExpr;
140
4.74M
    Op.ExprVal = Val;
141
4.74M
    return Op;
142
4.74M
  }
143
144
230k
  static MCOperand createInst(const MCInst *Val) {
145
230k
    MCOperand Op;
146
230k
    Op.Kind = kInst;
147
230k
    Op.InstVal = Val;
148
230k
    return Op;
149
230k
  }
150
151
  void print(raw_ostream &OS) const;
152
  void dump() const;
153
  bool isBareSymbolRef() const;
154
  bool evaluateAsConstantImm(int64_t &Imm) const;
155
};
156
157
template <> struct isPodLike<MCOperand> { static const bool value = true; };
158
159
/// Instances of this class represent a single low-level machine
160
/// instruction.
161
0
class MCInst {
162
  unsigned Opcode = 0;
163
  SMLoc Loc;
164
  SmallVector<MCOperand, 8> Operands;
165
  // These flags could be used to pass some info from one target subcomponent
166
  // to another, for example, from disassembler to asm printer. The values of
167
  // the flags have any sense on target level only (e.g. prefixes on x86).
168
  unsigned Flags = 0;
169
170
public:
171
381M
  MCInst() = default;
172
173
20.6M
  void setOpcode(unsigned Op) { Opcode = Op; }
174
102M
  unsigned getOpcode() const { return Opcode; }
175
176
515k
  void setFlags(unsigned F) { Flags = F; }
177
7.03M
  unsigned getFlags() const { return Flags; }
178
179
566k
  void setLoc(SMLoc loc) { Loc = loc; }
180
5.58M
  SMLoc getLoc() const { return Loc; }
181
182
135M
  const MCOperand &getOperand(unsigned i) const { return Operands[i]; }
183
1.01M
  MCOperand &getOperand(unsigned i) { return Operands[i]; }
184
24.7M
  unsigned getNumOperands() const { return Operands.size(); }
185
186
64.2M
  void addOperand(const MCOperand &Op) { Operands.push_back(Op); }
187
188
  using iterator = SmallVectorImpl<MCOperand>::iterator;
189
  using const_iterator = SmallVectorImpl<MCOperand>::const_iterator;
190
191
1.45M
  void clear() { Operands.clear(); }
192
8.14k
  void erase(iterator I) { Operands.erase(I); }
193
245k
  size_t size() const { return Operands.size(); }
194
62.0k
  iterator begin() { return Operands.begin(); }
195
231k
  const_iterator begin() const { return Operands.begin(); }
196
138k
  iterator end() { return Operands.end(); }
197
478k
  const_iterator end() const { return Operands.end(); }
198
199
34.0k
  iterator insert(iterator I, const MCOperand &Op) {
200
34.0k
    return Operands.insert(I, Op);
201
34.0k
  }
202
203
  void print(raw_ostream &OS) const;
204
  void dump() const;
205
206
  /// Dump the MCInst as prettily as possible using the additional MC
207
  /// structures, if given. Operators are separated by the \p Separator
208
  /// string.
209
  void dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer = nullptr,
210
                   StringRef Separator = " ") const;
211
};
212
213
699
inline raw_ostream& operator<<(raw_ostream &OS, const MCOperand &MO) {
214
699
  MO.print(OS);
215
699
  return OS;
216
699
}
217
218
0
inline raw_ostream& operator<<(raw_ostream &OS, const MCInst &MI) {
219
0
  MI.print(OS);
220
0
  return OS;
221
0
}
222
223
} // end namespace llvm
224
225
#endif // LLVM_MC_MCINST_H