-/// isPHITranslatable - Return true if the specified computation is derived from
-/// a PHI node in the current block and if it is simple enough for us to handle.
-static bool isPHITranslatable(Instruction *Inst) {
- if (isa<PHINode>(Inst))
- return true;
-
- // We can handle bitcast of a PHI, but the PHI needs to be in the same block
- // as the bitcast.
- if (BitCastInst *BC = dyn_cast<BitCastInst>(Inst))
- if (PHINode *PN = dyn_cast<PHINode>(BC->getOperand(0)))
- if (PN->getParent() == BC->getParent())
- return true;
-
- // We can translate a GEP that uses a PHI in the current block for at least
- // one of its operands.
- if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
- for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
- if (PHINode *PN = dyn_cast<PHINode>(GEP->getOperand(i)))
- if (PN->getParent() == GEP->getParent())
- return true;
- }
-
- // cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
- // if (isa<BitCastInst>(PtrInst) || isa<GetElementPtrInst>(PtrInst))
- // cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
-
- return false;
-}
-
-/// PHITranslateForPred - Given a computation that satisfied the
-/// isPHITranslatable predicate, see if we can translate the computation into
-/// the specified predecessor block. If so, return that value.
-Value *MemoryDependenceAnalysis::
-PHITranslatePointer(Value *InVal, BasicBlock *CurBB, BasicBlock *Pred,
- const TargetData *TD) const {
- // If the input value is not an instruction, or if it is not defined in CurBB,
- // then we don't need to phi translate it.
- Instruction *Inst = dyn_cast<Instruction>(InVal);
- if (Inst == 0 || Inst->getParent() != CurBB)
- return InVal;
-
- if (PHINode *PN = dyn_cast<PHINode>(Inst))
- return PN->getIncomingValueForBlock(Pred);
-
- // Handle bitcast of PHI.
- if (BitCastInst *BC = dyn_cast<BitCastInst>(Inst)) {
- PHINode *BCPN = cast<PHINode>(BC->getOperand(0));
- Value *PHIIn = BCPN->getIncomingValueForBlock(Pred);
-
- // Constants are trivial to phi translate.
- if (Constant *C = dyn_cast<Constant>(PHIIn))
- return ConstantExpr::getBitCast(C, BC->getType());
-
- // Otherwise we have to see if a bitcasted version of the incoming pointer
- // is available. If so, we can use it, otherwise we have to fail.
- for (Value::use_iterator UI = PHIIn->use_begin(), E = PHIIn->use_end();
- UI != E; ++UI) {
- if (BitCastInst *BCI = dyn_cast<BitCastInst>(*UI))
- if (BCI->getType() == BC->getType())
- return BCI;
- }
- return 0;
- }
-
- // Handle getelementptr with at least one PHI operand.
- if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
- SmallVector<Value*, 8> GEPOps;
- BasicBlock *CurBB = GEP->getParent();
- for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) {
- Value *GEPOp = GEP->getOperand(i);
- // No PHI translation is needed of operands whose values are live in to
- // the predecessor block.
- if (!isa<Instruction>(GEPOp) ||
- cast<Instruction>(GEPOp)->getParent() != CurBB) {
- GEPOps.push_back(GEPOp);
- continue;
- }
-
- // If the operand is a phi node, do phi translation.
- if (PHINode *PN = dyn_cast<PHINode>(GEPOp)) {
- GEPOps.push_back(PN->getIncomingValueForBlock(Pred));
- continue;
- }
-
- // Otherwise, we can't PHI translate this random value defined in this
- // block.
- return 0;
- }
-
- // Simplify the GEP to handle 'gep x, 0' -> x etc.
- if (Value *V = SimplifyGEPInst(&GEPOps[0], GEPOps.size(), TD))
- return V;
-
-
- // Scan to see if we have this GEP available.
- Value *APHIOp = GEPOps[0];
- for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end();
- UI != E; ++UI) {
- if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(*UI))
- if (GEPI->getType() == GEP->getType() &&
- GEPI->getNumOperands() == GEPOps.size() &&
- GEPI->getParent()->getParent() == CurBB->getParent()) {
- bool Mismatch = false;
- for (unsigned i = 0, e = GEPOps.size(); i != e; ++i)
- if (GEPI->getOperand(i) != GEPOps[i]) {
- Mismatch = true;
- break;
- }
- if (!Mismatch)
- return GEPI;
- }
- }
- return 0;
- }
-
- return 0;
-}
-
-/// InsertPHITranslatedPointer - Insert a computation of the PHI translated
-/// version of 'V' for the edge PredBB->CurBB into the end of the PredBB
-/// block.
-///
-/// This is only called when PHITranslatePointer returns a value that doesn't
-/// dominate the block, so we don't need to handle the trivial cases here.
-Value *MemoryDependenceAnalysis::
-InsertPHITranslatedPointer(Value *InVal, BasicBlock *CurBB,
- BasicBlock *PredBB, const TargetData *TD) const {
- // If the input value isn't an instruction in CurBB, it doesn't need phi
- // translation.
- Instruction *Inst = cast<Instruction>(InVal);
- assert(Inst->getParent() == CurBB && "Doesn't need phi trans");
-
- // Handle bitcast of PHI.
- if (BitCastInst *BC = dyn_cast<BitCastInst>(Inst)) {
- PHINode *BCPN = cast<PHINode>(BC->getOperand(0));
- Value *PHIIn = BCPN->getIncomingValueForBlock(PredBB);
-
- // Otherwise insert a bitcast at the end of PredBB.
- return new BitCastInst(PHIIn, InVal->getType(),
- InVal->getName()+".phi.trans.insert",
- PredBB->getTerminator());
- }
-
- // Handle getelementptr with at least one PHI operand.
- if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
- SmallVector<Value*, 8> GEPOps;
- Value *APHIOp = 0;
- BasicBlock *CurBB = GEP->getParent();
- for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) {
- GEPOps.push_back(GEP->getOperand(i)->DoPHITranslation(CurBB, PredBB));
- if (!isa<Constant>(GEPOps.back()))
- APHIOp = GEPOps.back();
- }
-
- GetElementPtrInst *Result =
- GetElementPtrInst::Create(GEPOps[0], GEPOps.begin()+1, GEPOps.end(),
- InVal->getName()+".phi.trans.insert",
- PredBB->getTerminator());
- Result->setIsInBounds(GEP->isInBounds());
- return Result;
- }
-
- return 0;
-}
-