CbC/CbC_llvm: lib/Analysis/DependenceAnalysis.cpp comparison

comparison lib/Analysis/DependenceAnalysis.cpp @ 83:60c9769439b8 LLVM3.7

LLVM 3.7

author	Tatsuki IHA <e125716@ie.u-ryukyu.ac.jp>
date	Wed, 18 Feb 2015 14:55:36 +0900
parents	54457678186b
children	afa8332a0e37

comparison

equal deleted inserted replaced

-:af83660cff7b
+:60c9769439b8
 //===----------------------------------------------------------------------===//
 // basics
 INITIALIZE_PASS_BEGIN(DependenceAnalysis, "da",
 "Dependence Analysis", true, true)
-INITIALIZE_PASS_DEPENDENCY(LoopInfo)
+INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
 INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
 INITIALIZE_PASS_END(DependenceAnalysis, "da",
 "Dependence Analysis", true, true)
 bool DependenceAnalysis::runOnFunction(Function &F) {
 this->F = &F;
 AA = &getAnalysis<AliasAnalysis>();
 SE = &getAnalysis<ScalarEvolution>();
-LI = &getAnalysis<LoopInfo>();
+LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 return false;
 }
 void DependenceAnalysis::releaseMemory() {
 void DependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
 AU.setPreservesAll();
 AU.addRequiredTransitive<AliasAnalysis>();
 AU.addRequiredTransitive<ScalarEvolution>();
-AU.addRequiredTransitive<LoopInfo>();
+AU.addRequiredTransitive<LoopInfoWrapperPass>();
 }
 // Used to test the dependence analyzer.
 // Looks through the function, noting loads and stores.
 Loops.set(Level);
 LoopNest = LoopNest->getParentLoop();
 }
 }
+void DependenceAnalysis::unifySubscriptType(Subscript *Pair) {
+const SCEV *Src = Pair->Src;
+const SCEV *Dst = Pair->Dst;
+IntegerType *SrcTy = dyn_cast<IntegerType>(Src->getType());
+IntegerType *DstTy = dyn_cast<IntegerType>(Dst->getType());
+if (SrcTy == nullptr || DstTy == nullptr) {
+assert(SrcTy == DstTy && "This function only unify integer types and "
+"expect Src and Dst share the same type "
+"otherwise.");
+return;
+}
+if (SrcTy->getBitWidth() > DstTy->getBitWidth()) {
+// Sign-extend Dst to typeof(Src) if typeof(Src) is wider than typeof(Dst).
+Pair->Dst = SE->getSignExtendExpr(Dst, SrcTy);
+} else if (SrcTy->getBitWidth() < DstTy->getBitWidth()) {
+// Sign-extend Src to typeof(Dst) if typeof(Dst) is wider than typeof(Src).
+Pair->Src = SE->getSignExtendExpr(Src, DstTy);
+}
+}
 // removeMatchingExtensions - Examines a subscript pair.
 // If the source and destination are identically sign (or zero)
 // extended, it strips off the extension in an effect to simplify
 // the actual analysis.
 const SCEV *Dst = Pair->Dst;
 if ((isa<SCEVZeroExtendExpr>(Src) && isa<SCEVZeroExtendExpr>(Dst)) ||
 (isa<SCEVSignExtendExpr>(Src) && isa<SCEVSignExtendExpr>(Dst))) {
 const SCEVCastExpr *SrcCast = cast<SCEVCastExpr>(Src);
 const SCEVCastExpr *DstCast = cast<SCEVCastExpr>(Dst);
-if (SrcCast->getType() == DstCast->getType()) {
+const SCEV *SrcCastOp = SrcCast->getOperand();
-Pair->Src = SrcCast->getOperand();
+const SCEV *DstCastOp = DstCast->getOperand();
-Pair->Dst = DstCast->getOperand();
+if (SrcCastOp->getType() == DstCastOp->getType()) {
+Pair->Src = SrcCastOp;
+Pair->Dst = DstCastOp;
 }
 }
 }
 Sum,
 AddRec->getLoop(),
 AddRec->getNoWrapFlags());
 }
 if (SE->isLoopInvariant(AddRec, TargetLoop))
-return SE->getAddRecExpr(AddRec,
+return SE->getAddRecExpr(AddRec, Value, TargetLoop, SCEV::FlagAnyWrap);
-			     Value,
+return SE->getAddRecExpr(
-			     TargetLoop,
+addToCoefficient(AddRec->getStart(), TargetLoop, Value),
-			     SCEV::FlagAnyWrap);
+AddRec->getStepRecurrence(*SE), AddRec->getLoop(),
-return SE->getAddRecExpr(addToCoefficient(AddRec->getStart(),
+AddRec->getNoWrapFlags());
-TargetLoop, Value),
-AddRec->getStepRecurrence(*SE),
-AddRec->getLoop(),
-AddRec->getNoWrapFlags());
 }
 // Review the constraints, looking for opportunities
 // to simplify a subscript pair (Src and Dst).
 /// this function flattens the nested recurrences into separate recurrences
 /// for each loop level.
 bool DependenceAnalysis::tryDelinearize(const SCEV *SrcSCEV,
 const SCEV *DstSCEV,
 SmallVectorImpl<Subscript> &Pair,
-const SCEV *ElementSize) const {
+const SCEV *ElementSize) {
 const SCEVUnknown *SrcBase =
 dyn_cast<SCEVUnknown>(SE->getPointerBase(SrcSCEV));
 const SCEVUnknown *DstBase =
 dyn_cast<SCEVUnknown>(SE->getPointerBase(DstSCEV));
 // has found, and then initialize the pairs following the delinearization.
 Pair.resize(size);
 for (int i = 0; i < size; ++i) {
 Pair[i].Src = SrcSubscripts[i];
 Pair[i].Dst = DstSubscripts[i];
+unifySubscriptType(&Pair[i]);
 // FIXME: we should record the bounds SrcSizes[i] and DstSizes[i] that the
 // delinearization has found, and add these constraints to the dependence
 // check to avoid memory accesses overflow from one dimension into another.
 // This is related to the problem of determining the existence of data
 DstIdx = DstGEP->idx_begin();
 SrcIdx != SrcEnd;
 ++SrcIdx, ++DstIdx, ++P) {
 Pair[P].Src = SE->getSCEV(*SrcIdx);
 Pair[P].Dst = SE->getSCEV(*DstIdx);
+unifySubscriptType(&Pair[P]);
 }
 }
 else {
 DEBUG(dbgs() << "    ignoring GEPs\n");
 const SCEV *SrcSCEV = SE->getSCEV(SrcPtr);

Mercurial > hg > CbC > CbC_llvm

comparison lib/Analysis/DependenceAnalysis.cpp @ 83:60c9769439b8 LLVM3.7