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. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/CodeGen/MachineSSAUpdater.h" 15 #include "llvm/CodeGen/MachineInstr.h" 16 #include "llvm/ADT/DenseMap.h" 17 using namespace llvm; 18 19 typedef DenseMap<MachineBasicBlock*, unsigned > AvailableValsTy; 20 typedef std::vector<std::pair<MachineBasicBlock*, unsigned> > 21 IncomingPredInfoTy; 22 23 static AvailableValsTy &getAvailableVals(void *AV) { 24 return *static_cast<AvailableValsTy*>(AV); 25 } 26 27 static IncomingPredInfoTy &getIncomingPredInfo(void *IPI) { 28 return *static_cast<IncomingPredInfoTy*>(IPI); 29 } 30 31 32 MachineSSAUpdater::MachineSSAUpdater(SmallVectorImpl<MachineInstr*> *NewPHI) 33 : AV(0), IPI(0), InsertedPHIs(NewPHI) {} 34 35 MachineSSAUpdater::~MachineSSAUpdater() { 36 delete &getAvailableVals(AV); 37 delete &getIncomingPredInfo(IPI); 38 } 39 40 /// Initialize - Reset this object to get ready for a new set of SSA 41 /// updates. ProtoValue is the value used to name PHI nodes. 42 void MachineSSAUpdater::Initialize() { 43 if (AV == 0) 44 AV = new AvailableValsTy(); 45 else 46 getAvailableVals(AV).clear(); 47 48 if (IPI == 0) 49 IPI = new IncomingPredInfoTy(); 50 else 51 getIncomingPredInfo(IPI).clear(); 52 } 53 54 /// HasValueForBlock - Return true if the MachineSSAUpdater already has a value for 55 /// the specified block. 56 bool MachineSSAUpdater::HasValueForBlock(MachineBasicBlock *BB) const { 57 return getAvailableVals(AV).count(BB); 58 } 59 60 /// AddAvailableValue - Indicate that a rewritten value is available in the 61 /// specified block with the specified value. 62 void MachineSSAUpdater::AddAvailableValue(MachineBasicBlock *BB, unsigned V) { 63 getAvailableVals(AV)[BB] = V; 64 } 65 66 /// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is 67 /// live at the end of the specified block. 68 unsigned MachineSSAUpdater::GetValueAtEndOfBlock(MachineBasicBlock *BB) { 69 return GetValueAtEndOfBlockInternal(BB); 70 } 71 72 /// GetValueInMiddleOfBlock - Construct SSA form, materializing a value that 73 /// is live in the middle of the specified block. 74 /// 75 /// GetValueInMiddleOfBlock is the same as GetValueAtEndOfBlock except in one 76 /// important case: if there is a definition of the rewritten value after the 77 /// 'use' in BB. Consider code like this: 78 /// 79 /// X1 = ... 80 /// SomeBB: 81 /// use(X) 82 /// X2 = ... 83 /// br Cond, SomeBB, OutBB 84 /// 85 /// In this case, there are two values (X1 and X2) added to the AvailableVals 86 /// set by the client of the rewriter, and those values are both live out of 87 /// their respective blocks. However, the use of X happens in the *middle* of 88 /// a block. Because of this, we need to insert a new PHI node in SomeBB to 89 /// merge the appropriate values, and this value isn't live out of the block. 90 /// 91 unsigned MachineSSAUpdater::GetValueInMiddleOfBlock(MachineBasicBlock *BB) { 92 return 0; 93 } 94 95 /// RewriteUse - Rewrite a use of the symbolic value. This handles PHI nodes, 96 /// which use their value in the corresponding predecessor. 97 void MachineSSAUpdater::RewriteUse(unsigned &U) { 98 } 99 100 101 /// GetValueAtEndOfBlockInternal - Check to see if AvailableVals has an entry 102 /// for the specified BB and if so, return it. If not, construct SSA form by 103 /// walking predecessors inserting PHI nodes as needed until we get to a block 104 /// where the value is available. 105 /// 106 unsigned MachineSSAUpdater::GetValueAtEndOfBlockInternal(MachineBasicBlock *BB){ 107 return 0; 108 } 109