MachineInstr.cpp revision 1793ab9e70c48146a5f1592b84b2b93e38c67fa4
1//===-- lib/CodeGen/MachineInstr.cpp --------------------------------------===// 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// Methods common to all machine instructions. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/CodeGen/MachineInstr.h" 15#include "llvm/Constants.h" 16#include "llvm/Function.h" 17#include "llvm/InlineAsm.h" 18#include "llvm/Metadata.h" 19#include "llvm/Type.h" 20#include "llvm/Value.h" 21#include "llvm/Assembly/Writer.h" 22#include "llvm/CodeGen/MachineConstantPool.h" 23#include "llvm/CodeGen/MachineFunction.h" 24#include "llvm/CodeGen/MachineMemOperand.h" 25#include "llvm/CodeGen/MachineRegisterInfo.h" 26#include "llvm/CodeGen/PseudoSourceValue.h" 27#include "llvm/MC/MCSymbol.h" 28#include "llvm/Target/TargetMachine.h" 29#include "llvm/Target/TargetInstrInfo.h" 30#include "llvm/Target/TargetInstrDesc.h" 31#include "llvm/Target/TargetRegisterInfo.h" 32#include "llvm/Analysis/AliasAnalysis.h" 33#include "llvm/Analysis/DebugInfo.h" 34#include "llvm/Support/Debug.h" 35#include "llvm/Support/ErrorHandling.h" 36#include "llvm/Support/LeakDetector.h" 37#include "llvm/Support/MathExtras.h" 38#include "llvm/Support/raw_ostream.h" 39#include "llvm/ADT/FoldingSet.h" 40using namespace llvm; 41 42//===----------------------------------------------------------------------===// 43// MachineOperand Implementation 44//===----------------------------------------------------------------------===// 45 46/// AddRegOperandToRegInfo - Add this register operand to the specified 47/// MachineRegisterInfo. If it is null, then the next/prev fields should be 48/// explicitly nulled out. 49void MachineOperand::AddRegOperandToRegInfo(MachineRegisterInfo *RegInfo) { 50 assert(isReg() && "Can only add reg operand to use lists"); 51 52 // If the reginfo pointer is null, just explicitly null out or next/prev 53 // pointers, to ensure they are not garbage. 54 if (RegInfo == 0) { 55 Contents.Reg.Prev = 0; 56 Contents.Reg.Next = 0; 57 return; 58 } 59 60 // Otherwise, add this operand to the head of the registers use/def list. 61 MachineOperand **Head = &RegInfo->getRegUseDefListHead(getReg()); 62 63 // For SSA values, we prefer to keep the definition at the start of the list. 64 // we do this by skipping over the definition if it is at the head of the 65 // list. 66 if (*Head && (*Head)->isDef()) 67 Head = &(*Head)->Contents.Reg.Next; 68 69 Contents.Reg.Next = *Head; 70 if (Contents.Reg.Next) { 71 assert(getReg() == Contents.Reg.Next->getReg() && 72 "Different regs on the same list!"); 73 Contents.Reg.Next->Contents.Reg.Prev = &Contents.Reg.Next; 74 } 75 76 Contents.Reg.Prev = Head; 77 *Head = this; 78} 79 80/// RemoveRegOperandFromRegInfo - Remove this register operand from the 81/// MachineRegisterInfo it is linked with. 82void MachineOperand::RemoveRegOperandFromRegInfo() { 83 assert(isOnRegUseList() && "Reg operand is not on a use list"); 84 // Unlink this from the doubly linked list of operands. 85 MachineOperand *NextOp = Contents.Reg.Next; 86 *Contents.Reg.Prev = NextOp; 87 if (NextOp) { 88 assert(NextOp->getReg() == getReg() && "Corrupt reg use/def chain!"); 89 NextOp->Contents.Reg.Prev = Contents.Reg.Prev; 90 } 91 Contents.Reg.Prev = 0; 92 Contents.Reg.Next = 0; 93} 94 95void MachineOperand::setReg(unsigned Reg) { 96 if (getReg() == Reg) return; // No change. 97 98 // Otherwise, we have to change the register. If this operand is embedded 99 // into a machine function, we need to update the old and new register's 100 // use/def lists. 101 if (MachineInstr *MI = getParent()) 102 if (MachineBasicBlock *MBB = MI->getParent()) 103 if (MachineFunction *MF = MBB->getParent()) { 104 RemoveRegOperandFromRegInfo(); 105 Contents.Reg.RegNo = Reg; 106 AddRegOperandToRegInfo(&MF->getRegInfo()); 107 return; 108 } 109 110 // Otherwise, just change the register, no problem. :) 111 Contents.Reg.RegNo = Reg; 112} 113 114/// ChangeToImmediate - Replace this operand with a new immediate operand of 115/// the specified value. If an operand is known to be an immediate already, 116/// the setImm method should be used. 117void MachineOperand::ChangeToImmediate(int64_t ImmVal) { 118 // If this operand is currently a register operand, and if this is in a 119 // function, deregister the operand from the register's use/def list. 120 if (isReg() && getParent() && getParent()->getParent() && 121 getParent()->getParent()->getParent()) 122 RemoveRegOperandFromRegInfo(); 123 124 OpKind = MO_Immediate; 125 Contents.ImmVal = ImmVal; 126} 127 128/// ChangeToRegister - Replace this operand with a new register operand of 129/// the specified value. If an operand is known to be an register already, 130/// the setReg method should be used. 131void MachineOperand::ChangeToRegister(unsigned Reg, bool isDef, bool isImp, 132 bool isKill, bool isDead, bool isUndef, 133 bool isDebug) { 134 // If this operand is already a register operand, use setReg to update the 135 // register's use/def lists. 136 if (isReg()) { 137 assert(!isEarlyClobber()); 138 setReg(Reg); 139 } else { 140 // Otherwise, change this to a register and set the reg#. 141 OpKind = MO_Register; 142 Contents.Reg.RegNo = Reg; 143 144 // If this operand is embedded in a function, add the operand to the 145 // register's use/def list. 146 if (MachineInstr *MI = getParent()) 147 if (MachineBasicBlock *MBB = MI->getParent()) 148 if (MachineFunction *MF = MBB->getParent()) 149 AddRegOperandToRegInfo(&MF->getRegInfo()); 150 } 151 152 IsDef = isDef; 153 IsImp = isImp; 154 IsKill = isKill; 155 IsDead = isDead; 156 IsUndef = isUndef; 157 IsEarlyClobber = false; 158 IsDebug = isDebug; 159 SubReg = 0; 160} 161 162/// isIdenticalTo - Return true if this operand is identical to the specified 163/// operand. 164bool MachineOperand::isIdenticalTo(const MachineOperand &Other) const { 165 if (getType() != Other.getType() || 166 getTargetFlags() != Other.getTargetFlags()) 167 return false; 168 169 switch (getType()) { 170 default: llvm_unreachable("Unrecognized operand type"); 171 case MachineOperand::MO_Register: 172 return getReg() == Other.getReg() && isDef() == Other.isDef() && 173 getSubReg() == Other.getSubReg(); 174 case MachineOperand::MO_Immediate: 175 return getImm() == Other.getImm(); 176 case MachineOperand::MO_FPImmediate: 177 return getFPImm() == Other.getFPImm(); 178 case MachineOperand::MO_MachineBasicBlock: 179 return getMBB() == Other.getMBB(); 180 case MachineOperand::MO_FrameIndex: 181 return getIndex() == Other.getIndex(); 182 case MachineOperand::MO_ConstantPoolIndex: 183 return getIndex() == Other.getIndex() && getOffset() == Other.getOffset(); 184 case MachineOperand::MO_JumpTableIndex: 185 return getIndex() == Other.getIndex(); 186 case MachineOperand::MO_GlobalAddress: 187 return getGlobal() == Other.getGlobal() && getOffset() == Other.getOffset(); 188 case MachineOperand::MO_ExternalSymbol: 189 return !strcmp(getSymbolName(), Other.getSymbolName()) && 190 getOffset() == Other.getOffset(); 191 case MachineOperand::MO_BlockAddress: 192 return getBlockAddress() == Other.getBlockAddress(); 193 case MachineOperand::MO_MCSymbol: 194 return getMCSymbol() == Other.getMCSymbol(); 195 case MachineOperand::MO_Metadata: 196 return getMetadata() == Other.getMetadata(); 197 } 198} 199 200/// print - Print the specified machine operand. 201/// 202void MachineOperand::print(raw_ostream &OS, const TargetMachine *TM) const { 203 // If the instruction is embedded into a basic block, we can find the 204 // target info for the instruction. 205 if (!TM) 206 if (const MachineInstr *MI = getParent()) 207 if (const MachineBasicBlock *MBB = MI->getParent()) 208 if (const MachineFunction *MF = MBB->getParent()) 209 TM = &MF->getTarget(); 210 211 switch (getType()) { 212 case MachineOperand::MO_Register: 213 if (getReg() == 0 || TargetRegisterInfo::isVirtualRegister(getReg())) { 214 OS << "%reg" << getReg(); 215 } else { 216 if (TM) 217 OS << "%" << TM->getRegisterInfo()->get(getReg()).Name; 218 else 219 OS << "%physreg" << getReg(); 220 } 221 222 if (getSubReg() != 0) 223 OS << ':' << getSubReg(); 224 225 if (isDef() || isKill() || isDead() || isImplicit() || isUndef() || 226 isEarlyClobber()) { 227 OS << '<'; 228 bool NeedComma = false; 229 if (isDef()) { 230 if (NeedComma) OS << ','; 231 if (isEarlyClobber()) 232 OS << "earlyclobber,"; 233 if (isImplicit()) 234 OS << "imp-"; 235 OS << "def"; 236 NeedComma = true; 237 } else if (isImplicit()) { 238 OS << "imp-use"; 239 NeedComma = true; 240 } 241 242 if (isKill() || isDead() || isUndef()) { 243 if (NeedComma) OS << ','; 244 if (isKill()) OS << "kill"; 245 if (isDead()) OS << "dead"; 246 if (isUndef()) { 247 if (isKill() || isDead()) 248 OS << ','; 249 OS << "undef"; 250 } 251 } 252 OS << '>'; 253 } 254 break; 255 case MachineOperand::MO_Immediate: 256 OS << getImm(); 257 break; 258 case MachineOperand::MO_FPImmediate: 259 if (getFPImm()->getType()->isFloatTy()) 260 OS << getFPImm()->getValueAPF().convertToFloat(); 261 else 262 OS << getFPImm()->getValueAPF().convertToDouble(); 263 break; 264 case MachineOperand::MO_MachineBasicBlock: 265 OS << "<BB#" << getMBB()->getNumber() << ">"; 266 break; 267 case MachineOperand::MO_FrameIndex: 268 OS << "<fi#" << getIndex() << '>'; 269 break; 270 case MachineOperand::MO_ConstantPoolIndex: 271 OS << "<cp#" << getIndex(); 272 if (getOffset()) OS << "+" << getOffset(); 273 OS << '>'; 274 break; 275 case MachineOperand::MO_JumpTableIndex: 276 OS << "<jt#" << getIndex() << '>'; 277 break; 278 case MachineOperand::MO_GlobalAddress: 279 OS << "<ga:"; 280 WriteAsOperand(OS, getGlobal(), /*PrintType=*/false); 281 if (getOffset()) OS << "+" << getOffset(); 282 OS << '>'; 283 break; 284 case MachineOperand::MO_ExternalSymbol: 285 OS << "<es:" << getSymbolName(); 286 if (getOffset()) OS << "+" << getOffset(); 287 OS << '>'; 288 break; 289 case MachineOperand::MO_BlockAddress: 290 OS << '<'; 291 WriteAsOperand(OS, getBlockAddress(), /*PrintType=*/false); 292 OS << '>'; 293 break; 294 case MachineOperand::MO_Metadata: 295 OS << '<'; 296 WriteAsOperand(OS, getMetadata(), /*PrintType=*/false); 297 OS << '>'; 298 break; 299 case MachineOperand::MO_MCSymbol: 300 OS << "<MCSym=" << *getMCSymbol() << '>'; 301 break; 302 default: 303 llvm_unreachable("Unrecognized operand type"); 304 } 305 306 if (unsigned TF = getTargetFlags()) 307 OS << "[TF=" << TF << ']'; 308} 309 310//===----------------------------------------------------------------------===// 311// MachineMemOperand Implementation 312//===----------------------------------------------------------------------===// 313 314MachineMemOperand::MachineMemOperand(const Value *v, unsigned int f, 315 int64_t o, uint64_t s, unsigned int a) 316 : Offset(o), Size(s), V(v), 317 Flags((f & ((1 << MOMaxBits) - 1)) | ((Log2_32(a) + 1) << MOMaxBits)) { 318 assert(getBaseAlignment() == a && "Alignment is not a power of 2!"); 319 assert((isLoad() || isStore()) && "Not a load/store!"); 320} 321 322/// Profile - Gather unique data for the object. 323/// 324void MachineMemOperand::Profile(FoldingSetNodeID &ID) const { 325 ID.AddInteger(Offset); 326 ID.AddInteger(Size); 327 ID.AddPointer(V); 328 ID.AddInteger(Flags); 329} 330 331void MachineMemOperand::refineAlignment(const MachineMemOperand *MMO) { 332 // The Value and Offset may differ due to CSE. But the flags and size 333 // should be the same. 334 assert(MMO->getFlags() == getFlags() && "Flags mismatch!"); 335 assert(MMO->getSize() == getSize() && "Size mismatch!"); 336 337 if (MMO->getBaseAlignment() >= getBaseAlignment()) { 338 // Update the alignment value. 339 Flags = (Flags & ((1 << MOMaxBits) - 1)) | 340 ((Log2_32(MMO->getBaseAlignment()) + 1) << MOMaxBits); 341 // Also update the base and offset, because the new alignment may 342 // not be applicable with the old ones. 343 V = MMO->getValue(); 344 Offset = MMO->getOffset(); 345 } 346} 347 348/// getAlignment - Return the minimum known alignment in bytes of the 349/// actual memory reference. 350uint64_t MachineMemOperand::getAlignment() const { 351 return MinAlign(getBaseAlignment(), getOffset()); 352} 353 354raw_ostream &llvm::operator<<(raw_ostream &OS, const MachineMemOperand &MMO) { 355 assert((MMO.isLoad() || MMO.isStore()) && 356 "SV has to be a load, store or both."); 357 358 if (MMO.isVolatile()) 359 OS << "Volatile "; 360 361 if (MMO.isLoad()) 362 OS << "LD"; 363 if (MMO.isStore()) 364 OS << "ST"; 365 OS << MMO.getSize(); 366 367 // Print the address information. 368 OS << "["; 369 if (!MMO.getValue()) 370 OS << "<unknown>"; 371 else 372 WriteAsOperand(OS, MMO.getValue(), /*PrintType=*/false); 373 374 // If the alignment of the memory reference itself differs from the alignment 375 // of the base pointer, print the base alignment explicitly, next to the base 376 // pointer. 377 if (MMO.getBaseAlignment() != MMO.getAlignment()) 378 OS << "(align=" << MMO.getBaseAlignment() << ")"; 379 380 if (MMO.getOffset() != 0) 381 OS << "+" << MMO.getOffset(); 382 OS << "]"; 383 384 // Print the alignment of the reference. 385 if (MMO.getBaseAlignment() != MMO.getAlignment() || 386 MMO.getBaseAlignment() != MMO.getSize()) 387 OS << "(align=" << MMO.getAlignment() << ")"; 388 389 return OS; 390} 391 392//===----------------------------------------------------------------------===// 393// MachineInstr Implementation 394//===----------------------------------------------------------------------===// 395 396/// MachineInstr ctor - This constructor creates a dummy MachineInstr with 397/// TID NULL and no operands. 398MachineInstr::MachineInstr() 399 : TID(0), NumImplicitOps(0), AsmPrinterFlags(0), MemRefs(0), MemRefsEnd(0), 400 Parent(0) { 401 // Make sure that we get added to a machine basicblock 402 LeakDetector::addGarbageObject(this); 403} 404 405void MachineInstr::addImplicitDefUseOperands() { 406 if (TID->ImplicitDefs) 407 for (const unsigned *ImpDefs = TID->ImplicitDefs; *ImpDefs; ++ImpDefs) 408 addOperand(MachineOperand::CreateReg(*ImpDefs, true, true)); 409 if (TID->ImplicitUses) 410 for (const unsigned *ImpUses = TID->ImplicitUses; *ImpUses; ++ImpUses) 411 addOperand(MachineOperand::CreateReg(*ImpUses, false, true)); 412} 413 414/// MachineInstr ctor - This constructor creates a MachineInstr and adds the 415/// implicit operands. It reserves space for the number of operands specified by 416/// the TargetInstrDesc. 417MachineInstr::MachineInstr(const TargetInstrDesc &tid, bool NoImp) 418 : TID(&tid), NumImplicitOps(0), AsmPrinterFlags(0), 419 MemRefs(0), MemRefsEnd(0), Parent(0) { 420 if (!NoImp) 421 NumImplicitOps = TID->getNumImplicitDefs() + TID->getNumImplicitUses(); 422 Operands.reserve(NumImplicitOps + TID->getNumOperands()); 423 if (!NoImp) 424 addImplicitDefUseOperands(); 425 // Make sure that we get added to a machine basicblock 426 LeakDetector::addGarbageObject(this); 427} 428 429/// MachineInstr ctor - As above, but with a DebugLoc. 430MachineInstr::MachineInstr(const TargetInstrDesc &tid, const DebugLoc dl, 431 bool NoImp) 432 : TID(&tid), NumImplicitOps(0), AsmPrinterFlags(0), MemRefs(0), MemRefsEnd(0), 433 Parent(0), debugLoc(dl) { 434 if (!NoImp) 435 NumImplicitOps = TID->getNumImplicitDefs() + TID->getNumImplicitUses(); 436 Operands.reserve(NumImplicitOps + TID->getNumOperands()); 437 if (!NoImp) 438 addImplicitDefUseOperands(); 439 // Make sure that we get added to a machine basicblock 440 LeakDetector::addGarbageObject(this); 441} 442 443/// MachineInstr ctor - Work exactly the same as the ctor two above, except 444/// that the MachineInstr is created and added to the end of the specified 445/// basic block. 446MachineInstr::MachineInstr(MachineBasicBlock *MBB, const TargetInstrDesc &tid) 447 : TID(&tid), NumImplicitOps(0), AsmPrinterFlags(0), 448 MemRefs(0), MemRefsEnd(0), Parent(0) { 449 assert(MBB && "Cannot use inserting ctor with null basic block!"); 450 NumImplicitOps = TID->getNumImplicitDefs() + TID->getNumImplicitUses(); 451 Operands.reserve(NumImplicitOps + TID->getNumOperands()); 452 addImplicitDefUseOperands(); 453 // Make sure that we get added to a machine basicblock 454 LeakDetector::addGarbageObject(this); 455 MBB->push_back(this); // Add instruction to end of basic block! 456} 457 458/// MachineInstr ctor - As above, but with a DebugLoc. 459/// 460MachineInstr::MachineInstr(MachineBasicBlock *MBB, const DebugLoc dl, 461 const TargetInstrDesc &tid) 462 : TID(&tid), NumImplicitOps(0), AsmPrinterFlags(0), MemRefs(0), MemRefsEnd(0), 463 Parent(0), debugLoc(dl) { 464 assert(MBB && "Cannot use inserting ctor with null basic block!"); 465 NumImplicitOps = TID->getNumImplicitDefs() + TID->getNumImplicitUses(); 466 Operands.reserve(NumImplicitOps + TID->getNumOperands()); 467 addImplicitDefUseOperands(); 468 // Make sure that we get added to a machine basicblock 469 LeakDetector::addGarbageObject(this); 470 MBB->push_back(this); // Add instruction to end of basic block! 471} 472 473/// MachineInstr ctor - Copies MachineInstr arg exactly 474/// 475MachineInstr::MachineInstr(MachineFunction &MF, const MachineInstr &MI) 476 : TID(&MI.getDesc()), NumImplicitOps(0), AsmPrinterFlags(0), 477 MemRefs(MI.MemRefs), MemRefsEnd(MI.MemRefsEnd), 478 Parent(0), debugLoc(MI.getDebugLoc()) { 479 Operands.reserve(MI.getNumOperands()); 480 481 // Add operands 482 for (unsigned i = 0; i != MI.getNumOperands(); ++i) 483 addOperand(MI.getOperand(i)); 484 NumImplicitOps = MI.NumImplicitOps; 485 486 // Set parent to null. 487 Parent = 0; 488 489 LeakDetector::addGarbageObject(this); 490} 491 492MachineInstr::~MachineInstr() { 493 LeakDetector::removeGarbageObject(this); 494#ifndef NDEBUG 495 for (unsigned i = 0, e = Operands.size(); i != e; ++i) { 496 assert(Operands[i].ParentMI == this && "ParentMI mismatch!"); 497 assert((!Operands[i].isReg() || !Operands[i].isOnRegUseList()) && 498 "Reg operand def/use list corrupted"); 499 } 500#endif 501} 502 503/// getRegInfo - If this instruction is embedded into a MachineFunction, 504/// return the MachineRegisterInfo object for the current function, otherwise 505/// return null. 506MachineRegisterInfo *MachineInstr::getRegInfo() { 507 if (MachineBasicBlock *MBB = getParent()) 508 return &MBB->getParent()->getRegInfo(); 509 return 0; 510} 511 512/// RemoveRegOperandsFromUseLists - Unlink all of the register operands in 513/// this instruction from their respective use lists. This requires that the 514/// operands already be on their use lists. 515void MachineInstr::RemoveRegOperandsFromUseLists() { 516 for (unsigned i = 0, e = Operands.size(); i != e; ++i) { 517 if (Operands[i].isReg()) 518 Operands[i].RemoveRegOperandFromRegInfo(); 519 } 520} 521 522/// AddRegOperandsToUseLists - Add all of the register operands in 523/// this instruction from their respective use lists. This requires that the 524/// operands not be on their use lists yet. 525void MachineInstr::AddRegOperandsToUseLists(MachineRegisterInfo &RegInfo) { 526 for (unsigned i = 0, e = Operands.size(); i != e; ++i) { 527 if (Operands[i].isReg()) 528 Operands[i].AddRegOperandToRegInfo(&RegInfo); 529 } 530} 531 532 533/// addOperand - Add the specified operand to the instruction. If it is an 534/// implicit operand, it is added to the end of the operand list. If it is 535/// an explicit operand it is added at the end of the explicit operand list 536/// (before the first implicit operand). 537void MachineInstr::addOperand(const MachineOperand &Op) { 538 bool isImpReg = Op.isReg() && Op.isImplicit(); 539 assert((isImpReg || !OperandsComplete()) && 540 "Trying to add an operand to a machine instr that is already done!"); 541 542 MachineRegisterInfo *RegInfo = getRegInfo(); 543 544 // If we are adding the operand to the end of the list, our job is simpler. 545 // This is true most of the time, so this is a reasonable optimization. 546 if (isImpReg || NumImplicitOps == 0) { 547 // We can only do this optimization if we know that the operand list won't 548 // reallocate. 549 if (Operands.empty() || Operands.size()+1 <= Operands.capacity()) { 550 Operands.push_back(Op); 551 552 // Set the parent of the operand. 553 Operands.back().ParentMI = this; 554 555 // If the operand is a register, update the operand's use list. 556 if (Op.isReg()) { 557 Operands.back().AddRegOperandToRegInfo(RegInfo); 558 // If the register operand is flagged as early, mark the operand as such 559 unsigned OpNo = Operands.size() - 1; 560 if (TID->getOperandConstraint(OpNo, TOI::EARLY_CLOBBER) != -1) 561 Operands[OpNo].setIsEarlyClobber(true); 562 } 563 return; 564 } 565 } 566 567 // Otherwise, we have to insert a real operand before any implicit ones. 568 unsigned OpNo = Operands.size()-NumImplicitOps; 569 570 // If this instruction isn't embedded into a function, then we don't need to 571 // update any operand lists. 572 if (RegInfo == 0) { 573 // Simple insertion, no reginfo update needed for other register operands. 574 Operands.insert(Operands.begin()+OpNo, Op); 575 Operands[OpNo].ParentMI = this; 576 577 // Do explicitly set the reginfo for this operand though, to ensure the 578 // next/prev fields are properly nulled out. 579 if (Operands[OpNo].isReg()) { 580 Operands[OpNo].AddRegOperandToRegInfo(0); 581 // If the register operand is flagged as early, mark the operand as such 582 if (TID->getOperandConstraint(OpNo, TOI::EARLY_CLOBBER) != -1) 583 Operands[OpNo].setIsEarlyClobber(true); 584 } 585 586 } else if (Operands.size()+1 <= Operands.capacity()) { 587 // Otherwise, we have to remove register operands from their register use 588 // list, add the operand, then add the register operands back to their use 589 // list. This also must handle the case when the operand list reallocates 590 // to somewhere else. 591 592 // If insertion of this operand won't cause reallocation of the operand 593 // list, just remove the implicit operands, add the operand, then re-add all 594 // the rest of the operands. 595 for (unsigned i = OpNo, e = Operands.size(); i != e; ++i) { 596 assert(Operands[i].isReg() && "Should only be an implicit reg!"); 597 Operands[i].RemoveRegOperandFromRegInfo(); 598 } 599 600 // Add the operand. If it is a register, add it to the reg list. 601 Operands.insert(Operands.begin()+OpNo, Op); 602 Operands[OpNo].ParentMI = this; 603 604 if (Operands[OpNo].isReg()) { 605 Operands[OpNo].AddRegOperandToRegInfo(RegInfo); 606 // If the register operand is flagged as early, mark the operand as such 607 if (TID->getOperandConstraint(OpNo, TOI::EARLY_CLOBBER) != -1) 608 Operands[OpNo].setIsEarlyClobber(true); 609 } 610 611 // Re-add all the implicit ops. 612 for (unsigned i = OpNo+1, e = Operands.size(); i != e; ++i) { 613 assert(Operands[i].isReg() && "Should only be an implicit reg!"); 614 Operands[i].AddRegOperandToRegInfo(RegInfo); 615 } 616 } else { 617 // Otherwise, we will be reallocating the operand list. Remove all reg 618 // operands from their list, then readd them after the operand list is 619 // reallocated. 620 RemoveRegOperandsFromUseLists(); 621 622 Operands.insert(Operands.begin()+OpNo, Op); 623 Operands[OpNo].ParentMI = this; 624 625 // Re-add all the operands. 626 AddRegOperandsToUseLists(*RegInfo); 627 628 // If the register operand is flagged as early, mark the operand as such 629 if (Operands[OpNo].isReg() 630 && TID->getOperandConstraint(OpNo, TOI::EARLY_CLOBBER) != -1) 631 Operands[OpNo].setIsEarlyClobber(true); 632 } 633} 634 635/// RemoveOperand - Erase an operand from an instruction, leaving it with one 636/// fewer operand than it started with. 637/// 638void MachineInstr::RemoveOperand(unsigned OpNo) { 639 assert(OpNo < Operands.size() && "Invalid operand number"); 640 641 // Special case removing the last one. 642 if (OpNo == Operands.size()-1) { 643 // If needed, remove from the reg def/use list. 644 if (Operands.back().isReg() && Operands.back().isOnRegUseList()) 645 Operands.back().RemoveRegOperandFromRegInfo(); 646 647 Operands.pop_back(); 648 return; 649 } 650 651 // Otherwise, we are removing an interior operand. If we have reginfo to 652 // update, remove all operands that will be shifted down from their reg lists, 653 // move everything down, then re-add them. 654 MachineRegisterInfo *RegInfo = getRegInfo(); 655 if (RegInfo) { 656 for (unsigned i = OpNo, e = Operands.size(); i != e; ++i) { 657 if (Operands[i].isReg()) 658 Operands[i].RemoveRegOperandFromRegInfo(); 659 } 660 } 661 662 Operands.erase(Operands.begin()+OpNo); 663 664 if (RegInfo) { 665 for (unsigned i = OpNo, e = Operands.size(); i != e; ++i) { 666 if (Operands[i].isReg()) 667 Operands[i].AddRegOperandToRegInfo(RegInfo); 668 } 669 } 670} 671 672/// addMemOperand - Add a MachineMemOperand to the machine instruction. 673/// This function should be used only occasionally. The setMemRefs function 674/// is the primary method for setting up a MachineInstr's MemRefs list. 675void MachineInstr::addMemOperand(MachineFunction &MF, 676 MachineMemOperand *MO) { 677 mmo_iterator OldMemRefs = MemRefs; 678 mmo_iterator OldMemRefsEnd = MemRefsEnd; 679 680 size_t NewNum = (MemRefsEnd - MemRefs) + 1; 681 mmo_iterator NewMemRefs = MF.allocateMemRefsArray(NewNum); 682 mmo_iterator NewMemRefsEnd = NewMemRefs + NewNum; 683 684 std::copy(OldMemRefs, OldMemRefsEnd, NewMemRefs); 685 NewMemRefs[NewNum - 1] = MO; 686 687 MemRefs = NewMemRefs; 688 MemRefsEnd = NewMemRefsEnd; 689} 690 691bool MachineInstr::isIdenticalTo(const MachineInstr *Other, 692 MICheckType Check) const { 693 // If opcodes or number of operands are not the same then the two 694 // instructions are obviously not identical. 695 if (Other->getOpcode() != getOpcode() || 696 Other->getNumOperands() != getNumOperands()) 697 return false; 698 699 // Check operands to make sure they match. 700 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 701 const MachineOperand &MO = getOperand(i); 702 const MachineOperand &OMO = Other->getOperand(i); 703 // Clients may or may not want to ignore defs when testing for equality. 704 // For example, machine CSE pass only cares about finding common 705 // subexpressions, so it's safe to ignore virtual register defs. 706 if (Check != CheckDefs && MO.isReg() && MO.isDef()) { 707 if (Check == IgnoreDefs) 708 continue; 709 // Check == IgnoreVRegDefs 710 if (TargetRegisterInfo::isPhysicalRegister(MO.getReg()) || 711 TargetRegisterInfo::isPhysicalRegister(OMO.getReg())) 712 if (MO.getReg() != OMO.getReg()) 713 return false; 714 } else if (!MO.isIdenticalTo(OMO)) 715 return false; 716 } 717 return true; 718} 719 720/// removeFromParent - This method unlinks 'this' from the containing basic 721/// block, and returns it, but does not delete it. 722MachineInstr *MachineInstr::removeFromParent() { 723 assert(getParent() && "Not embedded in a basic block!"); 724 getParent()->remove(this); 725 return this; 726} 727 728 729/// eraseFromParent - This method unlinks 'this' from the containing basic 730/// block, and deletes it. 731void MachineInstr::eraseFromParent() { 732 assert(getParent() && "Not embedded in a basic block!"); 733 getParent()->erase(this); 734} 735 736 737/// OperandComplete - Return true if it's illegal to add a new operand 738/// 739bool MachineInstr::OperandsComplete() const { 740 unsigned short NumOperands = TID->getNumOperands(); 741 if (!TID->isVariadic() && getNumOperands()-NumImplicitOps >= NumOperands) 742 return true; // Broken: we have all the operands of this instruction! 743 return false; 744} 745 746/// getNumExplicitOperands - Returns the number of non-implicit operands. 747/// 748unsigned MachineInstr::getNumExplicitOperands() const { 749 unsigned NumOperands = TID->getNumOperands(); 750 if (!TID->isVariadic()) 751 return NumOperands; 752 753 for (unsigned i = NumOperands, e = getNumOperands(); i != e; ++i) { 754 const MachineOperand &MO = getOperand(i); 755 if (!MO.isReg() || !MO.isImplicit()) 756 NumOperands++; 757 } 758 return NumOperands; 759} 760 761 762/// findRegisterUseOperandIdx() - Returns the MachineOperand that is a use of 763/// the specific register or -1 if it is not found. It further tightens 764/// the search criteria to a use that kills the register if isKill is true. 765int MachineInstr::findRegisterUseOperandIdx(unsigned Reg, bool isKill, 766 const TargetRegisterInfo *TRI) const { 767 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 768 const MachineOperand &MO = getOperand(i); 769 if (!MO.isReg() || !MO.isUse()) 770 continue; 771 unsigned MOReg = MO.getReg(); 772 if (!MOReg) 773 continue; 774 if (MOReg == Reg || 775 (TRI && 776 TargetRegisterInfo::isPhysicalRegister(MOReg) && 777 TargetRegisterInfo::isPhysicalRegister(Reg) && 778 TRI->isSubRegister(MOReg, Reg))) 779 if (!isKill || MO.isKill()) 780 return i; 781 } 782 return -1; 783} 784 785/// findRegisterDefOperandIdx() - Returns the operand index that is a def of 786/// the specified register or -1 if it is not found. If isDead is true, defs 787/// that are not dead are skipped. If TargetRegisterInfo is non-null, then it 788/// also checks if there is a def of a super-register. 789int MachineInstr::findRegisterDefOperandIdx(unsigned Reg, bool isDead, 790 const TargetRegisterInfo *TRI) const { 791 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 792 const MachineOperand &MO = getOperand(i); 793 if (!MO.isReg() || !MO.isDef()) 794 continue; 795 unsigned MOReg = MO.getReg(); 796 if (MOReg == Reg || 797 (TRI && 798 TargetRegisterInfo::isPhysicalRegister(MOReg) && 799 TargetRegisterInfo::isPhysicalRegister(Reg) && 800 TRI->isSubRegister(MOReg, Reg))) 801 if (!isDead || MO.isDead()) 802 return i; 803 } 804 return -1; 805} 806 807/// findFirstPredOperandIdx() - Find the index of the first operand in the 808/// operand list that is used to represent the predicate. It returns -1 if 809/// none is found. 810int MachineInstr::findFirstPredOperandIdx() const { 811 const TargetInstrDesc &TID = getDesc(); 812 if (TID.isPredicable()) { 813 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 814 if (TID.OpInfo[i].isPredicate()) 815 return i; 816 } 817 818 return -1; 819} 820 821/// isRegTiedToUseOperand - Given the index of a register def operand, 822/// check if the register def is tied to a source operand, due to either 823/// two-address elimination or inline assembly constraints. Returns the 824/// first tied use operand index by reference is UseOpIdx is not null. 825bool MachineInstr:: 826isRegTiedToUseOperand(unsigned DefOpIdx, unsigned *UseOpIdx) const { 827 if (isInlineAsm()) { 828 assert(DefOpIdx >= 2); 829 const MachineOperand &MO = getOperand(DefOpIdx); 830 if (!MO.isReg() || !MO.isDef() || MO.getReg() == 0) 831 return false; 832 // Determine the actual operand index that corresponds to this index. 833 unsigned DefNo = 0; 834 unsigned DefPart = 0; 835 for (unsigned i = 1, e = getNumOperands(); i < e; ) { 836 const MachineOperand &FMO = getOperand(i); 837 // After the normal asm operands there may be additional imp-def regs. 838 if (!FMO.isImm()) 839 return false; 840 // Skip over this def. 841 unsigned NumOps = InlineAsm::getNumOperandRegisters(FMO.getImm()); 842 unsigned PrevDef = i + 1; 843 i = PrevDef + NumOps; 844 if (i > DefOpIdx) { 845 DefPart = DefOpIdx - PrevDef; 846 break; 847 } 848 ++DefNo; 849 } 850 for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { 851 const MachineOperand &FMO = getOperand(i); 852 if (!FMO.isImm()) 853 continue; 854 if (i+1 >= e || !getOperand(i+1).isReg() || !getOperand(i+1).isUse()) 855 continue; 856 unsigned Idx; 857 if (InlineAsm::isUseOperandTiedToDef(FMO.getImm(), Idx) && 858 Idx == DefNo) { 859 if (UseOpIdx) 860 *UseOpIdx = (unsigned)i + 1 + DefPart; 861 return true; 862 } 863 } 864 return false; 865 } 866 867 assert(getOperand(DefOpIdx).isDef() && "DefOpIdx is not a def!"); 868 const TargetInstrDesc &TID = getDesc(); 869 for (unsigned i = 0, e = TID.getNumOperands(); i != e; ++i) { 870 const MachineOperand &MO = getOperand(i); 871 if (MO.isReg() && MO.isUse() && 872 TID.getOperandConstraint(i, TOI::TIED_TO) == (int)DefOpIdx) { 873 if (UseOpIdx) 874 *UseOpIdx = (unsigned)i; 875 return true; 876 } 877 } 878 return false; 879} 880 881/// isRegTiedToDefOperand - Return true if the operand of the specified index 882/// is a register use and it is tied to an def operand. It also returns the def 883/// operand index by reference. 884bool MachineInstr:: 885isRegTiedToDefOperand(unsigned UseOpIdx, unsigned *DefOpIdx) const { 886 if (isInlineAsm()) { 887 const MachineOperand &MO = getOperand(UseOpIdx); 888 if (!MO.isReg() || !MO.isUse() || MO.getReg() == 0) 889 return false; 890 891 // Find the flag operand corresponding to UseOpIdx 892 unsigned FlagIdx, NumOps=0; 893 for (FlagIdx = 1; FlagIdx < UseOpIdx; FlagIdx += NumOps+1) { 894 const MachineOperand &UFMO = getOperand(FlagIdx); 895 // After the normal asm operands there may be additional imp-def regs. 896 if (!UFMO.isImm()) 897 return false; 898 NumOps = InlineAsm::getNumOperandRegisters(UFMO.getImm()); 899 assert(NumOps < getNumOperands() && "Invalid inline asm flag"); 900 if (UseOpIdx < FlagIdx+NumOps+1) 901 break; 902 } 903 if (FlagIdx >= UseOpIdx) 904 return false; 905 const MachineOperand &UFMO = getOperand(FlagIdx); 906 unsigned DefNo; 907 if (InlineAsm::isUseOperandTiedToDef(UFMO.getImm(), DefNo)) { 908 if (!DefOpIdx) 909 return true; 910 911 unsigned DefIdx = 1; 912 // Remember to adjust the index. First operand is asm string, then there 913 // is a flag for each. 914 while (DefNo) { 915 const MachineOperand &FMO = getOperand(DefIdx); 916 assert(FMO.isImm()); 917 // Skip over this def. 918 DefIdx += InlineAsm::getNumOperandRegisters(FMO.getImm()) + 1; 919 --DefNo; 920 } 921 *DefOpIdx = DefIdx + UseOpIdx - FlagIdx; 922 return true; 923 } 924 return false; 925 } 926 927 const TargetInstrDesc &TID = getDesc(); 928 if (UseOpIdx >= TID.getNumOperands()) 929 return false; 930 const MachineOperand &MO = getOperand(UseOpIdx); 931 if (!MO.isReg() || !MO.isUse()) 932 return false; 933 int DefIdx = TID.getOperandConstraint(UseOpIdx, TOI::TIED_TO); 934 if (DefIdx == -1) 935 return false; 936 if (DefOpIdx) 937 *DefOpIdx = (unsigned)DefIdx; 938 return true; 939} 940 941/// copyKillDeadInfo - Copies kill / dead operand properties from MI. 942/// 943void MachineInstr::copyKillDeadInfo(const MachineInstr *MI) { 944 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 945 const MachineOperand &MO = MI->getOperand(i); 946 if (!MO.isReg() || (!MO.isKill() && !MO.isDead())) 947 continue; 948 for (unsigned j = 0, ee = getNumOperands(); j != ee; ++j) { 949 MachineOperand &MOp = getOperand(j); 950 if (!MOp.isIdenticalTo(MO)) 951 continue; 952 if (MO.isKill()) 953 MOp.setIsKill(); 954 else 955 MOp.setIsDead(); 956 break; 957 } 958 } 959} 960 961/// copyPredicates - Copies predicate operand(s) from MI. 962void MachineInstr::copyPredicates(const MachineInstr *MI) { 963 const TargetInstrDesc &TID = MI->getDesc(); 964 if (!TID.isPredicable()) 965 return; 966 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 967 if (TID.OpInfo[i].isPredicate()) { 968 // Predicated operands must be last operands. 969 addOperand(MI->getOperand(i)); 970 } 971 } 972} 973 974/// isSafeToMove - Return true if it is safe to move this instruction. If 975/// SawStore is set to true, it means that there is a store (or call) between 976/// the instruction's location and its intended destination. 977bool MachineInstr::isSafeToMove(const TargetInstrInfo *TII, 978 AliasAnalysis *AA, 979 bool &SawStore) const { 980 // Ignore stuff that we obviously can't move. 981 if (TID->mayStore() || TID->isCall()) { 982 SawStore = true; 983 return false; 984 } 985 if (TID->isTerminator() || TID->hasUnmodeledSideEffects()) 986 return false; 987 988 // See if this instruction does a load. If so, we have to guarantee that the 989 // loaded value doesn't change between the load and the its intended 990 // destination. The check for isInvariantLoad gives the targe the chance to 991 // classify the load as always returning a constant, e.g. a constant pool 992 // load. 993 if (TID->mayLoad() && !isInvariantLoad(AA)) 994 // Otherwise, this is a real load. If there is a store between the load and 995 // end of block, or if the load is volatile, we can't move it. 996 return !SawStore && !hasVolatileMemoryRef(); 997 998 return true; 999} 1000 1001/// isSafeToReMat - Return true if it's safe to rematerialize the specified 1002/// instruction which defined the specified register instead of copying it. 1003bool MachineInstr::isSafeToReMat(const TargetInstrInfo *TII, 1004 AliasAnalysis *AA, 1005 unsigned DstReg) const { 1006 bool SawStore = false; 1007 if (!TII->isTriviallyReMaterializable(this, AA) || 1008 !isSafeToMove(TII, AA, SawStore)) 1009 return false; 1010 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 1011 const MachineOperand &MO = getOperand(i); 1012 if (!MO.isReg()) 1013 continue; 1014 // FIXME: For now, do not remat any instruction with register operands. 1015 // Later on, we can loosen the restriction is the register operands have 1016 // not been modified between the def and use. Note, this is different from 1017 // MachineSink because the code is no longer in two-address form (at least 1018 // partially). 1019 if (MO.isUse()) 1020 return false; 1021 else if (!MO.isDead() && MO.getReg() != DstReg) 1022 return false; 1023 } 1024 return true; 1025} 1026 1027/// hasVolatileMemoryRef - Return true if this instruction may have a 1028/// volatile memory reference, or if the information describing the 1029/// memory reference is not available. Return false if it is known to 1030/// have no volatile memory references. 1031bool MachineInstr::hasVolatileMemoryRef() const { 1032 // An instruction known never to access memory won't have a volatile access. 1033 if (!TID->mayStore() && 1034 !TID->mayLoad() && 1035 !TID->isCall() && 1036 !TID->hasUnmodeledSideEffects()) 1037 return false; 1038 1039 // Otherwise, if the instruction has no memory reference information, 1040 // conservatively assume it wasn't preserved. 1041 if (memoperands_empty()) 1042 return true; 1043 1044 // Check the memory reference information for volatile references. 1045 for (mmo_iterator I = memoperands_begin(), E = memoperands_end(); I != E; ++I) 1046 if ((*I)->isVolatile()) 1047 return true; 1048 1049 return false; 1050} 1051 1052/// isInvariantLoad - Return true if this instruction is loading from a 1053/// location whose value is invariant across the function. For example, 1054/// loading a value from the constant pool or from the argument area 1055/// of a function if it does not change. This should only return true of 1056/// *all* loads the instruction does are invariant (if it does multiple loads). 1057bool MachineInstr::isInvariantLoad(AliasAnalysis *AA) const { 1058 // If the instruction doesn't load at all, it isn't an invariant load. 1059 if (!TID->mayLoad()) 1060 return false; 1061 1062 // If the instruction has lost its memoperands, conservatively assume that 1063 // it may not be an invariant load. 1064 if (memoperands_empty()) 1065 return false; 1066 1067 const MachineFrameInfo *MFI = getParent()->getParent()->getFrameInfo(); 1068 1069 for (mmo_iterator I = memoperands_begin(), 1070 E = memoperands_end(); I != E; ++I) { 1071 if ((*I)->isVolatile()) return false; 1072 if ((*I)->isStore()) return false; 1073 1074 if (const Value *V = (*I)->getValue()) { 1075 // A load from a constant PseudoSourceValue is invariant. 1076 if (const PseudoSourceValue *PSV = dyn_cast<PseudoSourceValue>(V)) 1077 if (PSV->isConstant(MFI)) 1078 continue; 1079 // If we have an AliasAnalysis, ask it whether the memory is constant. 1080 if (AA && AA->pointsToConstantMemory(V)) 1081 continue; 1082 } 1083 1084 // Otherwise assume conservatively. 1085 return false; 1086 } 1087 1088 // Everything checks out. 1089 return true; 1090} 1091 1092/// isConstantValuePHI - If the specified instruction is a PHI that always 1093/// merges together the same virtual register, return the register, otherwise 1094/// return 0. 1095unsigned MachineInstr::isConstantValuePHI() const { 1096 if (!isPHI()) 1097 return 0; 1098 assert(getNumOperands() >= 3 && 1099 "It's illegal to have a PHI without source operands"); 1100 1101 unsigned Reg = getOperand(1).getReg(); 1102 for (unsigned i = 3, e = getNumOperands(); i < e; i += 2) 1103 if (getOperand(i).getReg() != Reg) 1104 return 0; 1105 return Reg; 1106} 1107 1108/// allDefsAreDead - Return true if all the defs of this instruction are dead. 1109/// 1110bool MachineInstr::allDefsAreDead() const { 1111 for (unsigned i = 0, e = getNumOperands(); i < e; ++i) { 1112 const MachineOperand &MO = getOperand(i); 1113 if (!MO.isReg() || MO.isUse()) 1114 continue; 1115 if (!MO.isDead()) 1116 return false; 1117 } 1118 return true; 1119} 1120 1121void MachineInstr::dump() const { 1122 dbgs() << " " << *this; 1123} 1124 1125void MachineInstr::print(raw_ostream &OS, const TargetMachine *TM) const { 1126 // We can be a bit tidier if we know the TargetMachine and/or MachineFunction. 1127 const MachineFunction *MF = 0; 1128 if (const MachineBasicBlock *MBB = getParent()) { 1129 MF = MBB->getParent(); 1130 if (!TM && MF) 1131 TM = &MF->getTarget(); 1132 } 1133 1134 // Print explicitly defined operands on the left of an assignment syntax. 1135 unsigned StartOp = 0, e = getNumOperands(); 1136 for (; StartOp < e && getOperand(StartOp).isReg() && 1137 getOperand(StartOp).isDef() && 1138 !getOperand(StartOp).isImplicit(); 1139 ++StartOp) { 1140 if (StartOp != 0) OS << ", "; 1141 getOperand(StartOp).print(OS, TM); 1142 } 1143 1144 if (StartOp != 0) 1145 OS << " = "; 1146 1147 // Print the opcode name. 1148 OS << getDesc().getName(); 1149 1150 // Print the rest of the operands. 1151 bool OmittedAnyCallClobbers = false; 1152 bool FirstOp = true; 1153 for (unsigned i = StartOp, e = getNumOperands(); i != e; ++i) { 1154 const MachineOperand &MO = getOperand(i); 1155 1156 // Omit call-clobbered registers which aren't used anywhere. This makes 1157 // call instructions much less noisy on targets where calls clobber lots 1158 // of registers. Don't rely on MO.isDead() because we may be called before 1159 // LiveVariables is run, or we may be looking at a non-allocatable reg. 1160 if (MF && getDesc().isCall() && 1161 MO.isReg() && MO.isImplicit() && MO.isDef()) { 1162 unsigned Reg = MO.getReg(); 1163 if (Reg != 0 && TargetRegisterInfo::isPhysicalRegister(Reg)) { 1164 const MachineRegisterInfo &MRI = MF->getRegInfo(); 1165 if (MRI.use_empty(Reg) && !MRI.isLiveOut(Reg)) { 1166 bool HasAliasLive = false; 1167 for (const unsigned *Alias = TM->getRegisterInfo()->getAliasSet(Reg); 1168 unsigned AliasReg = *Alias; ++Alias) 1169 if (!MRI.use_empty(AliasReg) || MRI.isLiveOut(AliasReg)) { 1170 HasAliasLive = true; 1171 break; 1172 } 1173 if (!HasAliasLive) { 1174 OmittedAnyCallClobbers = true; 1175 continue; 1176 } 1177 } 1178 } 1179 } 1180 1181 if (FirstOp) FirstOp = false; else OS << ","; 1182 OS << " "; 1183 if (i < getDesc().NumOperands) { 1184 const TargetOperandInfo &TOI = getDesc().OpInfo[i]; 1185 if (TOI.isPredicate()) 1186 OS << "pred:"; 1187 if (TOI.isOptionalDef()) 1188 OS << "opt:"; 1189 } 1190 MO.print(OS, TM); 1191 } 1192 1193 // Briefly indicate whether any call clobbers were omitted. 1194 if (OmittedAnyCallClobbers) { 1195 if (!FirstOp) OS << ","; 1196 OS << " ..."; 1197 } 1198 1199 bool HaveSemi = false; 1200 if (!memoperands_empty()) { 1201 if (!HaveSemi) OS << ";"; HaveSemi = true; 1202 1203 OS << " mem:"; 1204 for (mmo_iterator i = memoperands_begin(), e = memoperands_end(); 1205 i != e; ++i) { 1206 OS << **i; 1207 if (next(i) != e) 1208 OS << " "; 1209 } 1210 } 1211 1212 if (!debugLoc.isUnknown() && MF) { 1213 if (!HaveSemi) OS << ";"; 1214 1215 // TODO: print InlinedAtLoc information 1216 1217 DIScope Scope(debugLoc.getScope(MF->getFunction()->getContext())); 1218 OS << " dbg:"; 1219 // Omit the directory, since it's usually long and uninteresting. 1220 if (Scope.Verify()) 1221 OS << Scope.getFilename(); 1222 else 1223 OS << "<unknown>"; 1224 OS << ':' << debugLoc.getLine(); 1225 if (debugLoc.getCol() != 0) 1226 OS << ':' << debugLoc.getCol(); 1227 } 1228 1229 OS << "\n"; 1230} 1231 1232bool MachineInstr::addRegisterKilled(unsigned IncomingReg, 1233 const TargetRegisterInfo *RegInfo, 1234 bool AddIfNotFound) { 1235 bool isPhysReg = TargetRegisterInfo::isPhysicalRegister(IncomingReg); 1236 bool hasAliases = isPhysReg && RegInfo->getAliasSet(IncomingReg); 1237 bool Found = false; 1238 SmallVector<unsigned,4> DeadOps; 1239 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 1240 MachineOperand &MO = getOperand(i); 1241 if (!MO.isReg() || !MO.isUse() || MO.isUndef()) 1242 continue; 1243 unsigned Reg = MO.getReg(); 1244 if (!Reg) 1245 continue; 1246 1247 if (Reg == IncomingReg) { 1248 if (!Found) { 1249 if (MO.isKill()) 1250 // The register is already marked kill. 1251 return true; 1252 if (isPhysReg && isRegTiedToDefOperand(i)) 1253 // Two-address uses of physregs must not be marked kill. 1254 return true; 1255 MO.setIsKill(); 1256 Found = true; 1257 } 1258 } else if (hasAliases && MO.isKill() && 1259 TargetRegisterInfo::isPhysicalRegister(Reg)) { 1260 // A super-register kill already exists. 1261 if (RegInfo->isSuperRegister(IncomingReg, Reg)) 1262 return true; 1263 if (RegInfo->isSubRegister(IncomingReg, Reg)) 1264 DeadOps.push_back(i); 1265 } 1266 } 1267 1268 // Trim unneeded kill operands. 1269 while (!DeadOps.empty()) { 1270 unsigned OpIdx = DeadOps.back(); 1271 if (getOperand(OpIdx).isImplicit()) 1272 RemoveOperand(OpIdx); 1273 else 1274 getOperand(OpIdx).setIsKill(false); 1275 DeadOps.pop_back(); 1276 } 1277 1278 // If not found, this means an alias of one of the operands is killed. Add a 1279 // new implicit operand if required. 1280 if (!Found && AddIfNotFound) { 1281 addOperand(MachineOperand::CreateReg(IncomingReg, 1282 false /*IsDef*/, 1283 true /*IsImp*/, 1284 true /*IsKill*/)); 1285 return true; 1286 } 1287 return Found; 1288} 1289 1290bool MachineInstr::addRegisterDead(unsigned IncomingReg, 1291 const TargetRegisterInfo *RegInfo, 1292 bool AddIfNotFound) { 1293 bool isPhysReg = TargetRegisterInfo::isPhysicalRegister(IncomingReg); 1294 bool hasAliases = isPhysReg && RegInfo->getAliasSet(IncomingReg); 1295 bool Found = false; 1296 SmallVector<unsigned,4> DeadOps; 1297 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 1298 MachineOperand &MO = getOperand(i); 1299 if (!MO.isReg() || !MO.isDef()) 1300 continue; 1301 unsigned Reg = MO.getReg(); 1302 if (!Reg) 1303 continue; 1304 1305 if (Reg == IncomingReg) { 1306 if (!Found) { 1307 if (MO.isDead()) 1308 // The register is already marked dead. 1309 return true; 1310 MO.setIsDead(); 1311 Found = true; 1312 } 1313 } else if (hasAliases && MO.isDead() && 1314 TargetRegisterInfo::isPhysicalRegister(Reg)) { 1315 // There exists a super-register that's marked dead. 1316 if (RegInfo->isSuperRegister(IncomingReg, Reg)) 1317 return true; 1318 if (RegInfo->getSubRegisters(IncomingReg) && 1319 RegInfo->getSuperRegisters(Reg) && 1320 RegInfo->isSubRegister(IncomingReg, Reg)) 1321 DeadOps.push_back(i); 1322 } 1323 } 1324 1325 // Trim unneeded dead operands. 1326 while (!DeadOps.empty()) { 1327 unsigned OpIdx = DeadOps.back(); 1328 if (getOperand(OpIdx).isImplicit()) 1329 RemoveOperand(OpIdx); 1330 else 1331 getOperand(OpIdx).setIsDead(false); 1332 DeadOps.pop_back(); 1333 } 1334 1335 // If not found, this means an alias of one of the operands is dead. Add a 1336 // new implicit operand if required. 1337 if (Found || !AddIfNotFound) 1338 return Found; 1339 1340 addOperand(MachineOperand::CreateReg(IncomingReg, 1341 true /*IsDef*/, 1342 true /*IsImp*/, 1343 false /*IsKill*/, 1344 true /*IsDead*/)); 1345 return true; 1346} 1347 1348void MachineInstr::addRegisterDefined(unsigned IncomingReg, 1349 const TargetRegisterInfo *RegInfo) { 1350 MachineOperand *MO = findRegisterDefOperand(IncomingReg, false, RegInfo); 1351 if (!MO || MO->getSubReg()) 1352 addOperand(MachineOperand::CreateReg(IncomingReg, 1353 true /*IsDef*/, 1354 true /*IsImp*/)); 1355} 1356 1357unsigned 1358MachineInstrExpressionTrait::getHashValue(const MachineInstr* const &MI) { 1359 unsigned Hash = MI->getOpcode() * 37; 1360 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 1361 const MachineOperand &MO = MI->getOperand(i); 1362 uint64_t Key = (uint64_t)MO.getType() << 32; 1363 switch (MO.getType()) { 1364 default: break; 1365 case MachineOperand::MO_Register: 1366 if (MO.isDef() && MO.getReg() && 1367 TargetRegisterInfo::isVirtualRegister(MO.getReg())) 1368 continue; // Skip virtual register defs. 1369 Key |= MO.getReg(); 1370 break; 1371 case MachineOperand::MO_Immediate: 1372 Key |= MO.getImm(); 1373 break; 1374 case MachineOperand::MO_FrameIndex: 1375 case MachineOperand::MO_ConstantPoolIndex: 1376 case MachineOperand::MO_JumpTableIndex: 1377 Key |= MO.getIndex(); 1378 break; 1379 case MachineOperand::MO_MachineBasicBlock: 1380 Key |= DenseMapInfo<void*>::getHashValue(MO.getMBB()); 1381 break; 1382 case MachineOperand::MO_GlobalAddress: 1383 Key |= DenseMapInfo<void*>::getHashValue(MO.getGlobal()); 1384 break; 1385 case MachineOperand::MO_BlockAddress: 1386 Key |= DenseMapInfo<void*>::getHashValue(MO.getBlockAddress()); 1387 break; 1388 case MachineOperand::MO_MCSymbol: 1389 Key |= DenseMapInfo<void*>::getHashValue(MO.getMCSymbol()); 1390 break; 1391 } 1392 Key += ~(Key << 32); 1393 Key ^= (Key >> 22); 1394 Key += ~(Key << 13); 1395 Key ^= (Key >> 8); 1396 Key += (Key << 3); 1397 Key ^= (Key >> 15); 1398 Key += ~(Key << 27); 1399 Key ^= (Key >> 31); 1400 Hash = (unsigned)Key + Hash * 37; 1401 } 1402 return Hash; 1403} 1404