MCInst.h revision e303503da3dd928b70ab371161e33b515e8dfc95 
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/MC/MCValue.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/Support/DataTypes.h"
22#include "llvm/Support/DebugLoc.h"
23
24namespace llvm {
25
26/// MCOperand - Instances of this class represent operands of the MCInst class.
27/// This is a simple discriminated union.
28class MCOperand {
29  enum MachineOperandType {
30    kInvalid,                 ///< Uninitialized.
31    kRegister,                ///< Register operand.
32    kImmediate,               ///< Immediate operand.
33    kMBBLabel,                ///< Basic block label.
34    kMCValue                  ///< Relocatable immediate operand.
35  };
36  unsigned char Kind;
37
38  union {
39    unsigned RegVal;
40    int64_t ImmVal;
41    MCValue MCValueVal;
42    struct {
43      unsigned FunctionNo;
44      unsigned BlockNo;
45    } MBBLabel;
46  };
47public:
48
49  MCOperand() : Kind(kInvalid) {}
50  MCOperand(const MCOperand &RHS) { *this = RHS; }
51
52  bool isValid() const { return Kind != kInvalid; }
53  bool isReg() const { return Kind == kRegister; }
54  bool isImm() const { return Kind == kImmediate; }
55  bool isMBBLabel() const { return Kind == kMBBLabel; }
56  bool isMCValue() const { return Kind == kMCValue; }
57
58  /// getReg - Returns the register number.
59  unsigned getReg() const {
60    assert(isReg() && "This is not a register operand!");
61    return RegVal;
62  }
63
64  /// setReg - Set the register number.
65  void setReg(unsigned Reg) {
66    assert(isReg() && "This is not a register operand!");
67    RegVal = Reg;
68  }
69
70  int64_t getImm() const {
71    assert(isImm() && "This is not an immediate");
72    return ImmVal;
73  }
74  void setImm(int64_t Val) {
75    assert(isImm() && "This is not an immediate");
76    ImmVal = Val;
77  }
78
79  unsigned getMBBLabelFunction() const {
80    assert(isMBBLabel() && "Wrong accessor");
81    return MBBLabel.FunctionNo;
82  }
83  unsigned getMBBLabelBlock() const {
84    assert(isMBBLabel() && "Wrong accessor");
85    return MBBLabel.BlockNo;
86  }
87
88  const MCValue &getMCValue() const {
89    assert(isMCValue() && "This is not an MCValue");
90    return MCValueVal;
91  }
92  void setMCValue(const MCValue &Val) {
93    assert(isMCValue() && "This is not an MCValue");
94    MCValueVal = Val;
95  }
96
97  void MakeReg(unsigned Reg) {
98    Kind = kRegister;
99    RegVal = Reg;
100  }
101  void MakeImm(int64_t Val) {
102    Kind = kImmediate;
103    ImmVal = Val;
104  }
105  void MakeMBBLabel(unsigned Fn, unsigned MBB) {
106    Kind = kMBBLabel;
107    MBBLabel.FunctionNo = Fn;
108    MBBLabel.BlockNo = MBB;
109  }
110  void MakeMCValue(const MCValue &Val) {
111    Kind = kMCValue;
112    MCValueVal = Val;
113  }
114};
115
116
117/// MCInst - Instances of this class represent a single low-level machine
118/// instruction.
119class MCInst {
120  unsigned Opcode;
121  SmallVector<MCOperand, 8> Operands;
122public:
123  MCInst() : Opcode(~0U) {}
124
125  void setOpcode(unsigned Op) { Opcode = Op; }
126
127  unsigned getOpcode() const { return Opcode; }
128  DebugLoc getDebugLoc() const { return DebugLoc(); }
129
130  const MCOperand &getOperand(unsigned i) const { return Operands[i]; }
131  MCOperand &getOperand(unsigned i) { return Operands[i]; }
132  unsigned getNumOperands() const { return Operands.size(); }
133
134  void addOperand(const MCOperand &Op) {
135    Operands.push_back(Op);
136  }
137};
138
139
140} // end namespace llvm
141
142#endif
143