MachineOperand.h revision 195098
1//===-- llvm/CodeGen/MachineOperand.h - MachineOperand 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 MachineOperand class. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CODEGEN_MACHINEOPERAND_H 15#define LLVM_CODEGEN_MACHINEOPERAND_H 16 17#include "llvm/Support/DataTypes.h" 18#include <cassert> 19#include <iosfwd> 20 21namespace llvm { 22 23class ConstantFP; 24class MachineBasicBlock; 25class GlobalValue; 26class MachineInstr; 27class TargetMachine; 28class MachineRegisterInfo; 29class raw_ostream; 30 31/// MachineOperand class - Representation of each machine instruction operand. 32/// 33class MachineOperand { 34public: 35 enum MachineOperandType { 36 MO_Register, ///< Register operand. 37 MO_Immediate, ///< Immediate operand 38 MO_FPImmediate, ///< Floating-point immediate operand 39 MO_MachineBasicBlock, ///< MachineBasicBlock reference 40 MO_FrameIndex, ///< Abstract Stack Frame Index 41 MO_ConstantPoolIndex, ///< Address of indexed Constant in Constant Pool 42 MO_JumpTableIndex, ///< Address of indexed Jump Table for switch 43 MO_ExternalSymbol, ///< Name of external global symbol 44 MO_GlobalAddress ///< Address of a global value 45 }; 46 47private: 48 /// OpKind - Specify what kind of operand this is. This discriminates the 49 /// union. 50 unsigned char OpKind; // MachineOperandType 51 52 /// SubReg - Subregister number, only valid for MO_Register. A value of 0 53 /// indicates the MO_Register has no subReg. 54 unsigned char SubReg; 55 56 /// TargetFlags - This is a set of target-specific operand flags. 57 unsigned char TargetFlags; 58 59 /// IsDef/IsImp/IsKill/IsDead flags - These are only valid for MO_Register 60 /// operands. 61 62 /// IsDef - True if this is a def, false if this is a use of the register. 63 /// 64 bool IsDef : 1; 65 66 /// IsImp - True if this is an implicit def or use, false if it is explicit. 67 /// 68 bool IsImp : 1; 69 70 /// IsKill - True if this instruction is the last use of the register on this 71 /// path through the function. This is only valid on uses of registers. 72 bool IsKill : 1; 73 74 /// IsDead - True if this register is never used by a subsequent instruction. 75 /// This is only valid on definitions of registers. 76 bool IsDead : 1; 77 78 /// IsEarlyClobber - True if this MO_Register 'def' operand is written to 79 /// by the MachineInstr before all input registers are read. This is used to 80 /// model the GCC inline asm '&' constraint modifier. 81 bool IsEarlyClobber : 1; 82 83 /// ParentMI - This is the instruction that this operand is embedded into. 84 /// This is valid for all operand types, when the operand is in an instr. 85 MachineInstr *ParentMI; 86 87 /// Contents union - This contains the payload for the various operand types. 88 union { 89 MachineBasicBlock *MBB; // For MO_MachineBasicBlock. 90 const ConstantFP *CFP; // For MO_FPImmediate. 91 int64_t ImmVal; // For MO_Immediate. 92 93 struct { // For MO_Register. 94 unsigned RegNo; 95 MachineOperand **Prev; // Access list for register. 96 MachineOperand *Next; 97 } Reg; 98 99 /// OffsetedInfo - This struct contains the offset and an object identifier. 100 /// this represent the object as with an optional offset from it. 101 struct { 102 union { 103 int Index; // For MO_*Index - The index itself. 104 const char *SymbolName; // For MO_ExternalSymbol. 105 GlobalValue *GV; // For MO_GlobalAddress. 106 } Val; 107 int64_t Offset; // An offset from the object. 108 } OffsetedInfo; 109 } Contents; 110 111 explicit MachineOperand(MachineOperandType K) : OpKind(K), ParentMI(0) { 112 TargetFlags = 0; 113 } 114public: 115 MachineOperand(const MachineOperand &M) { 116 *this = M; 117 } 118 119 ~MachineOperand() {} 120 121 /// getType - Returns the MachineOperandType for this operand. 122 /// 123 MachineOperandType getType() const { return (MachineOperandType)OpKind; } 124 125 unsigned char getTargetFlags() const { return TargetFlags; } 126 void setTargetFlags(unsigned char F) { TargetFlags = F; } 127 void addTargetFlag(unsigned char F) { TargetFlags |= F; } 128 129 130 /// getParent - Return the instruction that this operand belongs to. 131 /// 132 MachineInstr *getParent() { return ParentMI; } 133 const MachineInstr *getParent() const { return ParentMI; } 134 135 void print(std::ostream &os, const TargetMachine *TM = 0) const; 136 void print(raw_ostream &os, const TargetMachine *TM = 0) const; 137 138 //===--------------------------------------------------------------------===// 139 // Accessors that tell you what kind of MachineOperand you're looking at. 140 //===--------------------------------------------------------------------===// 141 142 /// isReg - Tests if this is a MO_Register operand. 143 bool isReg() const { return OpKind == MO_Register; } 144 /// isImm - Tests if this is a MO_Immediate operand. 145 bool isImm() const { return OpKind == MO_Immediate; } 146 /// isFPImm - Tests if this is a MO_FPImmediate operand. 147 bool isFPImm() const { return OpKind == MO_FPImmediate; } 148 /// isMBB - Tests if this is a MO_MachineBasicBlock operand. 149 bool isMBB() const { return OpKind == MO_MachineBasicBlock; } 150 /// isFI - Tests if this is a MO_FrameIndex operand. 151 bool isFI() const { return OpKind == MO_FrameIndex; } 152 /// isCPI - Tests if this is a MO_ConstantPoolIndex operand. 153 bool isCPI() const { return OpKind == MO_ConstantPoolIndex; } 154 /// isJTI - Tests if this is a MO_JumpTableIndex operand. 155 bool isJTI() const { return OpKind == MO_JumpTableIndex; } 156 /// isGlobal - Tests if this is a MO_GlobalAddress operand. 157 bool isGlobal() const { return OpKind == MO_GlobalAddress; } 158 /// isSymbol - Tests if this is a MO_ExternalSymbol operand. 159 bool isSymbol() const { return OpKind == MO_ExternalSymbol; } 160 161 //===--------------------------------------------------------------------===// 162 // Accessors for Register Operands 163 //===--------------------------------------------------------------------===// 164 165 /// getReg - Returns the register number. 166 unsigned getReg() const { 167 assert(isReg() && "This is not a register operand!"); 168 return Contents.Reg.RegNo; 169 } 170 171 unsigned getSubReg() const { 172 assert(isReg() && "Wrong MachineOperand accessor"); 173 return (unsigned)SubReg; 174 } 175 176 bool isUse() const { 177 assert(isReg() && "Wrong MachineOperand accessor"); 178 return !IsDef; 179 } 180 181 bool isDef() const { 182 assert(isReg() && "Wrong MachineOperand accessor"); 183 return IsDef; 184 } 185 186 bool isImplicit() const { 187 assert(isReg() && "Wrong MachineOperand accessor"); 188 return IsImp; 189 } 190 191 bool isDead() const { 192 assert(isReg() && "Wrong MachineOperand accessor"); 193 return IsDead; 194 } 195 196 bool isKill() const { 197 assert(isReg() && "Wrong MachineOperand accessor"); 198 return IsKill; 199 } 200 201 bool isEarlyClobber() const { 202 assert(isReg() && "Wrong MachineOperand accessor"); 203 return IsEarlyClobber; 204 } 205 206 /// getNextOperandForReg - Return the next MachineOperand in the function that 207 /// uses or defines this register. 208 MachineOperand *getNextOperandForReg() const { 209 assert(isReg() && "This is not a register operand!"); 210 return Contents.Reg.Next; 211 } 212 213 //===--------------------------------------------------------------------===// 214 // Mutators for Register Operands 215 //===--------------------------------------------------------------------===// 216 217 /// Change the register this operand corresponds to. 218 /// 219 void setReg(unsigned Reg); 220 221 void setSubReg(unsigned subReg) { 222 assert(isReg() && "Wrong MachineOperand accessor"); 223 SubReg = (unsigned char)subReg; 224 } 225 226 void setIsUse(bool Val = true) { 227 assert(isReg() && "Wrong MachineOperand accessor"); 228 IsDef = !Val; 229 } 230 231 void setIsDef(bool Val = true) { 232 assert(isReg() && "Wrong MachineOperand accessor"); 233 IsDef = Val; 234 } 235 236 void setImplicit(bool Val = true) { 237 assert(isReg() && "Wrong MachineOperand accessor"); 238 IsImp = Val; 239 } 240 241 void setIsKill(bool Val = true) { 242 assert(isReg() && !IsDef && "Wrong MachineOperand accessor"); 243 IsKill = Val; 244 } 245 246 void setIsDead(bool Val = true) { 247 assert(isReg() && IsDef && "Wrong MachineOperand accessor"); 248 IsDead = Val; 249 } 250 251 void setIsEarlyClobber(bool Val = true) { 252 assert(isReg() && IsDef && "Wrong MachineOperand accessor"); 253 IsEarlyClobber = Val; 254 } 255 256 //===--------------------------------------------------------------------===// 257 // Accessors for various operand types. 258 //===--------------------------------------------------------------------===// 259 260 int64_t getImm() const { 261 assert(isImm() && "Wrong MachineOperand accessor"); 262 return Contents.ImmVal; 263 } 264 265 const ConstantFP *getFPImm() const { 266 assert(isFPImm() && "Wrong MachineOperand accessor"); 267 return Contents.CFP; 268 } 269 270 MachineBasicBlock *getMBB() const { 271 assert(isMBB() && "Wrong MachineOperand accessor"); 272 return Contents.MBB; 273 } 274 275 int getIndex() const { 276 assert((isFI() || isCPI() || isJTI()) && 277 "Wrong MachineOperand accessor"); 278 return Contents.OffsetedInfo.Val.Index; 279 } 280 281 GlobalValue *getGlobal() const { 282 assert(isGlobal() && "Wrong MachineOperand accessor"); 283 return Contents.OffsetedInfo.Val.GV; 284 } 285 286 int64_t getOffset() const { 287 assert((isGlobal() || isSymbol() || isCPI()) && 288 "Wrong MachineOperand accessor"); 289 return Contents.OffsetedInfo.Offset; 290 } 291 292 const char *getSymbolName() const { 293 assert(isSymbol() && "Wrong MachineOperand accessor"); 294 return Contents.OffsetedInfo.Val.SymbolName; 295 } 296 297 //===--------------------------------------------------------------------===// 298 // Mutators for various operand types. 299 //===--------------------------------------------------------------------===// 300 301 void setImm(int64_t immVal) { 302 assert(isImm() && "Wrong MachineOperand mutator"); 303 Contents.ImmVal = immVal; 304 } 305 306 void setOffset(int64_t Offset) { 307 assert((isGlobal() || isSymbol() || isCPI()) && 308 "Wrong MachineOperand accessor"); 309 Contents.OffsetedInfo.Offset = Offset; 310 } 311 312 void setIndex(int Idx) { 313 assert((isFI() || isCPI() || isJTI()) && 314 "Wrong MachineOperand accessor"); 315 Contents.OffsetedInfo.Val.Index = Idx; 316 } 317 318 void setMBB(MachineBasicBlock *MBB) { 319 assert(isMBB() && "Wrong MachineOperand accessor"); 320 Contents.MBB = MBB; 321 } 322 323 //===--------------------------------------------------------------------===// 324 // Other methods. 325 //===--------------------------------------------------------------------===// 326 327 /// isIdenticalTo - Return true if this operand is identical to the specified 328 /// operand. Note: This method ignores isKill and isDead properties. 329 bool isIdenticalTo(const MachineOperand &Other) const; 330 331 /// ChangeToImmediate - Replace this operand with a new immediate operand of 332 /// the specified value. If an operand is known to be an immediate already, 333 /// the setImm method should be used. 334 void ChangeToImmediate(int64_t ImmVal); 335 336 /// ChangeToRegister - Replace this operand with a new register operand of 337 /// the specified value. If an operand is known to be an register already, 338 /// the setReg method should be used. 339 void ChangeToRegister(unsigned Reg, bool isDef, bool isImp = false, 340 bool isKill = false, bool isDead = false); 341 342 //===--------------------------------------------------------------------===// 343 // Construction methods. 344 //===--------------------------------------------------------------------===// 345 346 static MachineOperand CreateImm(int64_t Val) { 347 MachineOperand Op(MachineOperand::MO_Immediate); 348 Op.setImm(Val); 349 return Op; 350 } 351 352 static MachineOperand CreateFPImm(const ConstantFP *CFP) { 353 MachineOperand Op(MachineOperand::MO_FPImmediate); 354 Op.Contents.CFP = CFP; 355 return Op; 356 } 357 358 static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false, 359 bool isKill = false, bool isDead = false, 360 unsigned SubReg = 0, 361 bool isEarlyClobber = false) { 362 MachineOperand Op(MachineOperand::MO_Register); 363 Op.IsDef = isDef; 364 Op.IsImp = isImp; 365 Op.IsKill = isKill; 366 Op.IsDead = isDead; 367 Op.IsEarlyClobber = isEarlyClobber; 368 Op.Contents.Reg.RegNo = Reg; 369 Op.Contents.Reg.Prev = 0; 370 Op.Contents.Reg.Next = 0; 371 Op.SubReg = SubReg; 372 return Op; 373 } 374 static MachineOperand CreateMBB(MachineBasicBlock *MBB, 375 unsigned char TargetFlags = 0) { 376 MachineOperand Op(MachineOperand::MO_MachineBasicBlock); 377 Op.setMBB(MBB); 378 Op.setTargetFlags(TargetFlags); 379 return Op; 380 } 381 static MachineOperand CreateFI(unsigned Idx) { 382 MachineOperand Op(MachineOperand::MO_FrameIndex); 383 Op.setIndex(Idx); 384 return Op; 385 } 386 static MachineOperand CreateCPI(unsigned Idx, int Offset, 387 unsigned char TargetFlags = 0) { 388 MachineOperand Op(MachineOperand::MO_ConstantPoolIndex); 389 Op.setIndex(Idx); 390 Op.setOffset(Offset); 391 Op.setTargetFlags(TargetFlags); 392 return Op; 393 } 394 static MachineOperand CreateJTI(unsigned Idx, 395 unsigned char TargetFlags = 0) { 396 MachineOperand Op(MachineOperand::MO_JumpTableIndex); 397 Op.setIndex(Idx); 398 Op.setTargetFlags(TargetFlags); 399 return Op; 400 } 401 static MachineOperand CreateGA(GlobalValue *GV, int64_t Offset, 402 unsigned char TargetFlags = 0) { 403 MachineOperand Op(MachineOperand::MO_GlobalAddress); 404 Op.Contents.OffsetedInfo.Val.GV = GV; 405 Op.setOffset(Offset); 406 Op.setTargetFlags(TargetFlags); 407 return Op; 408 } 409 static MachineOperand CreateES(const char *SymName, int64_t Offset = 0, 410 unsigned char TargetFlags = 0) { 411 MachineOperand Op(MachineOperand::MO_ExternalSymbol); 412 Op.Contents.OffsetedInfo.Val.SymbolName = SymName; 413 Op.setOffset(Offset); 414 Op.setTargetFlags(TargetFlags); 415 return Op; 416 } 417 const MachineOperand &operator=(const MachineOperand &MO) { 418 OpKind = MO.OpKind; 419 IsDef = MO.IsDef; 420 IsImp = MO.IsImp; 421 IsKill = MO.IsKill; 422 IsDead = MO.IsDead; 423 IsEarlyClobber = MO.IsEarlyClobber; 424 SubReg = MO.SubReg; 425 ParentMI = MO.ParentMI; 426 Contents = MO.Contents; 427 TargetFlags = MO.TargetFlags; 428 return *this; 429 } 430 431 friend class MachineInstr; 432 friend class MachineRegisterInfo; 433private: 434 //===--------------------------------------------------------------------===// 435 // Methods for handling register use/def lists. 436 //===--------------------------------------------------------------------===// 437 438 /// isOnRegUseList - Return true if this operand is on a register use/def list 439 /// or false if not. This can only be called for register operands that are 440 /// part of a machine instruction. 441 bool isOnRegUseList() const { 442 assert(isReg() && "Can only add reg operand to use lists"); 443 return Contents.Reg.Prev != 0; 444 } 445 446 /// AddRegOperandToRegInfo - Add this register operand to the specified 447 /// MachineRegisterInfo. If it is null, then the next/prev fields should be 448 /// explicitly nulled out. 449 void AddRegOperandToRegInfo(MachineRegisterInfo *RegInfo); 450 451 /// RemoveRegOperandFromRegInfo - Remove this register operand from the 452 /// MachineRegisterInfo it is linked with. 453 void RemoveRegOperandFromRegInfo(); 454}; 455 456inline std::ostream &operator<<(std::ostream &OS, const MachineOperand &MO) { 457 MO.print(OS, 0); 458 return OS; 459} 460 461inline raw_ostream &operator<<(raw_ostream &OS, const MachineOperand& MO) { 462 MO.print(OS, 0); 463 return OS; 464} 465 466} // End llvm namespace 467 468#endif 469