From 7372a7d5f87bf1ff65d07f25bae037ddc4df994d Mon Sep 17 00:00:00 2001 From: Sebastian Pop Date: Tue, 20 Nov 2012 22:28:04 +0000 Subject: [PATCH] removes a few "const" qualifiers so that I can (someday) call SE->getSCEV without complaint. No semantic change intended. Patch from Preston Briggs . git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@168391 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/DependenceAnalysis.h | 18 +++++++-------- lib/Analysis/DependenceAnalysis.cpp | 26 +++++++++++----------- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/include/llvm/Analysis/DependenceAnalysis.h b/include/llvm/Analysis/DependenceAnalysis.h index b4327eeb0b1..39f57208ee4 100644 --- a/include/llvm/Analysis/DependenceAnalysis.h +++ b/include/llvm/Analysis/DependenceAnalysis.h @@ -53,8 +53,8 @@ namespace llvm { /// input dependences are unordered. class Dependence { public: - Dependence(const Instruction *Source, - const Instruction *Destination) : + Dependence(Instruction *Source, + Instruction *Destination) : Src(Source), Dst(Destination) {} virtual ~Dependence() {} @@ -82,11 +82,11 @@ namespace llvm { /// getSrc - Returns the source instruction for this dependence. /// - const Instruction *getSrc() const { return Src; } + Instruction *getSrc() const { return Src; } /// getDst - Returns the destination instruction for this dependence. /// - const Instruction *getDst() const { return Dst; } + Instruction *getDst() const { return Dst; } /// isInput - Returns true if this is an input dependence. /// @@ -158,7 +158,7 @@ namespace llvm { /// void dump(raw_ostream &OS) const; private: - const Instruction *Src, *Dst; + Instruction *Src, *Dst; friend class DependenceAnalysis; }; @@ -173,8 +173,8 @@ namespace llvm { /// input dependences are unordered. class FullDependence : public Dependence { public: - FullDependence(const Instruction *Src, - const Instruction *Dst, + FullDependence(Instruction *Src, + Instruction *Dst, bool LoopIndependent, unsigned Levels); ~FullDependence() { @@ -243,8 +243,8 @@ namespace llvm { /// The flag PossiblyLoopIndependent should be set by the caller /// if it appears that control flow can reach from Src to Dst /// without traversing a loop back edge. - Dependence *depends(const Instruction *Src, - const Instruction *Dst, + Dependence *depends(Instruction *Src, + Instruction *Dst, bool PossiblyLoopIndependent); /// getSplitIteration - Give a dependence that's splitable at some diff --git a/lib/Analysis/DependenceAnalysis.cpp b/lib/Analysis/DependenceAnalysis.cpp index 29a6f96cb23..6291e995847 100644 --- a/lib/Analysis/DependenceAnalysis.cpp +++ b/lib/Analysis/DependenceAnalysis.cpp @@ -221,8 +221,8 @@ bool Dependence::isScalar(unsigned level) const { //===----------------------------------------------------------------------===// // FullDependence methods -FullDependence::FullDependence(const Instruction *Source, - const Instruction *Destination, +FullDependence::FullDependence(Instruction *Source, + Instruction *Destination, bool PossiblyLoopIndependent, unsigned CommonLevels) : Dependence(Source, Destination), @@ -649,10 +649,10 @@ bool isLoadOrStore(const Instruction *I) { static -const Value *getPointerOperand(const Instruction *I) { - if (const LoadInst *LI = dyn_cast(I)) +Value *getPointerOperand(Instruction *I) { + if (LoadInst *LI = dyn_cast(I)) return LI->getPointerOperand(); - if (const StoreInst *SI = dyn_cast(I)) + if (StoreInst *SI = dyn_cast(I)) return SI->getPointerOperand(); llvm_unreachable("Value is not load or store instruction"); return 0; @@ -3195,8 +3195,8 @@ static void dumpSmallBitVector(SmallBitVector &BV) { // PLDI 1991 // // Care is required to keep the code below up to date w.r.t. this routine. -Dependence *DependenceAnalysis::depends(const Instruction *Src, - const Instruction *Dst, +Dependence *DependenceAnalysis::depends(Instruction *Src, + Instruction *Dst, bool PossiblyLoopIndependent) { if ((!Src->mayReadFromMemory() && !Src->mayWriteToMemory()) || (!Dst->mayReadFromMemory() && !Dst->mayWriteToMemory())) @@ -3207,8 +3207,8 @@ Dependence *DependenceAnalysis::depends(const Instruction *Src, // can only analyze simple loads and stores, i.e., no calls, invokes, etc. return new Dependence(Src, Dst); - const Value *SrcPtr = getPointerOperand(Src); - const Value *DstPtr = getPointerOperand(Dst); + Value *SrcPtr = getPointerOperand(Src); + Value *DstPtr = getPointerOperand(Dst); switch (underlyingObjectsAlias(AA, DstPtr, SrcPtr)) { case AliasAnalysis::MayAlias: @@ -3222,8 +3222,8 @@ Dependence *DependenceAnalysis::depends(const Instruction *Src, break; // The underlying objects alias; test accesses for dependence. } - const GEPOperator *SrcGEP = dyn_cast(SrcPtr); - const GEPOperator *DstGEP = dyn_cast(DstPtr); + GEPOperator *SrcGEP = dyn_cast(SrcPtr); + GEPOperator *DstGEP = dyn_cast(DstPtr); if (!SrcGEP || !DstGEP) return new Dependence(Src, Dst); // missing GEP, assume dependence @@ -3605,8 +3605,8 @@ const SCEV *DependenceAnalysis::getSplitIteration(const Dependence *Dep, assert(Dep && "expected a pointer to a Dependence"); assert(Dep->isSplitable(SplitLevel) && "Dep should be splitable at SplitLevel"); - const Instruction *Src = Dep->getSrc(); - const Instruction *Dst = Dep->getDst(); + Instruction *Src = Dep->getSrc(); + Instruction *Dst = Dep->getDst(); assert(Src->mayReadFromMemory() || Src->mayWriteToMemory()); assert(Dst->mayReadFromMemory() || Dst->mayWriteToMemory()); assert(isLoadOrStore(Src)); -- 2.34.1