MachineInstr.cpp revision a284cbf667e11660840dc7bae3ee9eeaa3c7cbd2
1//===-- MachineInstr.cpp --------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Methods common to all machine instructions. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/CodeGen/MachineInstr.h" 15#include "llvm/CodeGen/MachineFunction.h" 16#include "llvm/Target/TargetMachine.h" 17#include "llvm/Target/TargetInstrInfo.h" 18#include "llvm/Target/MRegisterInfo.h" 19#include "llvm/Support/LeakDetector.h" 20#include "llvm/Support/Streams.h" 21#include <ostream> 22using namespace llvm; 23 24/// MachineInstr ctor - This constructor creates a dummy MachineInstr with 25/// TID NULL and no operands. 26MachineInstr::MachineInstr() 27 : TID(0), NumImplicitOps(0), parent(0) { 28 // Make sure that we get added to a machine basicblock 29 LeakDetector::addGarbageObject(this); 30} 31 32void MachineInstr::addImplicitDefUseOperands() { 33 if (TID->ImplicitDefs) 34 for (const unsigned *ImpDefs = TID->ImplicitDefs; *ImpDefs; ++ImpDefs) { 35 MachineOperand Op; 36 Op.opType = MachineOperand::MO_Register; 37 Op.IsDef = true; 38 Op.IsImp = true; 39 Op.IsKill = false; 40 Op.IsDead = false; 41 Op.contents.RegNo = *ImpDefs; 42 Op.offset = 0; 43 Operands.push_back(Op); 44 } 45 if (TID->ImplicitUses) 46 for (const unsigned *ImpUses = TID->ImplicitUses; *ImpUses; ++ImpUses) { 47 MachineOperand Op; 48 Op.opType = MachineOperand::MO_Register; 49 Op.IsDef = false; 50 Op.IsImp = true; 51 Op.IsKill = false; 52 Op.IsDead = false; 53 Op.contents.RegNo = *ImpUses; 54 Op.offset = 0; 55 Operands.push_back(Op); 56 } 57} 58 59/// MachineInstr ctor - This constructor create a MachineInstr and add the 60/// implicit operands. It reserves space for number of operands specified by 61/// TargetInstrDescriptor or the numOperands if it is not zero. (for 62/// instructions with variable number of operands). 63MachineInstr::MachineInstr(const TargetInstrDescriptor &tid) 64 : TID(&tid), NumImplicitOps(0), parent(0) { 65 if (TID->ImplicitDefs) 66 for (const unsigned *ImpDefs = TID->ImplicitDefs; *ImpDefs; ++ImpDefs) 67 NumImplicitOps++; 68 if (TID->ImplicitUses) 69 for (const unsigned *ImpUses = TID->ImplicitUses; *ImpUses; ++ImpUses) 70 NumImplicitOps++; 71 Operands.reserve(NumImplicitOps + TID->numOperands); 72 addImplicitDefUseOperands(); 73 // Make sure that we get added to a machine basicblock 74 LeakDetector::addGarbageObject(this); 75} 76 77/// MachineInstr ctor - Work exactly the same as the ctor above, except that the 78/// MachineInstr is created and added to the end of the specified basic block. 79/// 80MachineInstr::MachineInstr(MachineBasicBlock *MBB, 81 const TargetInstrDescriptor &tid) 82 : TID(&tid), NumImplicitOps(0), parent(0) { 83 assert(MBB && "Cannot use inserting ctor with null basic block!"); 84 if (TID->ImplicitDefs) 85 for (const unsigned *ImpDefs = TID->ImplicitDefs; *ImpDefs; ++ImpDefs) 86 NumImplicitOps++; 87 if (TID->ImplicitUses) 88 for (const unsigned *ImpUses = TID->ImplicitUses; *ImpUses; ++ImpUses) 89 NumImplicitOps++; 90 Operands.reserve(NumImplicitOps + TID->numOperands); 91 addImplicitDefUseOperands(); 92 // Make sure that we get added to a machine basicblock 93 LeakDetector::addGarbageObject(this); 94 MBB->push_back(this); // Add instruction to end of basic block! 95} 96 97/// MachineInstr ctor - Copies MachineInstr arg exactly 98/// 99MachineInstr::MachineInstr(const MachineInstr &MI) { 100 TID = MI.getInstrDescriptor(); 101 NumImplicitOps = MI.NumImplicitOps; 102 Operands.reserve(MI.getNumOperands()); 103 104 // Add operands 105 for (unsigned i = 0; i != MI.getNumOperands(); ++i) 106 Operands.push_back(MI.getOperand(i)); 107 108 // Set parent, next, and prev to null 109 parent = 0; 110 prev = 0; 111 next = 0; 112} 113 114 115MachineInstr::~MachineInstr() { 116 LeakDetector::removeGarbageObject(this); 117} 118 119/// getOpcode - Returns the opcode of this MachineInstr. 120/// 121const int MachineInstr::getOpcode() const { 122 return TID->Opcode; 123} 124 125/// removeFromParent - This method unlinks 'this' from the containing basic 126/// block, and returns it, but does not delete it. 127MachineInstr *MachineInstr::removeFromParent() { 128 assert(getParent() && "Not embedded in a basic block!"); 129 getParent()->remove(this); 130 return this; 131} 132 133 134/// OperandComplete - Return true if it's illegal to add a new operand 135/// 136bool MachineInstr::OperandsComplete() const { 137 unsigned short NumOperands = TID->numOperands; 138 if ((TID->Flags & M_VARIABLE_OPS) == 0 && 139 getNumOperands()-NumImplicitOps >= NumOperands) 140 return true; // Broken: we have all the operands of this instruction! 141 return false; 142} 143 144/// isIdenticalTo - Return true if this operand is identical to the specified 145/// operand. 146bool MachineOperand::isIdenticalTo(const MachineOperand &Other) const { 147 if (getType() != Other.getType()) return false; 148 149 switch (getType()) { 150 default: assert(0 && "Unrecognized operand type"); 151 case MachineOperand::MO_Register: 152 return getReg() == Other.getReg() && isDef() == Other.isDef(); 153 case MachineOperand::MO_Immediate: 154 return getImm() == Other.getImm(); 155 case MachineOperand::MO_MachineBasicBlock: 156 return getMBB() == Other.getMBB(); 157 case MachineOperand::MO_FrameIndex: 158 return getFrameIndex() == Other.getFrameIndex(); 159 case MachineOperand::MO_ConstantPoolIndex: 160 return getConstantPoolIndex() == Other.getConstantPoolIndex() && 161 getOffset() == Other.getOffset(); 162 case MachineOperand::MO_JumpTableIndex: 163 return getJumpTableIndex() == Other.getJumpTableIndex(); 164 case MachineOperand::MO_GlobalAddress: 165 return getGlobal() == Other.getGlobal() && getOffset() == Other.getOffset(); 166 case MachineOperand::MO_ExternalSymbol: 167 return !strcmp(getSymbolName(), Other.getSymbolName()) && 168 getOffset() == Other.getOffset(); 169 } 170} 171 172/// findRegisterUseOperand() - Returns the MachineOperand that is a use of 173/// the specific register or NULL if it is not found. 174MachineOperand *MachineInstr::findRegisterUseOperand(unsigned Reg) { 175 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 176 MachineOperand &MO = getOperand(i); 177 if (MO.isReg() && MO.isUse() && MO.getReg() == Reg) 178 return &MO; 179 } 180 return NULL; 181} 182 183/// copyKillDeadInfo - Copies kill / dead operand properties from MI. 184/// 185void MachineInstr::copyKillDeadInfo(const MachineInstr *MI) { 186 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 187 const MachineOperand &MO = MI->getOperand(i); 188 if (!MO.isReg() || (!MO.isKill() && !MO.isDead())) 189 continue; 190 for (unsigned j = 0, ee = getNumOperands(); j != ee; ++j) { 191 MachineOperand &MOp = getOperand(j); 192 if (!MOp.isIdenticalTo(MO)) 193 continue; 194 if (MO.isKill()) 195 MOp.setIsKill(); 196 else 197 MOp.setIsDead(); 198 break; 199 } 200 } 201} 202 203void MachineInstr::dump() const { 204 cerr << " " << *this; 205} 206 207static inline void OutputReg(std::ostream &os, unsigned RegNo, 208 const MRegisterInfo *MRI = 0) { 209 if (!RegNo || MRegisterInfo::isPhysicalRegister(RegNo)) { 210 if (MRI) 211 os << "%" << MRI->get(RegNo).Name; 212 else 213 os << "%mreg(" << RegNo << ")"; 214 } else 215 os << "%reg" << RegNo; 216} 217 218static void print(const MachineOperand &MO, std::ostream &OS, 219 const TargetMachine *TM) { 220 const MRegisterInfo *MRI = 0; 221 222 if (TM) MRI = TM->getRegisterInfo(); 223 224 switch (MO.getType()) { 225 case MachineOperand::MO_Register: 226 OutputReg(OS, MO.getReg(), MRI); 227 break; 228 case MachineOperand::MO_Immediate: 229 OS << MO.getImmedValue(); 230 break; 231 case MachineOperand::MO_MachineBasicBlock: 232 OS << "mbb<" 233 << ((Value*)MO.getMachineBasicBlock()->getBasicBlock())->getName() 234 << "," << (void*)MO.getMachineBasicBlock() << ">"; 235 break; 236 case MachineOperand::MO_FrameIndex: 237 OS << "<fi#" << MO.getFrameIndex() << ">"; 238 break; 239 case MachineOperand::MO_ConstantPoolIndex: 240 OS << "<cp#" << MO.getConstantPoolIndex() << ">"; 241 break; 242 case MachineOperand::MO_JumpTableIndex: 243 OS << "<jt#" << MO.getJumpTableIndex() << ">"; 244 break; 245 case MachineOperand::MO_GlobalAddress: 246 OS << "<ga:" << ((Value*)MO.getGlobal())->getName(); 247 if (MO.getOffset()) OS << "+" << MO.getOffset(); 248 OS << ">"; 249 break; 250 case MachineOperand::MO_ExternalSymbol: 251 OS << "<es:" << MO.getSymbolName(); 252 if (MO.getOffset()) OS << "+" << MO.getOffset(); 253 OS << ">"; 254 break; 255 default: 256 assert(0 && "Unrecognized operand type"); 257 } 258} 259 260void MachineInstr::print(std::ostream &OS, const TargetMachine *TM) const { 261 unsigned StartOp = 0; 262 263 // Specialize printing if op#0 is definition 264 if (getNumOperands() && getOperand(0).isReg() && getOperand(0).isDef()) { 265 ::print(getOperand(0), OS, TM); 266 if (getOperand(0).isDead()) 267 OS << "<dead>"; 268 OS << " = "; 269 ++StartOp; // Don't print this operand again! 270 } 271 272 if (TID) 273 OS << TID->Name; 274 275 for (unsigned i = StartOp, e = getNumOperands(); i != e; ++i) { 276 const MachineOperand& mop = getOperand(i); 277 if (i != StartOp) 278 OS << ","; 279 OS << " "; 280 ::print(mop, OS, TM); 281 282 if (mop.isReg()) { 283 if (mop.isDef() || mop.isKill() || mop.isDead() || mop.isImplicit()) { 284 OS << "<"; 285 bool NeedComma = false; 286 if (mop.isImplicit()) { 287 OS << (mop.isDef() ? "imp-def" : "imp-use"); 288 NeedComma = true; 289 } else if (mop.isDef()) { 290 OS << "def"; 291 NeedComma = true; 292 } 293 if (mop.isKill() || mop.isDead()) { 294 if (NeedComma) 295 OS << ","; 296 if (mop.isKill()) 297 OS << "kill"; 298 if (mop.isDead()) 299 OS << "dead"; 300 } 301 OS << ">"; 302 } 303 } 304 } 305 306 OS << "\n"; 307} 308 309void MachineInstr::print(std::ostream &os) const { 310 // If the instruction is embedded into a basic block, we can find the target 311 // info for the instruction. 312 if (const MachineBasicBlock *MBB = getParent()) { 313 const MachineFunction *MF = MBB->getParent(); 314 if (MF) 315 print(os, &MF->getTarget()); 316 else 317 print(os, 0); 318 } 319 320 // Otherwise, print it out in the "raw" format without symbolic register names 321 // and such. 322 os << getInstrDescriptor()->Name; 323 324 for (unsigned i = 0, N = getNumOperands(); i < N; i++) { 325 os << "\t" << getOperand(i); 326 if (getOperand(i).isReg() && getOperand(i).isDef()) 327 os << "<d>"; 328 } 329 330 os << "\n"; 331} 332 333void MachineOperand::print(std::ostream &OS) const { 334 switch (getType()) { 335 case MO_Register: 336 OutputReg(OS, getReg()); 337 break; 338 case MO_Immediate: 339 OS << (long)getImmedValue(); 340 break; 341 case MO_MachineBasicBlock: 342 OS << "<mbb:" 343 << ((Value*)getMachineBasicBlock()->getBasicBlock())->getName() 344 << "@" << (void*)getMachineBasicBlock() << ">"; 345 break; 346 case MO_FrameIndex: 347 OS << "<fi#" << getFrameIndex() << ">"; 348 break; 349 case MO_ConstantPoolIndex: 350 OS << "<cp#" << getConstantPoolIndex() << ">"; 351 break; 352 case MO_JumpTableIndex: 353 OS << "<jt#" << getJumpTableIndex() << ">"; 354 break; 355 case MO_GlobalAddress: 356 OS << "<ga:" << ((Value*)getGlobal())->getName() << ">"; 357 break; 358 case MO_ExternalSymbol: 359 OS << "<es:" << getSymbolName() << ">"; 360 break; 361 default: 362 assert(0 && "Unrecognized operand type"); 363 break; 364 } 365} 366 367