lib/CodeGen/MachineSSAUpdater.cpp

   1 //===- MachineSSAUpdater.cpp - Unstructured SSA Update Tool ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the MachineSSAUpdater class. It's based on SSAUpdater
  11 // class in lib/Transforms/Utils.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/CodeGen/MachineSSAUpdater.h"
  16 #include "llvm/CodeGen/MachineInstr.h"
  17 #include "llvm/CodeGen/MachineInstrBuilder.h"
  18 #include "llvm/CodeGen/MachineRegisterInfo.h"
  19 #include "llvm/Target/TargetInstrInfo.h"
  20 #include "llvm/Target/TargetMachine.h"
  21 #include "llvm/Target/TargetRegisterInfo.h"
  22 #include "llvm/ADT/DenseMap.h"
  23 #include "llvm/ADT/SmallVector.h"
  24 #include "llvm/Support/AlignOf.h"
  25 #include "llvm/Support/Allocator.h"
  26 #include "llvm/Support/Debug.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Support/raw_ostream.h"
  29 #include "llvm/Transforms/Utils/SSAUpdaterImpl.h"
  30 using namespace llvm;
  31
  32 typedef DenseMap<MachineBasicBlock*, unsigned> AvailableValsTy;
  33 static AvailableValsTy &getAvailableVals(void *AV) {
  34   return *static_cast<AvailableValsTy*>(AV);
  35 }
  36
  37 MachineSSAUpdater::MachineSSAUpdater(MachineFunction &MF,
  38                                      SmallVectorImpl<MachineInstr*> *NewPHI)
  39   : AV(0), InsertedPHIs(NewPHI) {
  40   TII = MF.getTarget().getInstrInfo();
  41   MRI = &MF.getRegInfo();
  42 }
  43
  44 MachineSSAUpdater::~MachineSSAUpdater() {
  45   delete &getAvailableVals(AV);
  46 }
  47
  48 /// Initialize - Reset this object to get ready for a new set of SSA
  49 /// updates.  ProtoValue is the value used to name PHI nodes.
  50 void MachineSSAUpdater::Initialize(unsigned V) {
  51   if (AV == 0)
  52     AV = new AvailableValsTy();
  53   else
  54     getAvailableVals(AV).clear();
  55
  56   VR = V;
  57   VRC = MRI->getRegClass(VR);
  58 }
  59
  60 /// HasValueForBlock - Return true if the MachineSSAUpdater already has a value for
  61 /// the specified block.
  62 bool MachineSSAUpdater::HasValueForBlock(MachineBasicBlock *BB) const {
  63   return getAvailableVals(AV).count(BB);
  64 }
  65
  66 /// AddAvailableValue - Indicate that a rewritten value is available in the
  67 /// specified block with the specified value.
  68 void MachineSSAUpdater::AddAvailableValue(MachineBasicBlock *BB, unsigned V) {
  69   getAvailableVals(AV)[BB] = V;
  70 }
  71
  72 /// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is
  73 /// live at the end of the specified block.
  74 unsigned MachineSSAUpdater::GetValueAtEndOfBlock(MachineBasicBlock *BB) {
  75   return GetValueAtEndOfBlockInternal(BB);
  76 }
  77
  78 static
  79 unsigned LookForIdenticalPHI(MachineBasicBlock *BB,
  80           SmallVector<std::pair<MachineBasicBlock*, unsigned>, 8> &PredValues) {
  81   if (BB->empty())
  82     return 0;
  83
  84   MachineBasicBlock::iterator I = BB->begin();
  85   if (!I->isPHI())
  86     return 0;
  87
  88   AvailableValsTy AVals;
  89   for (unsigned i = 0, e = PredValues.size(); i != e; ++i)
  90     AVals[PredValues[i].first] = PredValues[i].second;
  91   while (I != BB->end() && I->isPHI()) {
  92     bool Same = true;
  93     for (unsigned i = 1, e = I->getNumOperands(); i != e; i += 2) {
  94       unsigned SrcReg = I->getOperand(i).getReg();
  95       MachineBasicBlock *SrcBB = I->getOperand(i+1).getMBB();
  96       if (AVals[SrcBB] != SrcReg) {
  97         Same = false;
  98         break;
  99       }
 100     }
 101     if (Same)
 102       return I->getOperand(0).getReg();
 103     ++I;
 104   }
 105   return 0;
 106 }
 107
 108 /// InsertNewDef - Insert an empty PHI or IMPLICIT_DEF instruction which define
 109 /// a value of the given register class at the start of the specified basic
 110 /// block. It returns the virtual register defined by the instruction.
 111 static
 112 MachineInstr *InsertNewDef(unsigned Opcode,
 113                            MachineBasicBlock *BB, MachineBasicBlock::iterator I,
 114                            const TargetRegisterClass *RC,
 115                            MachineRegisterInfo *MRI,
 116                            const TargetInstrInfo *TII) {
 117   unsigned NewVR = MRI->createVirtualRegister(RC);
 118   return BuildMI(*BB, I, DebugLoc(), TII->get(Opcode), NewVR);
 119 }
 120
 121 /// GetValueInMiddleOfBlock - Construct SSA form, materializing a value that
 122 /// is live in the middle of the specified block.
 123 ///
 124 /// GetValueInMiddleOfBlock is the same as GetValueAtEndOfBlock except in one
 125 /// important case: if there is a definition of the rewritten value after the
 126 /// 'use' in BB.  Consider code like this:
 127 ///
 128 ///      X1 = ...
 129 ///   SomeBB:
 130 ///      use(X)
 131 ///      X2 = ...
 132 ///      br Cond, SomeBB, OutBB
 133 ///
 134 /// In this case, there are two values (X1 and X2) added to the AvailableVals
 135 /// set by the client of the rewriter, and those values are both live out of
 136 /// their respective blocks.  However, the use of X happens in the *middle* of
 137 /// a block.  Because of this, we need to insert a new PHI node in SomeBB to
 138 /// merge the appropriate values, and this value isn't live out of the block.
 139 ///
 140 unsigned MachineSSAUpdater::GetValueInMiddleOfBlock(MachineBasicBlock *BB) {
 141   // If there is no definition of the renamed variable in this block, just use
 142   // GetValueAtEndOfBlock to do our work.
 143   if (!HasValueForBlock(BB))
 144     return GetValueAtEndOfBlockInternal(BB);
 145
 146   // If there are no predecessors, just return undef.
 147   if (BB->pred_empty()) {
 148     // Insert an implicit_def to represent an undef value.
 149     MachineInstr *NewDef = InsertNewDef(TargetOpcode::IMPLICIT_DEF,
 150                                         BB, BB->getFirstTerminator(),
 151                                         VRC, MRI, TII);
 152     return NewDef->getOperand(0).getReg();
 153   }
 154
 155   // Otherwise, we have the hard case.  Get the live-in values for each
 156   // predecessor.
 157   SmallVector<std::pair<MachineBasicBlock*, unsigned>, 8> PredValues;
 158   unsigned SingularValue = 0;
 159
 160   bool isFirstPred = true;
 161   for (MachineBasicBlock::pred_iterator PI = BB->pred_begin(),
 162          E = BB->pred_end(); PI != E; ++PI) {
 163     MachineBasicBlock *PredBB = *PI;
 164     unsigned PredVal = GetValueAtEndOfBlockInternal(PredBB);
 165     PredValues.push_back(std::make_pair(PredBB, PredVal));
 166
 167     // Compute SingularValue.
 168     if (isFirstPred) {
 169       SingularValue = PredVal;
 170       isFirstPred = false;
 171     } else if (PredVal != SingularValue)
 172       SingularValue = 0;
 173   }
 174
 175   // Otherwise, if all the merged values are the same, just use it.
 176   if (SingularValue != 0)
 177     return SingularValue;
 178
 179   // If an identical PHI is already in BB, just reuse it.
 180   unsigned DupPHI = LookForIdenticalPHI(BB, PredValues);
 181   if (DupPHI)
 182     return DupPHI;
 183
 184   // Otherwise, we do need a PHI: insert one now.
 185   MachineBasicBlock::iterator Loc = BB->empty() ? BB->end() : BB->begin();
 186   MachineInstr *InsertedPHI = InsertNewDef(TargetOpcode::PHI, BB,
 187                                            Loc, VRC, MRI, TII);
 188
 189   // Fill in all the predecessors of the PHI.
 190   MachineInstrBuilder MIB(InsertedPHI);
 191   for (unsigned i = 0, e = PredValues.size(); i != e; ++i)
 192     MIB.addReg(PredValues[i].second).addMBB(PredValues[i].first);
 193
 194   // See if the PHI node can be merged to a single value.  This can happen in
 195   // loop cases when we get a PHI of itself and one other value.
 196   if (unsigned ConstVal = InsertedPHI->isConstantValuePHI()) {
 197     InsertedPHI->eraseFromParent();
 198     return ConstVal;
 199   }
 200
 201   // If the client wants to know about all new instructions, tell it.
 202   if (InsertedPHIs) InsertedPHIs->push_back(InsertedPHI);
 203
 204   DEBUG(dbgs() << "  Inserted PHI: " << *InsertedPHI << "\n");
 205   return InsertedPHI->getOperand(0).getReg();
 206 }
 207
 208 static
 209 MachineBasicBlock *findCorrespondingPred(const MachineInstr *MI,
 210                                          MachineOperand *U) {
 211   for (unsigned i = 1, e = MI->getNumOperands(); i != e; i += 2) {
 212     if (&MI->getOperand(i) == U)
 213       return MI->getOperand(i+1).getMBB();
 214   }
 215
 216   llvm_unreachable("MachineOperand::getParent() failure?");
 217 }
 218
 219 /// RewriteUse - Rewrite a use of the symbolic value.  This handles PHI nodes,
 220 /// which use their value in the corresponding predecessor.
 221 void MachineSSAUpdater::RewriteUse(MachineOperand &U) {
 222   MachineInstr *UseMI = U.getParent();
 223   unsigned NewVR = 0;
 224   if (UseMI->isPHI()) {
 225     MachineBasicBlock *SourceBB = findCorrespondingPred(UseMI, &U);
 226     NewVR = GetValueAtEndOfBlockInternal(SourceBB);
 227   } else {
 228     NewVR = GetValueInMiddleOfBlock(UseMI->getParent());
 229   }
 230
 231   U.setReg(NewVR);
 232 }
 233
 234 void MachineSSAUpdater::ReplaceRegWith(unsigned OldReg, unsigned NewReg) {
 235   MRI->replaceRegWith(OldReg, NewReg);
 236
 237   AvailableValsTy &AvailableVals = getAvailableVals(AV);
 238   for (DenseMap<MachineBasicBlock*, unsigned>::iterator
 239          I = AvailableVals.begin(), E = AvailableVals.end(); I != E; ++I)
 240     if (I->second == OldReg)
 241       I->second = NewReg;
 242 }
 243
 244 /// MachinePHIiter - Iterator for PHI operands.  This is used for the
 245 /// PHI_iterator in the SSAUpdaterImpl template.
 246 namespace {
 247   class MachinePHIiter {
 248   private:
 249     MachineInstr *PHI;
 250     unsigned idx;
 251
 252   public:
 253     explicit MachinePHIiter(MachineInstr *P) // begin iterator
 254       : PHI(P), idx(1) {}
 255     MachinePHIiter(MachineInstr *P, bool) // end iterator
 256       : PHI(P), idx(PHI->getNumOperands()) {}
 257
 258     MachinePHIiter &operator++() { idx += 2; return *this; }
 259     bool operator==(const MachinePHIiter& x) const { return idx == x.idx; }
 260     bool operator!=(const MachinePHIiter& x) const { return !operator==(x); }
 261     unsigned getIncomingValue() { return PHI->getOperand(idx).getReg(); }
 262     MachineBasicBlock *getIncomingBlock() {
 263       return PHI->getOperand(idx+1).getMBB();
 264     }
 265   };
 266 }
 267
 268 /// SSAUpdaterTraits<MachineSSAUpdater> - Traits for the SSAUpdaterImpl
 269 /// template, specialized for MachineSSAUpdater.
 270 namespace llvm {
 271 template<>
 272 class SSAUpdaterTraits<MachineSSAUpdater> {
 273 public:
 274   typedef MachineBasicBlock BlkT;
 275   typedef unsigned ValT;
 276   typedef MachineInstr PhiT;
 277
 278   typedef MachineBasicBlock::succ_iterator BlkSucc_iterator;
 279   static BlkSucc_iterator BlkSucc_begin(BlkT *BB) { return BB->succ_begin(); }
 280   static BlkSucc_iterator BlkSucc_end(BlkT *BB) { return BB->succ_end(); }
 281
 282   typedef MachinePHIiter PHI_iterator;
 283   static inline PHI_iterator PHI_begin(PhiT *PHI) { return PHI_iterator(PHI); }
 284   static inline PHI_iterator PHI_end(PhiT *PHI) {
 285     return PHI_iterator(PHI, true);
 286   }
 287
 288   /// FindPredecessorBlocks - Put the predecessors of BB into the Preds
 289   /// vector.
 290   static void FindPredecessorBlocks(MachineBasicBlock *BB,
 291                                     SmallVectorImpl<MachineBasicBlock*> *Preds){
 292     for (MachineBasicBlock::pred_iterator PI = BB->pred_begin(),
 293            E = BB->pred_end(); PI != E; ++PI)
 294       Preds->push_back(*PI);
 295   }
 296
 297   /// GetUndefVal - Create an IMPLICIT_DEF instruction with a new register.
 298   /// Add it into the specified block and return the register.
 299   static unsigned GetUndefVal(MachineBasicBlock *BB,
 300                               MachineSSAUpdater *Updater) {
 301     // Insert an implicit_def to represent an undef value.
 302     MachineInstr *NewDef = InsertNewDef(TargetOpcode::IMPLICIT_DEF,
 303                                         BB, BB->getFirstTerminator(),
 304                                         Updater->VRC, Updater->MRI,
 305                                         Updater->TII);
 306     return NewDef->getOperand(0).getReg();
 307   }
 308
 309   /// CreateEmptyPHI - Create a PHI instruction that defines a new register.
 310   /// Add it into the specified block and return the register.
 311   static unsigned CreateEmptyPHI(MachineBasicBlock *BB, unsigned NumPreds,
 312                                  MachineSSAUpdater *Updater) {
 313     MachineBasicBlock::iterator Loc = BB->empty() ? BB->end() : BB->begin();
 314     MachineInstr *PHI = InsertNewDef(TargetOpcode::PHI, BB, Loc,
 315                                      Updater->VRC, Updater->MRI,
 316                                      Updater->TII);
 317     return PHI->getOperand(0).getReg();
 318   }
 319
 320   /// AddPHIOperand - Add the specified value as an operand of the PHI for
 321   /// the specified predecessor block.
 322   static void AddPHIOperand(MachineInstr *PHI, unsigned Val,
 323                             MachineBasicBlock *Pred) {
 324     PHI->addOperand(MachineOperand::CreateReg(Val, false));
 325     PHI->addOperand(MachineOperand::CreateMBB(Pred));
 326   }
 327
 328   /// InstrIsPHI - Check if an instruction is a PHI.
 329   ///
 330   static MachineInstr *InstrIsPHI(MachineInstr *I) {
 331     if (I && I->isPHI())
 332       return I;
 333     return 0;
 334   }
 335
 336   /// ValueIsPHI - Check if the instruction that defines the specified register
 337   /// is a PHI instruction.
 338   static MachineInstr *ValueIsPHI(unsigned Val, MachineSSAUpdater *Updater) {
 339     return InstrIsPHI(Updater->MRI->getVRegDef(Val));
 340   }
 341
 342   /// ValueIsNewPHI - Like ValueIsPHI but also check if the PHI has no source
 343   /// operands, i.e., it was just added.
 344   static MachineInstr *ValueIsNewPHI(unsigned Val, MachineSSAUpdater *Updater) {
 345     MachineInstr *PHI = ValueIsPHI(Val, Updater);
 346     if (PHI && PHI->getNumOperands() <= 1)
 347       return PHI;
 348     return 0;
 349   }
 350
 351   /// GetPHIValue - For the specified PHI instruction, return the register
 352   /// that it defines.
 353   static unsigned GetPHIValue(MachineInstr *PHI) {
 354     return PHI->getOperand(0).getReg();
 355   }
 356 };
 357
 358 } // End llvm namespace
 359
 360 /// GetValueAtEndOfBlockInternal - Check to see if AvailableVals has an entry
 361 /// for the specified BB and if so, return it.  If not, construct SSA form by
 362 /// first calculating the required placement of PHIs and then inserting new
 363 /// PHIs where needed.
 364 unsigned MachineSSAUpdater::GetValueAtEndOfBlockInternal(MachineBasicBlock *BB){
 365   AvailableValsTy &AvailableVals = getAvailableVals(AV);
 366   if (unsigned V = AvailableVals[BB])
 367     return V;
 368
 369   SSAUpdaterImpl<MachineSSAUpdater> Impl(this, &AvailableVals, InsertedPHIs);
 370   return Impl.GetValue(BB);
 371 }