MCInst.h revision dce4a407a24b04eebc6a376f8e62b41aaa7b071f
10f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans//===-- llvm/MC/MCInst.h - MCInst class -------------------------*- C++ -*-===// 20f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// 3b666378b6b6aecd713524a04100f33ba8861f4e1Mike Hommey// The LLVM Compiler Infrastructure 4b666378b6b6aecd713524a04100f33ba8861f4e1Mike Hommey// 5b666378b6b6aecd713524a04100f33ba8861f4e1Mike Hommey// This file is distributed under the University of Illinois Open Source 6b666378b6b6aecd713524a04100f33ba8861f4e1Mike Hommey// License. See LICENSE.TXT for details. 70f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// 80f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans//===----------------------------------------------------------------------===// 90f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// 100f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// This file contains the declaration of the MCInst and MCOperand classes, which 110f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// is the basic representation used to represent low-level machine code 120f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// instructions. 130f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans// 140f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans//===----------------------------------------------------------------------===// 150f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 160f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans#ifndef LLVM_MC_MCINST_H 170f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans#define LLVM_MC_MCINST_H 180f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 190f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans#include "llvm/ADT/SmallVector.h" 200f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans#include "llvm/ADT/StringRef.h" 21a2be4779b19a491a5686cfda067f98d7d70a9056Jason Evans#include "llvm/Support/DataTypes.h" 220f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans#include "llvm/Support/SMLoc.h" 230f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 240f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansnamespace llvm { 250f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansclass raw_ostream; 260f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansclass MCAsmInfo; 270f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansclass MCInstPrinter; 280f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansclass MCExpr; 290f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansclass MCInst; 300f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 310f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans/// MCOperand - Instances of this class represent operands of the MCInst class. 320f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans/// This is a simple discriminated union. 330f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evansclass MCOperand { 340f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans enum MachineOperandType { 350f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans kInvalid, ///< Uninitialized. 360f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans kRegister, ///< Register operand. 370f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans kImmediate, ///< Immediate operand. 380f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans kFPImmediate, ///< Floating-point immediate operand. 390f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans kExpr, ///< Relocatable immediate operand. 400f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans kInst ///< Sub-instruction operand. 410f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans }; 420f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans unsigned char Kind; 430f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 440f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans union { 450f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans unsigned RegVal; 460f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans int64_t ImmVal; 470f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans double FPImmVal; 480f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans const MCExpr *ExprVal; 490f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans const MCInst *InstVal; 500f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans }; 510f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evanspublic: 520f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 530f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans MCOperand() : Kind(kInvalid), FPImmVal(0.0) {} 540f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 550f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans bool isValid() const { return Kind != kInvalid; } 560f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans bool isReg() const { return Kind == kRegister; } 570f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans bool isImm() const { return Kind == kImmediate; } 580f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans bool isFPImm() const { return Kind == kFPImmediate; } 590f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans bool isExpr() const { return Kind == kExpr; } 600f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans bool isInst() const { return Kind == kInst; } 610f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans 620f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans /// getReg - Returns the register number. 630f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans unsigned getReg() const { 640f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans assert(isReg() && "This is not a register operand!"); 650f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans return RegVal; 660f4f1efd94d33a4bbf766d3d4e7e349fa7c0d3b9Jason Evans } 67 68 /// setReg - Set the register number. 69 void setReg(unsigned Reg) { 70 assert(isReg() && "This is not a register operand!"); 71 RegVal = Reg; 72 } 73 74 int64_t getImm() const { 75 assert(isImm() && "This is not an immediate"); 76 return ImmVal; 77 } 78 void setImm(int64_t Val) { 79 assert(isImm() && "This is not an immediate"); 80 ImmVal = Val; 81 } 82 83 double getFPImm() const { 84 assert(isFPImm() && "This is not an FP immediate"); 85 return FPImmVal; 86 } 87 88 void setFPImm(double Val) { 89 assert(isFPImm() && "This is not an FP immediate"); 90 FPImmVal = Val; 91 } 92 93 const MCExpr *getExpr() const { 94 assert(isExpr() && "This is not an expression"); 95 return ExprVal; 96 } 97 void setExpr(const MCExpr *Val) { 98 assert(isExpr() && "This is not an expression"); 99 ExprVal = Val; 100 } 101 102 const MCInst *getInst() const { 103 assert(isInst() && "This is not a sub-instruction"); 104 return InstVal; 105 } 106 void setInst(const MCInst *Val) { 107 assert(isInst() && "This is not a sub-instruction"); 108 InstVal = Val; 109 } 110 111 static MCOperand CreateReg(unsigned Reg) { 112 MCOperand Op; 113 Op.Kind = kRegister; 114 Op.RegVal = Reg; 115 return Op; 116 } 117 static MCOperand CreateImm(int64_t Val) { 118 MCOperand Op; 119 Op.Kind = kImmediate; 120 Op.ImmVal = Val; 121 return Op; 122 } 123 static MCOperand CreateFPImm(double Val) { 124 MCOperand Op; 125 Op.Kind = kFPImmediate; 126 Op.FPImmVal = Val; 127 return Op; 128 } 129 static MCOperand CreateExpr(const MCExpr *Val) { 130 MCOperand Op; 131 Op.Kind = kExpr; 132 Op.ExprVal = Val; 133 return Op; 134 } 135 static MCOperand CreateInst(const MCInst *Val) { 136 MCOperand Op; 137 Op.Kind = kInst; 138 Op.InstVal = Val; 139 return Op; 140 } 141 142 void print(raw_ostream &OS, const MCAsmInfo *MAI) const; 143 void dump() const; 144}; 145 146template <> struct isPodLike<MCOperand> { static const bool value = true; }; 147 148/// MCInst - Instances of this class represent a single low-level machine 149/// instruction. 150class MCInst { 151 unsigned Opcode; 152 SMLoc Loc; 153 SmallVector<MCOperand, 8> Operands; 154public: 155 MCInst() : Opcode(0) {} 156 157 void setOpcode(unsigned Op) { Opcode = Op; } 158 unsigned getOpcode() const { return Opcode; } 159 160 void setLoc(SMLoc loc) { Loc = loc; } 161 SMLoc getLoc() const { return Loc; } 162 163 const MCOperand &getOperand(unsigned i) const { return Operands[i]; } 164 MCOperand &getOperand(unsigned i) { return Operands[i]; } 165 unsigned getNumOperands() const { return Operands.size(); } 166 167 void addOperand(const MCOperand &Op) { 168 Operands.push_back(Op); 169 } 170 171 void clear() { Operands.clear(); } 172 size_t size() { return Operands.size(); } 173 174 typedef SmallVectorImpl<MCOperand>::iterator iterator; 175 iterator begin() { return Operands.begin(); } 176 iterator end() { return Operands.end(); } 177 iterator insert(iterator I, const MCOperand &Op) { 178 return Operands.insert(I, Op); 179 } 180 181 void print(raw_ostream &OS, const MCAsmInfo *MAI) const; 182 void dump() const; 183 184 /// \brief Dump the MCInst as prettily as possible using the additional MC 185 /// structures, if given. Operators are separated by the \p Separator 186 /// string. 187 void dump_pretty(raw_ostream &OS, const MCAsmInfo *MAI = nullptr, 188 const MCInstPrinter *Printer = nullptr, 189 StringRef Separator = " ") const; 190}; 191 192inline raw_ostream& operator<<(raw_ostream &OS, const MCOperand &MO) { 193 MO.print(OS, nullptr); 194 return OS; 195} 196 197inline raw_ostream& operator<<(raw_ostream &OS, const MCInst &MI) { 198 MI.print(OS, nullptr); 199 return OS; 200} 201 202} // end namespace llvm 203 204#endif 205