LLVM  6.0.0svn
MCInst.h
Go to the documentation of this file.
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 /// \brief Instances of this class represent operands of the MCInst class.
34 /// This is a simple discriminated union.
35 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  union {
47  unsigned RegVal;
48  int64_t ImmVal;
49  double FPImmVal;
50  const MCExpr *ExprVal;
51  const MCInst *InstVal;
52  };
53 
54 public:
55  MCOperand() : FPImmVal(0.0) {}
56 
57  bool isValid() const { return Kind != kInvalid; }
58  bool isReg() const { return Kind == kRegister; }
59  bool isImm() const { return Kind == kImmediate; }
60  bool isFPImm() const { return Kind == kFPImmediate; }
61  bool isExpr() const { return Kind == kExpr; }
62  bool isInst() const { return Kind == kInst; }
63 
64  /// \brief Returns the register number.
65  unsigned getReg() const {
66  assert(isReg() && "This is not a register operand!");
67  return RegVal;
68  }
69 
70  /// \brief Set the register number.
71  void setReg(unsigned Reg) {
72  assert(isReg() && "This is not a register operand!");
73  RegVal = Reg;
74  }
75 
76  int64_t getImm() const {
77  assert(isImm() && "This is not an immediate");
78  return ImmVal;
79  }
80 
81  void setImm(int64_t Val) {
82  assert(isImm() && "This is not an immediate");
83  ImmVal = Val;
84  }
85 
86  double getFPImm() const {
87  assert(isFPImm() && "This is not an FP immediate");
88  return FPImmVal;
89  }
90 
91  void setFPImm(double Val) {
92  assert(isFPImm() && "This is not an FP immediate");
93  FPImmVal = Val;
94  }
95 
96  const MCExpr *getExpr() const {
97  assert(isExpr() && "This is not an expression");
98  return ExprVal;
99  }
100 
101  void setExpr(const MCExpr *Val) {
102  assert(isExpr() && "This is not an expression");
103  ExprVal = Val;
104  }
105 
106  const MCInst *getInst() const {
107  assert(isInst() && "This is not a sub-instruction");
108  return InstVal;
109  }
110 
111  void setInst(const MCInst *Val) {
112  assert(isInst() && "This is not a sub-instruction");
113  InstVal = Val;
114  }
115 
116  static MCOperand createReg(unsigned Reg) {
117  MCOperand Op;
118  Op.Kind = kRegister;
119  Op.RegVal = Reg;
120  return Op;
121  }
122 
123  static MCOperand createImm(int64_t Val) {
124  MCOperand Op;
125  Op.Kind = kImmediate;
126  Op.ImmVal = Val;
127  return Op;
128  }
129 
130  static MCOperand createFPImm(double Val) {
131  MCOperand Op;
132  Op.Kind = kFPImmediate;
133  Op.FPImmVal = Val;
134  return Op;
135  }
136 
137  static MCOperand createExpr(const MCExpr *Val) {
138  MCOperand Op;
139  Op.Kind = kExpr;
140  Op.ExprVal = Val;
141  return Op;
142  }
143 
144  static MCOperand createInst(const MCInst *Val) {
145  MCOperand Op;
146  Op.Kind = kInst;
147  Op.InstVal = Val;
148  return Op;
149  }
150 
151  void print(raw_ostream &OS) const;
152  void dump() const;
153 };
154 
155 template <> struct isPodLike<MCOperand> { static const bool value = true; };
156 
157 /// \brief Instances of this class represent a single low-level machine
158 /// instruction.
159 class MCInst {
160  unsigned Opcode = 0;
161  SMLoc Loc;
162  SmallVector<MCOperand, 8> Operands;
163 
164 public:
165  MCInst() = default;
166 
167  void setOpcode(unsigned Op) { Opcode = Op; }
168  unsigned getOpcode() const { return Opcode; }
169 
170  void setLoc(SMLoc loc) { Loc = loc; }
171  SMLoc getLoc() const { return Loc; }
172 
173  const MCOperand &getOperand(unsigned i) const { return Operands[i]; }
174  MCOperand &getOperand(unsigned i) { return Operands[i]; }
175  unsigned getNumOperands() const { return Operands.size(); }
176 
177  void addOperand(const MCOperand &Op) { Operands.push_back(Op); }
178 
181 
182  void clear() { Operands.clear(); }
183  void erase(iterator I) { Operands.erase(I); }
184  size_t size() const { return Operands.size(); }
185  iterator begin() { return Operands.begin(); }
186  const_iterator begin() const { return Operands.begin(); }
187  iterator end() { return Operands.end(); }
188  const_iterator end() const { return Operands.end(); }
189 
191  return Operands.insert(I, Op);
192  }
193 
194  void print(raw_ostream &OS) const;
195  void dump() const;
196 
197  /// \brief Dump the MCInst as prettily as possible using the additional MC
198  /// structures, if given. Operators are separated by the \p Separator
199  /// string.
200  void dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer = nullptr,
201  StringRef Separator = " ") const;
202 };
203 
204 inline raw_ostream& operator<<(raw_ostream &OS, const MCOperand &MO) {
205  MO.print(OS);
206  return OS;
207 }
208 
210  MI.print(OS);
211  return OS;
212 }
213 
214 } // end namespace llvm
215 
216 #endif // LLVM_MC_MCINST_H
iterator end()
Definition: MCInst.h:187
iterator begin()
Definition: MCInst.h:185
bool isImm() const
Definition: MCInst.h:59
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void clear()
Definition: MCInst.h:182
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
unsigned RegVal
Definition: MCInst.h:47
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:137
void setInst(const MCInst *Val)
Definition: MCInst.h:111
void print(raw_ostream &OS) const
Definition: MCInst.cpp:19
bool isReg() const
Definition: MCInst.h:58
print alias Alias Set Printer
int64_t ImmVal
Definition: MCInst.h:48
MCOperand & getOperand(unsigned i)
Definition: MCInst.h:174
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:116
double FPImmVal
Definition: MCInst.h:49
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
void erase(iterator I)
Definition: MCInst.h:183
void dump() const
Definition: MCInst.cpp:39
Reg
All possible values of the reg field in the ModR/M byte.
const_iterator begin() const
Definition: MCInst.h:186
void setFPImm(double Val)
Definition: MCInst.h:91
unsigned getReg() const
Returns the register number.
Definition: MCInst.h:65
const MCInst * getInst() const
Definition: MCInst.h:106
const MCExpr * getExpr() const
Definition: MCInst.h:96
iterator insert(iterator I, const MCOperand &Op)
Definition: MCInst.h:190
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:159
int64_t getImm() const
Definition: MCInst.h:76
void setImm(int64_t Val)
Definition: MCInst.h:81
bool isInst() const
Definition: MCInst.h:62
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
bool isFPImm() const
Definition: MCInst.h:60
bool isExpr() const
Definition: MCInst.h:61
unsigned getNumOperands() const
Definition: MCInst.h:175
SmallVectorImpl< MCOperand >::iterator iterator
Definition: MCInst.h:179
void print(raw_ostream &OS) const
Definition: MCInst.cpp:45
const MCInst * InstVal
Definition: MCInst.h:51
iterator erase(const_iterator CI)
Definition: SmallVector.h:449
void setLoc(SMLoc loc)
Definition: MCInst.h:170
isPodLike - This is a type trait that is used to determine whether a given type can be copied around ...
Definition: ArrayRef.h:530
void setOpcode(unsigned Op)
Definition: MCInst.h:167
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:173
static MCOperand createFPImm(double Val)
Definition: MCInst.h:130
const_iterator end() const
Definition: MCInst.h:188
SmallVectorImpl< MCOperand >::const_iterator const_iterator
Definition: MCInst.h:180
SMLoc getLoc() const
Definition: MCInst.h:171
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:482
static MCOperand createInst(const MCInst *Val)
Definition: MCInst.h:144
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:41
size_t size() const
Definition: MCInst.h:184
#define I(x, y, z)
Definition: MD5.cpp:58
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2018
void setReg(unsigned Reg)
Set the register number.
Definition: MCInst.h:71
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
IRTranslator LLVM IR MI
void addOperand(const MCOperand &Op)
Definition: MCInst.h:177
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
bool isValid() const
Definition: MCInst.h:57
Represents a location in source code.
Definition: SMLoc.h:24
unsigned getOpcode() const
Definition: MCInst.h:168
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:35
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:123
double getFPImm() const
Definition: MCInst.h:86
const MCExpr * ExprVal
Definition: MCInst.h:50
void setExpr(const MCExpr *Val)
Definition: MCInst.h:101