From 032dafd64ae1a9da38db41dde32de8066e8d518f Mon Sep 17 00:00:00 2001 From: Juergen Ributzka Date: Fri, 21 Mar 2014 06:04:33 +0000 Subject: [PATCH] [Constant Hoisting] Fix capitalization of function names. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@204432 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/ConstantHoisting.cpp | 67 +++++++++++----------- 1 file changed, 34 insertions(+), 33 deletions(-) diff --git a/lib/Transforms/Scalar/ConstantHoisting.cpp b/lib/Transforms/Scalar/ConstantHoisting.cpp index 452f0797d84..6e46e8b6529 100644 --- a/lib/Transforms/Scalar/ConstantHoisting.cpp +++ b/lib/Transforms/Scalar/ConstantHoisting.cpp @@ -102,19 +102,19 @@ public: } private: - void CollectConstant(User *U, unsigned Opcode, Intrinsic::ID IID, - ConstantInt *C); - void CollectConstants(Instruction *I); - void CollectConstants(Function &F); - void FindAndMakeBaseConstant(ConstCandVecType::iterator S, + void collectConstantCandidates(User *U, unsigned Opcode, Intrinsic::ID IID, + ConstantInt *C); + void collectConstantCandidates(Instruction *I); + void collectConstantCandidates(Function &F); + void findAndMakeBaseConstant(ConstCandVecType::iterator S, ConstCandVecType::iterator E); - void FindBaseConstants(); - Instruction *FindConstantInsertionPoint(Function &F, + void findBaseConstants(); + Instruction *findConstantInsertionPoint(Function &F, const ConstantInfo &CI) const; - void EmitBaseConstants(Function &F, User *U, Instruction *Base, + void emitBaseConstants(Function &F, User *U, Instruction *Base, Constant *Offset, ConstantInt *OriginalConstant); - bool EmitBaseConstants(Function &F); - bool OptimizeConstants(Function &F); + bool emitBaseConstants(Function &F); + bool optimizeConstants(Function &F); }; } @@ -138,11 +138,12 @@ bool ConstantHoisting::runOnFunction(Function &F) { DT = &getAnalysis().getDomTree(); TTI = &getAnalysis(); - return OptimizeConstants(F); + return optimizeConstants(F); } -void ConstantHoisting::CollectConstant(User * U, unsigned Opcode, - Intrinsic::ID IID, ConstantInt *C) { +void ConstantHoisting::collectConstantCandidates(User * U, unsigned Opcode, + Intrinsic::ID IID, + ConstantInt *C) { unsigned Cost; if (Opcode) Cost = TTI->getIntImmCost(Opcode, C->getValue(), C->getType()); @@ -168,7 +169,7 @@ void ConstantHoisting::CollectConstant(User * U, unsigned Opcode, /// \brief Scan the instruction or constant expression for expensive integer /// constants and record them in the constant map. -void ConstantHoisting::CollectConstants(Instruction *I) { +void ConstantHoisting::collectConstantCandidates(Instruction *I) { unsigned Opcode = 0; Intrinsic::ID IID = Intrinsic::not_intrinsic; if (IntrinsicInst *II = dyn_cast(I)) @@ -179,7 +180,7 @@ void ConstantHoisting::CollectConstants(Instruction *I) { // Scan all operands. for (User::op_iterator O = I->op_begin(), E = I->op_end(); O != E; ++O) { if (ConstantInt *C = dyn_cast(O)) { - CollectConstant(I, Opcode, IID, C); + collectConstantCandidates(I, Opcode, IID, C); continue; } if (ConstantExpr *CE = dyn_cast(O)) { @@ -189,7 +190,7 @@ void ConstantHoisting::CollectConstants(Instruction *I) { if (ConstantInt *C = dyn_cast(CE->getOperand(0))) { // Ignore the cast expression and use the opcode of the instruction. - CollectConstant(CE, Opcode, IID, C); + collectConstantCandidates(CE, Opcode, IID, C); continue; } } @@ -198,15 +199,15 @@ void ConstantHoisting::CollectConstants(Instruction *I) { /// \brief Collect all integer constants in the function that cannot be folded /// into an instruction itself. -void ConstantHoisting::CollectConstants(Function &F) { +void ConstantHoisting::collectConstantCandidates(Function &F) { for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) - CollectConstants(I); + collectConstantCandidates(I); } /// \brief Find the base constant within the given range and rebase all other /// constants with respect to the base constant. -void ConstantHoisting::FindAndMakeBaseConstant(ConstCandVecType::iterator S, +void ConstantHoisting::findAndMakeBaseConstant(ConstCandVecType::iterator S, ConstCandVecType::iterator E) { ConstCandVecType::iterator MaxCostItr = S; unsigned NumUses = 0; @@ -238,7 +239,7 @@ void ConstantHoisting::FindAndMakeBaseConstant(ConstCandVecType::iterator S, /// \brief Finds and combines constants that can be easily rematerialized with /// an add from a common base constant. -void ConstantHoisting::FindBaseConstants() { +void ConstantHoisting::findBaseConstants() { // Sort the constants by value and type. This invalidates the mapping. std::sort(ConstCandVec.begin(), ConstCandVec.end(), [](const ConstantCandidate &LHS, const ConstantCandidate &RHS) { @@ -262,17 +263,17 @@ void ConstantHoisting::FindBaseConstants() { } // We either have now a different constant type or the constant is not in // range of an add with immediate anymore. - FindAndMakeBaseConstant(MinValItr, I); + findAndMakeBaseConstant(MinValItr, I); // Start a new base constant search. MinValItr = I; } // Finalize the last base constant search. - FindAndMakeBaseConstant(MinValItr, ConstCandVec.end()); + findAndMakeBaseConstant(MinValItr, ConstCandVec.end()); } /// \brief Records the basic block of the instruction or all basic blocks of the /// users of the constant expression. -static void CollectBasicBlocks(SmallPtrSet &BBs, Function &F, +static void collectBasicBlocks(SmallPtrSet &BBs, Function &F, User *U) { if (Instruction *I = dyn_cast(U)) BBs.insert(I->getParent()); @@ -303,7 +304,7 @@ static Instruction *getMatInsertPt(Instruction *I, const DominatorTree *DT) { /// \brief Find an insertion point that dominates all uses. Instruction *ConstantHoisting:: -FindConstantInsertionPoint(Function &F, const ConstantInfo &CI) const { +findConstantInsertionPoint(Function &F, const ConstantInfo &CI) const { BasicBlock *Entry = &F.getEntryBlock(); // Collect all basic blocks. @@ -313,7 +314,7 @@ FindConstantInsertionPoint(Function &F, const ConstantInfo &CI) const { RCI != RCE; ++RCI) for (SmallVectorImpl::const_iterator U = RCI->Uses.begin(), E = RCI->Uses.end(); U != E; ++U) - CollectBasicBlocks(BBs, F, *U); + collectBasicBlocks(BBs, F, *U); if (BBs.count(Entry)) return getMatInsertPt(&Entry->front(), DT); @@ -336,7 +337,7 @@ FindConstantInsertionPoint(Function &F, const ConstantInfo &CI) const { /// \brief Emit materialization code for all rebased constants and update their /// users. -void ConstantHoisting::EmitBaseConstants(Function &F, User *U, +void ConstantHoisting::emitBaseConstants(Function &F, User *U, Instruction *Base, Constant *Offset, ConstantInt *OriginalConstant) { if (Instruction *I = dyn_cast(U)) { @@ -409,12 +410,12 @@ void ConstantHoisting::EmitBaseConstants(Function &F, User *U, /// \brief Hoist and hide the base constant behind a bitcast and emit /// materialization code for derived constants. -bool ConstantHoisting::EmitBaseConstants(Function &F) { +bool ConstantHoisting::emitBaseConstants(Function &F) { bool MadeChange = false; SmallVectorImpl::iterator CI, CE; for (CI = Constants.begin(), CE = Constants.end(); CI != CE; ++CI) { // Hoist and hide the base constant behind a bitcast. - Instruction *IP = FindConstantInsertionPoint(F, *CI); + Instruction *IP = findConstantInsertionPoint(F, *CI); IntegerType *Ty = CI->BaseConstant->getType(); Instruction *Base = new BitCastInst(CI->BaseConstant, Ty, "const", IP); DEBUG(dbgs() << "Hoist constant (" << *CI->BaseConstant << ") to BB " @@ -428,7 +429,7 @@ bool ConstantHoisting::EmitBaseConstants(Function &F) { NumConstantsRebased++; for (SmallVectorImpl::iterator U = RCI->Uses.begin(), E = RCI->Uses.end(); U != E; ++U) - EmitBaseConstants(F, *U, Base, RCI->Offset, RCI->OriginalConstant); + emitBaseConstants(F, *U, Base, RCI->Offset, RCI->OriginalConstant); } // Use the same debug location as the last user of the constant. @@ -445,11 +446,11 @@ bool ConstantHoisting::EmitBaseConstants(Function &F) { } /// \brief Optimize expensive integer constants in the given function. -bool ConstantHoisting::OptimizeConstants(Function &F) { +bool ConstantHoisting::optimizeConstants(Function &F) { bool MadeChange = false; // Collect all constant candidates. - CollectConstants(F); + collectConstantCandidates(F); // There are no constant candidates to worry about. if (ConstCandVec.empty()) @@ -457,11 +458,11 @@ bool ConstantHoisting::OptimizeConstants(Function &F) { // Combine constants that can be easily materialized with an add from a common // base constant. - FindBaseConstants(); + findBaseConstants(); // Finally hoist the base constant and emit materializating code for dependent // constants. - MadeChange |= EmitBaseConstants(F); + MadeChange |= emitBaseConstants(F); ConstCandMap.clear(); ConstCandVec.clear();