lib/CodeGen/MachineInstr.cpp

   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/Constants.h"
  15 #include "llvm/CodeGen/MachineInstr.h"
  16 #include "llvm/Value.h"
  17 #include "llvm/CodeGen/MachineFunction.h"
  18 #include "llvm/CodeGen/MachineRegisterInfo.h"
  19 #include "llvm/CodeGen/PseudoSourceValue.h"
  20 #include "llvm/CodeGen/SelectionDAGNodes.h"
  21 #include "llvm/Target/TargetMachine.h"
  22 #include "llvm/Target/TargetInstrInfo.h"
  23 #include "llvm/Target/TargetInstrDesc.h"
  24 #include "llvm/Target/TargetRegisterInfo.h"
  25 #include "llvm/Support/LeakDetector.h"
  26 #include "llvm/Support/MathExtras.h"
  27 #include "llvm/Support/Streams.h"
  28 #include <ostream>
  29 using namespace llvm;
  30
  31 //===----------------------------------------------------------------------===//
  32 // MachineOperand Implementation
  33 //===----------------------------------------------------------------------===//
  34
  35 /// AddRegOperandToRegInfo - Add this register operand to the specified
  36 /// MachineRegisterInfo.  If it is null, then the next/prev fields should be
  37 /// explicitly nulled out.
  38 void MachineOperand::AddRegOperandToRegInfo(MachineRegisterInfo *RegInfo) {
  39   assert(isReg() && "Can only add reg operand to use lists");
  40
  41   // If the reginfo pointer is null, just explicitly null out or next/prev
  42   // pointers, to ensure they are not garbage.
  43   if (RegInfo == 0) {
  44     Contents.Reg.Prev = 0;
  45     Contents.Reg.Next = 0;
  46     return;
  47   }
  48
  49   // Otherwise, add this operand to the head of the registers use/def list.
  50   MachineOperand **Head = &RegInfo->getRegUseDefListHead(getReg());
  51
  52   // For SSA values, we prefer to keep the definition at the start of the list.
  53   // we do this by skipping over the definition if it is at the head of the
  54   // list.
  55   if (*Head && (*Head)->isDef())
  56     Head = &(*Head)->Contents.Reg.Next;
  57
  58   Contents.Reg.Next = *Head;
  59   if (Contents.Reg.Next) {
  60     assert(getReg() == Contents.Reg.Next->getReg() &&
  61            "Different regs on the same list!");
  62     Contents.Reg.Next->Contents.Reg.Prev = &Contents.Reg.Next;
  63   }
  64
  65   Contents.Reg.Prev = Head;
  66   *Head = this;
  67 }
  68
  69 void MachineOperand::setReg(unsigned Reg) {
  70   if (getReg() == Reg) return; // No change.
  71
  72   // Otherwise, we have to change the register.  If this operand is embedded
  73   // into a machine function, we need to update the old and new register's
  74   // use/def lists.
  75   if (MachineInstr *MI = getParent())
  76     if (MachineBasicBlock *MBB = MI->getParent())
  77       if (MachineFunction *MF = MBB->getParent()) {
  78         RemoveRegOperandFromRegInfo();
  79         Contents.Reg.RegNo = Reg;
  80         AddRegOperandToRegInfo(&MF->getRegInfo());
  81         return;
  82       }
  83
  84   // Otherwise, just change the register, no problem.  :)
  85   Contents.Reg.RegNo = Reg;
  86 }
  87
  88 /// ChangeToImmediate - Replace this operand with a new immediate operand of
  89 /// the specified value.  If an operand is known to be an immediate already,
  90 /// the setImm method should be used.
  91 void MachineOperand::ChangeToImmediate(int64_t ImmVal) {
  92   // If this operand is currently a register operand, and if this is in a
  93   // function, deregister the operand from the register's use/def list.
  94   if (isReg() && getParent() && getParent()->getParent() &&
  95       getParent()->getParent()->getParent())
  96     RemoveRegOperandFromRegInfo();
  97
  98   OpKind = MO_Immediate;
  99   Contents.ImmVal = ImmVal;
 100 }
 101
 102 /// ChangeToRegister - Replace this operand with a new register operand of
 103 /// the specified value.  If an operand is known to be an register already,
 104 /// the setReg method should be used.
 105 void MachineOperand::ChangeToRegister(unsigned Reg, bool isDef, bool isImp,
 106                                       bool isKill, bool isDead) {
 107   // If this operand is already a register operand, use setReg to update the
 108   // register's use/def lists.
 109   if (isReg()) {
 110     setReg(Reg);
 111   } else {
 112     // Otherwise, change this to a register and set the reg#.
 113     OpKind = MO_Register;
 114     Contents.Reg.RegNo = Reg;
 115
 116     // If this operand is embedded in a function, add the operand to the
 117     // register's use/def list.
 118     if (MachineInstr *MI = getParent())
 119       if (MachineBasicBlock *MBB = MI->getParent())
 120         if (MachineFunction *MF = MBB->getParent())
 121           AddRegOperandToRegInfo(&MF->getRegInfo());
 122   }
 123
 124   IsDef = isDef;
 125   IsImp = isImp;
 126   IsKill = isKill;
 127   IsDead = isDead;
 128   SubReg = 0;
 129 }
 130
 131 /// isIdenticalTo - Return true if this operand is identical to the specified
 132 /// operand.
 133 bool MachineOperand::isIdenticalTo(const MachineOperand &Other) const {
 134   if (getType() != Other.getType()) return false;
 135
 136   switch (getType()) {
 137   default: assert(0 && "Unrecognized operand type");
 138   case MachineOperand::MO_Register:
 139     return getReg() == Other.getReg() && isDef() == Other.isDef() &&
 140            getSubReg() == Other.getSubReg();
 141   case MachineOperand::MO_Immediate:
 142     return getImm() == Other.getImm();
 143   case MachineOperand::MO_FPImmediate:
 144     return getFPImm() == Other.getFPImm();
 145   case MachineOperand::MO_MachineBasicBlock:
 146     return getMBB() == Other.getMBB();
 147   case MachineOperand::MO_FrameIndex:
 148     return getIndex() == Other.getIndex();
 149   case MachineOperand::MO_ConstantPoolIndex:
 150     return getIndex() == Other.getIndex() && getOffset() == Other.getOffset();
 151   case MachineOperand::MO_JumpTableIndex:
 152     return getIndex() == Other.getIndex();
 153   case MachineOperand::MO_GlobalAddress:
 154     return getGlobal() == Other.getGlobal() && getOffset() == Other.getOffset();
 155   case MachineOperand::MO_ExternalSymbol:
 156     return !strcmp(getSymbolName(), Other.getSymbolName()) &&
 157            getOffset() == Other.getOffset();
 158   }
 159 }
 160
 161 /// print - Print the specified machine operand.
 162 ///
 163 void MachineOperand::print(std::ostream &OS, const TargetMachine *TM) const {
 164   switch (getType()) {
 165   case MachineOperand::MO_Register:
 166     if (getReg() == 0 || TargetRegisterInfo::isVirtualRegister(getReg())) {
 167       OS << "%reg" << getReg();
 168     } else {
 169       // If the instruction is embedded into a basic block, we can find the
 170       // target info for the instruction.
 171       if (TM == 0)
 172         if (const MachineInstr *MI = getParent())
 173           if (const MachineBasicBlock *MBB = MI->getParent())
 174             if (const MachineFunction *MF = MBB->getParent())
 175               TM = &MF->getTarget();
 176
 177       if (TM)
 178         OS << "%" << TM->getRegisterInfo()->get(getReg()).Name;
 179       else
 180         OS << "%mreg" << getReg();
 181     }
 182
 183     if (isDef() || isKill() || isDead() || isImplicit()) {
 184       OS << "<";
 185       bool NeedComma = false;
 186       if (isImplicit()) {
 187         OS << (isDef() ? "imp-def" : "imp-use");
 188         NeedComma = true;
 189       } else if (isDef()) {
 190         OS << "def";
 191         NeedComma = true;
 192       }
 193       if (isKill() || isDead()) {
 194         if (NeedComma) OS << ",";
 195         if (isKill())  OS << "kill";
 196         if (isDead())  OS << "dead";
 197       }
 198       OS << ">";
 199     }
 200     break;
 201   case MachineOperand::MO_Immediate:
 202     OS << getImm();
 203     break;
 204   case MachineOperand::MO_FPImmediate:
 205     if (getFPImm()->getType() == Type::FloatTy) {
 206       OS << getFPImm()->getValueAPF().convertToFloat();
 207     } else {
 208       OS << getFPImm()->getValueAPF().convertToDouble();
 209     }
 210     break;
 211   case MachineOperand::MO_MachineBasicBlock:
 212     OS << "mbb<"
 213        << ((Value*)getMBB()->getBasicBlock())->getName()
 214        << "," << (void*)getMBB() << ">";
 215     break;
 216   case MachineOperand::MO_FrameIndex:
 217     OS << "<fi#" << getIndex() << ">";
 218     break;
 219   case MachineOperand::MO_ConstantPoolIndex:
 220     OS << "<cp#" << getIndex();
 221     if (getOffset()) OS << "+" << getOffset();
 222     OS << ">";
 223     break;
 224   case MachineOperand::MO_JumpTableIndex:
 225     OS << "<jt#" << getIndex() << ">";
 226     break;
 227   case MachineOperand::MO_GlobalAddress:
 228     OS << "<ga:" << ((Value*)getGlobal())->getName();
 229     if (getOffset()) OS << "+" << getOffset();
 230     OS << ">";
 231     break;
 232   case MachineOperand::MO_ExternalSymbol:
 233     OS << "<es:" << getSymbolName();
 234     if (getOffset()) OS << "+" << getOffset();
 235     OS << ">";
 236     break;
 237   default:
 238     assert(0 && "Unrecognized operand type");
 239   }
 240 }
 241
 242 //===----------------------------------------------------------------------===//
 243 // MachineMemOperand Implementation
 244 //===----------------------------------------------------------------------===//
 245
 246 MachineMemOperand::MachineMemOperand(const Value *v, unsigned int f,
 247                                      int64_t o, uint64_t s, unsigned int a)
 248   : Offset(o), Size(s), V(v),
 249     Flags((f & 7) | ((Log2_32(a) + 1) << 3)) {
 250 }
 251
 252 //===----------------------------------------------------------------------===//
 253 // MachineInstr Implementation
 254 //===----------------------------------------------------------------------===//
 255
 256 /// MachineInstr ctor - This constructor creates a dummy MachineInstr with
 257 /// TID NULL and no operands.
 258 MachineInstr::MachineInstr()
 259   : TID(0), NumImplicitOps(0), Parent(0) {
 260   // Make sure that we get added to a machine basicblock
 261   LeakDetector::addGarbageObject(this);
 262 }
 263
 264 void MachineInstr::addImplicitDefUseOperands() {
 265   if (TID->ImplicitDefs)
 266     for (const unsigned *ImpDefs = TID->ImplicitDefs; *ImpDefs; ++ImpDefs)
 267       addOperand(MachineOperand::CreateReg(*ImpDefs, true, true));
 268   if (TID->ImplicitUses)
 269     for (const unsigned *ImpUses = TID->ImplicitUses; *ImpUses; ++ImpUses)
 270       addOperand(MachineOperand::CreateReg(*ImpUses, false, true));
 271 }
 272
 273 /// MachineInstr ctor - This constructor create a MachineInstr and add the
 274 /// implicit operands. It reserves space for number of operands specified by
 275 /// TargetInstrDesc or the numOperands if it is not zero. (for
 276 /// instructions with variable number of operands).
 277 MachineInstr::MachineInstr(const TargetInstrDesc &tid, bool NoImp)
 278   : TID(&tid), NumImplicitOps(0), Parent(0) {
 279   if (!NoImp && TID->getImplicitDefs())
 280     for (const unsigned *ImpDefs = TID->getImplicitDefs(); *ImpDefs; ++ImpDefs)
 281       NumImplicitOps++;
 282   if (!NoImp && TID->getImplicitUses())
 283     for (const unsigned *ImpUses = TID->getImplicitUses(); *ImpUses; ++ImpUses)
 284       NumImplicitOps++;
 285   Operands.reserve(NumImplicitOps + TID->getNumOperands());
 286   if (!NoImp)
 287     addImplicitDefUseOperands();
 288   // Make sure that we get added to a machine basicblock
 289   LeakDetector::addGarbageObject(this);
 290 }
 291
 292 /// MachineInstr ctor - Work exactly the same as the ctor above, except that the
 293 /// MachineInstr is created and added to the end of the specified basic block.
 294 ///
 295 MachineInstr::MachineInstr(MachineBasicBlock *MBB,
 296                            const TargetInstrDesc &tid)
 297   : TID(&tid), NumImplicitOps(0), Parent(0) {
 298   assert(MBB && "Cannot use inserting ctor with null basic block!");
 299   if (TID->ImplicitDefs)
 300     for (const unsigned *ImpDefs = TID->getImplicitDefs(); *ImpDefs; ++ImpDefs)
 301       NumImplicitOps++;
 302   if (TID->ImplicitUses)
 303     for (const unsigned *ImpUses = TID->getImplicitUses(); *ImpUses; ++ImpUses)
 304       NumImplicitOps++;
 305   Operands.reserve(NumImplicitOps + TID->getNumOperands());
 306   addImplicitDefUseOperands();
 307   // Make sure that we get added to a machine basicblock
 308   LeakDetector::addGarbageObject(this);
 309   MBB->push_back(this);  // Add instruction to end of basic block!
 310 }
 311
 312 /// MachineInstr ctor - Copies MachineInstr arg exactly
 313 ///
 314 MachineInstr::MachineInstr(const MachineInstr &MI) {
 315   TID = &MI.getDesc();
 316   NumImplicitOps = MI.NumImplicitOps;
 317   Operands.reserve(MI.getNumOperands());
 318   MemOperands = MI.MemOperands;
 319
 320   // Add operands
 321   for (unsigned i = 0; i != MI.getNumOperands(); ++i) {
 322     Operands.push_back(MI.getOperand(i));
 323     Operands.back().ParentMI = this;
 324   }
 325
 326   // Set parent, next, and prev to null
 327   Parent = 0;
 328   Prev = 0;
 329   Next = 0;
 330 }
 331
 332
 333 MachineInstr::~MachineInstr() {
 334   LeakDetector::removeGarbageObject(this);
 335 #ifndef NDEBUG
 336   for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
 337     assert(Operands[i].ParentMI == this && "ParentMI mismatch!");
 338     assert((!Operands[i].isReg() || !Operands[i].isOnRegUseList()) &&
 339            "Reg operand def/use list corrupted");
 340   }
 341 #endif
 342 }
 343
 344 /// getOpcode - Returns the opcode of this MachineInstr.
 345 ///
 346 int MachineInstr::getOpcode() const {
 347   return TID->Opcode;
 348 }
 349
 350 /// getRegInfo - If this instruction is embedded into a MachineFunction,
 351 /// return the MachineRegisterInfo object for the current function, otherwise
 352 /// return null.
 353 MachineRegisterInfo *MachineInstr::getRegInfo() {
 354   if (MachineBasicBlock *MBB = getParent())
 355     if (MachineFunction *MF = MBB->getParent())
 356       return &MF->getRegInfo();
 357   return 0;
 358 }
 359
 360 /// RemoveRegOperandsFromUseLists - Unlink all of the register operands in
 361 /// this instruction from their respective use lists.  This requires that the
 362 /// operands already be on their use lists.
 363 void MachineInstr::RemoveRegOperandsFromUseLists() {
 364   for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
 365     if (Operands[i].isReg())
 366       Operands[i].RemoveRegOperandFromRegInfo();
 367   }
 368 }
 369
 370 /// AddRegOperandsToUseLists - Add all of the register operands in
 371 /// this instruction from their respective use lists.  This requires that the
 372 /// operands not be on their use lists yet.
 373 void MachineInstr::AddRegOperandsToUseLists(MachineRegisterInfo &RegInfo) {
 374   for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
 375     if (Operands[i].isReg())
 376       Operands[i].AddRegOperandToRegInfo(&RegInfo);
 377   }
 378 }
 379
 380
 381 /// addOperand - Add the specified operand to the instruction.  If it is an
 382 /// implicit operand, it is added to the end of the operand list.  If it is
 383 /// an explicit operand it is added at the end of the explicit operand list
 384 /// (before the first implicit operand).
 385 void MachineInstr::addOperand(const MachineOperand &Op) {
 386   bool isImpReg = Op.isReg() && Op.isImplicit();
 387   assert((isImpReg || !OperandsComplete()) &&
 388          "Trying to add an operand to a machine instr that is already done!");
 389
 390   // If we are adding the operand to the end of the list, our job is simpler.
 391   // This is true most of the time, so this is a reasonable optimization.
 392   if (isImpReg || NumImplicitOps == 0) {
 393     // We can only do this optimization if we know that the operand list won't
 394     // reallocate.
 395     if (Operands.empty() || Operands.size()+1 <= Operands.capacity()) {
 396       Operands.push_back(Op);
 397
 398       // Set the parent of the operand.
 399       Operands.back().ParentMI = this;
 400
 401       // If the operand is a register, update the operand's use list.
 402       if (Op.isReg())
 403         Operands.back().AddRegOperandToRegInfo(getRegInfo());
 404       return;
 405     }
 406   }
 407
 408   // Otherwise, we have to insert a real operand before any implicit ones.
 409   unsigned OpNo = Operands.size()-NumImplicitOps;
 410
 411   MachineRegisterInfo *RegInfo = getRegInfo();
 412
 413   // If this instruction isn't embedded into a function, then we don't need to
 414   // update any operand lists.
 415   if (RegInfo == 0) {
 416     // Simple insertion, no reginfo update needed for other register operands.
 417     Operands.insert(Operands.begin()+OpNo, Op);
 418     Operands[OpNo].ParentMI = this;
 419
 420     // Do explicitly set the reginfo for this operand though, to ensure the
 421     // next/prev fields are properly nulled out.
 422     if (Operands[OpNo].isReg())
 423       Operands[OpNo].AddRegOperandToRegInfo(0);
 424
 425   } else if (Operands.size()+1 <= Operands.capacity()) {
 426     // Otherwise, we have to remove register operands from their register use
 427     // list, add the operand, then add the register operands back to their use
 428     // list.  This also must handle the case when the operand list reallocates
 429     // to somewhere else.
 430
 431     // If insertion of this operand won't cause reallocation of the operand
 432     // list, just remove the implicit operands, add the operand, then re-add all
 433     // the rest of the operands.
 434     for (unsigned i = OpNo, e = Operands.size(); i != e; ++i) {
 435       assert(Operands[i].isReg() && "Should only be an implicit reg!");
 436       Operands[i].RemoveRegOperandFromRegInfo();
 437     }
 438
 439     // Add the operand.  If it is a register, add it to the reg list.
 440     Operands.insert(Operands.begin()+OpNo, Op);
 441     Operands[OpNo].ParentMI = this;
 442
 443     if (Operands[OpNo].isReg())
 444       Operands[OpNo].AddRegOperandToRegInfo(RegInfo);
 445
 446     // Re-add all the implicit ops.
 447     for (unsigned i = OpNo+1, e = Operands.size(); i != e; ++i) {
 448       assert(Operands[i].isReg() && "Should only be an implicit reg!");
 449       Operands[i].AddRegOperandToRegInfo(RegInfo);
 450     }
 451   } else {
 452     // Otherwise, we will be reallocating the operand list.  Remove all reg
 453     // operands from their list, then readd them after the operand list is
 454     // reallocated.
 455     RemoveRegOperandsFromUseLists();
 456
 457     Operands.insert(Operands.begin()+OpNo, Op);
 458     Operands[OpNo].ParentMI = this;
 459
 460     // Re-add all the operands.
 461     AddRegOperandsToUseLists(*RegInfo);
 462   }
 463 }
 464
 465 /// RemoveOperand - Erase an operand  from an instruction, leaving it with one
 466 /// fewer operand than it started with.
 467 ///
 468 void MachineInstr::RemoveOperand(unsigned OpNo) {
 469   assert(OpNo < Operands.size() && "Invalid operand number");
 470
 471   // Special case removing the last one.
 472   if (OpNo == Operands.size()-1) {
 473     // If needed, remove from the reg def/use list.
 474     if (Operands.back().isReg() && Operands.back().isOnRegUseList())
 475       Operands.back().RemoveRegOperandFromRegInfo();
 476
 477     Operands.pop_back();
 478     return;
 479   }
 480
 481   // Otherwise, we are removing an interior operand.  If we have reginfo to
 482   // update, remove all operands that will be shifted down from their reg lists,
 483   // move everything down, then re-add them.
 484   MachineRegisterInfo *RegInfo = getRegInfo();
 485   if (RegInfo) {
 486     for (unsigned i = OpNo, e = Operands.size(); i != e; ++i) {
 487       if (Operands[i].isReg())
 488         Operands[i].RemoveRegOperandFromRegInfo();
 489     }
 490   }
 491
 492   Operands.erase(Operands.begin()+OpNo);
 493
 494   if (RegInfo) {
 495     for (unsigned i = OpNo, e = Operands.size(); i != e; ++i) {
 496       if (Operands[i].isReg())
 497         Operands[i].AddRegOperandToRegInfo(RegInfo);
 498     }
 499   }
 500 }
 501
 502
 503 /// removeFromParent - This method unlinks 'this' from the containing basic
 504 /// block, and returns it, but does not delete it.
 505 MachineInstr *MachineInstr::removeFromParent() {
 506   assert(getParent() && "Not embedded in a basic block!");
 507   getParent()->remove(this);
 508   return this;
 509 }
 510
 511
 512 /// OperandComplete - Return true if it's illegal to add a new operand
 513 ///
 514 bool MachineInstr::OperandsComplete() const {
 515   unsigned short NumOperands = TID->getNumOperands();
 516   if (!TID->isVariadic() && getNumOperands()-NumImplicitOps >= NumOperands)
 517     return true;  // Broken: we have all the operands of this instruction!
 518   return false;
 519 }
 520
 521 /// getNumExplicitOperands - Returns the number of non-implicit operands.
 522 ///
 523 unsigned MachineInstr::getNumExplicitOperands() const {
 524   unsigned NumOperands = TID->getNumOperands();
 525   if (!TID->isVariadic())
 526     return NumOperands;
 527
 528   for (unsigned e = getNumOperands(); NumOperands != e; ++NumOperands) {
 529     const MachineOperand &MO = getOperand(NumOperands);
 530     if (!MO.isRegister() || !MO.isImplicit())
 531       NumOperands++;
 532   }
 533   return NumOperands;
 534 }
 535
 536
 537 /// isLabel - Returns true if the MachineInstr represents a label.
 538 ///
 539 bool MachineInstr::isLabel() const {
 540   return getOpcode() == TargetInstrInfo::DBG_LABEL ||
 541          getOpcode() == TargetInstrInfo::EH_LABEL ||
 542          getOpcode() == TargetInstrInfo::GC_LABEL;
 543 }
 544
 545 /// isDebugLabel - Returns true if the MachineInstr represents a debug label.
 546 ///
 547 bool MachineInstr::isDebugLabel() const {
 548   return getOpcode() == TargetInstrInfo::DBG_LABEL;
 549 }
 550
 551 /// findRegisterUseOperandIdx() - Returns the MachineOperand that is a use of
 552 /// the specific register or -1 if it is not found. It further tightening
 553 /// the search criteria to a use that kills the register if isKill is true.
 554 int MachineInstr::findRegisterUseOperandIdx(unsigned Reg, bool isKill,
 555                                           const TargetRegisterInfo *TRI) const {
 556   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 557     const MachineOperand &MO = getOperand(i);
 558     if (!MO.isRegister() || !MO.isUse())
 559       continue;
 560     unsigned MOReg = MO.getReg();
 561     if (!MOReg)
 562       continue;
 563     if (MOReg == Reg ||
 564         (TRI &&
 565          TargetRegisterInfo::isPhysicalRegister(MOReg) &&
 566          TargetRegisterInfo::isPhysicalRegister(Reg) &&
 567          TRI->isSubRegister(MOReg, Reg)))
 568       if (!isKill || MO.isKill())
 569         return i;
 570   }
 571   return -1;
 572 }
 573
 574 /// findRegisterDefOperandIdx() - Returns the operand index that is a def of
 575 /// the specified register or -1 if it is not found. If isDead is true, defs
 576 /// that are not dead are skipped. If TargetRegisterInfo is non-null, then it
 577 /// also checks if there is a def of a super-register.
 578 int MachineInstr::findRegisterDefOperandIdx(unsigned Reg, bool isDead,
 579                                           const TargetRegisterInfo *TRI) const {
 580   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 581     const MachineOperand &MO = getOperand(i);
 582     if (!MO.isRegister() || !MO.isDef())
 583       continue;
 584     unsigned MOReg = MO.getReg();
 585     if (MOReg == Reg ||
 586         (TRI &&
 587          TargetRegisterInfo::isPhysicalRegister(MOReg) &&
 588          TargetRegisterInfo::isPhysicalRegister(Reg) &&
 589          TRI->isSubRegister(MOReg, Reg)))
 590       if (!isDead || MO.isDead())
 591         return i;
 592   }
 593   return -1;
 594 }
 595
 596 /// findFirstPredOperandIdx() - Find the index of the first operand in the
 597 /// operand list that is used to represent the predicate. It returns -1 if
 598 /// none is found.
 599 int MachineInstr::findFirstPredOperandIdx() const {
 600   const TargetInstrDesc &TID = getDesc();
 601   if (TID.isPredicable()) {
 602     for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
 603       if (TID.OpInfo[i].isPredicate())
 604         return i;
 605   }
 606
 607   return -1;
 608 }
 609
 610 /// isRegReDefinedByTwoAddr - Returns true if the Reg re-definition is due
 611 /// to two addr elimination.
 612 bool MachineInstr::isRegReDefinedByTwoAddr(unsigned Reg) const {
 613   const TargetInstrDesc &TID = getDesc();
 614   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 615     const MachineOperand &MO1 = getOperand(i);
 616     if (MO1.isRegister() && MO1.isDef() && MO1.getReg() == Reg) {
 617       for (unsigned j = i+1; j < e; ++j) {
 618         const MachineOperand &MO2 = getOperand(j);
 619         if (MO2.isRegister() && MO2.isUse() && MO2.getReg() == Reg &&
 620             TID.getOperandConstraint(j, TOI::TIED_TO) == (int)i)
 621           return true;
 622       }
 623     }
 624   }
 625   return false;
 626 }
 627
 628 /// copyKillDeadInfo - Copies kill / dead operand properties from MI.
 629 ///
 630 void MachineInstr::copyKillDeadInfo(const MachineInstr *MI) {
 631   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 632     const MachineOperand &MO = MI->getOperand(i);
 633     if (!MO.isRegister() || (!MO.isKill() && !MO.isDead()))
 634       continue;
 635     for (unsigned j = 0, ee = getNumOperands(); j != ee; ++j) {
 636       MachineOperand &MOp = getOperand(j);
 637       if (!MOp.isIdenticalTo(MO))
 638         continue;
 639       if (MO.isKill())
 640         MOp.setIsKill();
 641       else
 642         MOp.setIsDead();
 643       break;
 644     }
 645   }
 646 }
 647
 648 /// copyPredicates - Copies predicate operand(s) from MI.
 649 void MachineInstr::copyPredicates(const MachineInstr *MI) {
 650   const TargetInstrDesc &TID = MI->getDesc();
 651   if (!TID.isPredicable())
 652     return;
 653   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 654     if (TID.OpInfo[i].isPredicate()) {
 655       // Predicated operands must be last operands.
 656       addOperand(MI->getOperand(i));
 657     }
 658   }
 659 }
 660
 661 /// isSafeToMove - Return true if it is safe to move this instruction. If
 662 /// SawStore is set to true, it means that there is a store (or call) between
 663 /// the instruction's location and its intended destination.
 664 bool MachineInstr::isSafeToMove(const TargetInstrInfo *TII, bool &SawStore) {
 665   // Ignore stuff that we obviously can't move.
 666   if (TID->mayStore() || TID->isCall()) {
 667     SawStore = true;
 668     return false;
 669   }
 670   if (TID->isReturn() || TID->isBranch() || TID->hasUnmodeledSideEffects())
 671     return false;
 672
 673   // See if this instruction does a load.  If so, we have to guarantee that the
 674   // loaded value doesn't change between the load and the its intended
 675   // destination. The check for isInvariantLoad gives the targe the chance to
 676   // classify the load as always returning a constant, e.g. a constant pool
 677   // load.
 678   if (TID->mayLoad() && !TII->isInvariantLoad(this)) {
 679     // Otherwise, this is a real load.  If there is a store between the load and
 680     // end of block, we can't sink the load.
 681     //
 682     // FIXME: we can't do this transformation until we know that the load is
 683     // not volatile, and machineinstrs don't keep this info. :(
 684     //
 685     //if (SawStore)
 686     return false;
 687   }
 688   return true;
 689 }
 690
 691 void MachineInstr::dump() const {
 692   cerr << "  " << *this;
 693 }
 694
 695 void MachineInstr::print(std::ostream &OS, const TargetMachine *TM) const {
 696   // Specialize printing if op#0 is definition
 697   unsigned StartOp = 0;
 698   if (getNumOperands() && getOperand(0).isRegister() && getOperand(0).isDef()) {
 699     getOperand(0).print(OS, TM);
 700     OS << " = ";
 701     ++StartOp;   // Don't print this operand again!
 702   }
 703
 704   OS << getDesc().getName();
 705
 706   for (unsigned i = StartOp, e = getNumOperands(); i != e; ++i) {
 707     if (i != StartOp)
 708       OS << ",";
 709     OS << " ";
 710     getOperand(i).print(OS, TM);
 711   }
 712
 713   if (getNumMemOperands() > 0) {
 714     OS << ", Mem:";
 715     for (unsigned i = 0; i < getNumMemOperands(); i++) {
 716       const MachineMemOperand &MRO = getMemOperand(i);
 717       const Value *V = MRO.getValue();
 718
 719       assert((MRO.isLoad() || MRO.isStore()) &&
 720              "SV has to be a load, store or both.");
 721
 722       if (MRO.isVolatile())
 723         OS << "Volatile ";
 724
 725       if (MRO.isLoad())
 726         OS << "LD";
 727       if (MRO.isStore())
 728         OS << "ST";
 729
 730       OS << "(" << MRO.getSize() << "," << MRO.getAlignment() << ") [";
 731
 732       if (!V)
 733         OS << "<unknown>";
 734       else if (!V->getName().empty())
 735         OS << V->getName();
 736       else if (isa<PseudoSourceValue>(V))
 737         OS << *V;
 738       else
 739         OS << V;
 740
 741       OS << " + " << MRO.getOffset() << "]";
 742     }
 743   }
 744
 745   OS << "\n";
 746 }
 747
 748 bool MachineInstr::addRegisterKilled(unsigned IncomingReg,
 749                                      const TargetRegisterInfo *RegInfo,
 750                                      bool AddIfNotFound) {
 751   bool isPhysReg = TargetRegisterInfo::isPhysicalRegister(IncomingReg);
 752   bool hasAliases = isPhysReg && RegInfo->getAliasSet(IncomingReg);
 753   SmallVector<unsigned,4> DeadOps;
 754   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 755     MachineOperand &MO = getOperand(i);
 756     if (!MO.isRegister() || !MO.isUse())
 757       continue;
 758     unsigned Reg = MO.getReg();
 759     if (!Reg)
 760       continue;
 761
 762     if (Reg == IncomingReg) {
 763       MO.setIsKill();
 764       return true;
 765     }
 766     if (hasAliases && MO.isKill() &&
 767         TargetRegisterInfo::isPhysicalRegister(Reg)) {
 768       // A super-register kill already exists.
 769       if (RegInfo->isSuperRegister(IncomingReg, Reg))
 770         return true;
 771       if (RegInfo->isSubRegister(IncomingReg, Reg))
 772         DeadOps.push_back(i);
 773     }
 774   }
 775
 776   // Trim unneeded kill operands.
 777   while (!DeadOps.empty()) {
 778     unsigned OpIdx = DeadOps.back();
 779     if (getOperand(OpIdx).isImplicit())
 780       RemoveOperand(OpIdx);
 781     else
 782       getOperand(OpIdx).setIsKill(false);
 783     DeadOps.pop_back();
 784   }
 785
 786   // If not found, this means an alias of one of the operands is killed. Add a
 787   // new implicit operand if required.
 788   if (AddIfNotFound) {
 789     addOperand(MachineOperand::CreateReg(IncomingReg,
 790                                          false /*IsDef*/,
 791                                          true  /*IsImp*/,
 792                                          true  /*IsKill*/));
 793     return true;
 794   }
 795   return false;
 796 }
 797
 798 bool MachineInstr::addRegisterDead(unsigned IncomingReg,
 799                                    const TargetRegisterInfo *RegInfo,
 800                                    bool AddIfNotFound) {
 801   bool isPhysReg = TargetRegisterInfo::isPhysicalRegister(IncomingReg);
 802   bool hasAliases = isPhysReg && RegInfo->getAliasSet(IncomingReg);
 803   SmallVector<unsigned,4> DeadOps;
 804   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 805     MachineOperand &MO = getOperand(i);
 806     if (!MO.isRegister() || !MO.isDef())
 807       continue;
 808     unsigned Reg = MO.getReg();
 809     if (Reg == IncomingReg) {
 810       MO.setIsDead();
 811       return true;
 812     }
 813     if (hasAliases && MO.isDead() &&
 814         TargetRegisterInfo::isPhysicalRegister(Reg)) {
 815       // There exists a super-register that's marked dead.
 816       if (RegInfo->isSuperRegister(IncomingReg, Reg))
 817         return true;
 818       if (RegInfo->isSubRegister(IncomingReg, Reg))
 819         DeadOps.push_back(i);
 820     }
 821   }
 822
 823   // Trim unneeded dead operands.
 824   while (!DeadOps.empty()) {
 825     unsigned OpIdx = DeadOps.back();
 826     if (getOperand(OpIdx).isImplicit())
 827       RemoveOperand(OpIdx);
 828     else
 829       getOperand(OpIdx).setIsDead(false);
 830     DeadOps.pop_back();
 831   }
 832
 833   // If not found, this means an alias of one of the operand is dead. Add a
 834   // new implicit operand.
 835   if (AddIfNotFound) {
 836     addOperand(MachineOperand::CreateReg(IncomingReg, true/*IsDef*/,
 837                                          true/*IsImp*/,false/*IsKill*/,
 838                                          true/*IsDead*/));
 839     return true;
 840   }
 841   return false;
 842 }