From 06366afa19f0caa3588043881043eaf2b2a16f65 Mon Sep 17 00:00:00 2001 From: Daniel Berlin Date: Sun, 21 May 2017 23:41:56 +0000 Subject: [PATCH] NewGVN: Cleanup some repeated code using some templated helpers git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@303520 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/NewGVN.cpp | 80 ++++++++++++++++---------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/lib/Transforms/Scalar/NewGVN.cpp b/lib/Transforms/Scalar/NewGVN.cpp index aa52ffdfd8e..3e45f8da496 100644 --- a/lib/Transforms/Scalar/NewGVN.cpp +++ b/lib/Transforms/Scalar/NewGVN.cpp @@ -486,7 +486,7 @@ class NewGVN { DenseMap> ExpressionToPhiOfOps; // Map from basic block to the temporary operations we created - DenseMap> PHIOfOpsPHIs; + DenseMap> PHIOfOpsPHIs; // Map from temporary operation to MemoryAccess. DenseMap TempToMemory; // Set of all temporary instructions we created. @@ -698,6 +698,10 @@ private: void handleNewInstruction(Instruction *){}; // Various instruction touch utilities + template + void for_each_found(Map &, const KeyType &, Func); + template + void touchAndErase(Map &, const KeyType &); void markUsersTouched(Value *); void markMemoryUsersTouched(const MemoryAccess *); void markMemoryDefTouched(const MemoryAccess *); @@ -1900,6 +1904,28 @@ NewGVN::performSymbolicEvaluation(Value *V, return E; } +// Look up a container in a map, and then call a function for each thing in the +// found container. +template +void NewGVN::for_each_found(Map &M, const KeyType &Key, Func F) { + const auto Result = M.find_as(Key); + if (Result != M.end()) + for (typename Map::mapped_type::value_type Mapped : Result->second) + F(Mapped); +} + +// Look up a container of values/instructions in a map, and touch all the +// instructions in the container. Then erase value from the map. +template +void NewGVN::touchAndErase(Map &M, const KeyType &Key) { + const auto Result = M.find_as(Key); + if (Result != M.end()) { + for (const typename Map::mapped_type::value_type Mapped : Result->second) + TouchedInstructions.set(InstrToDFSNum(Mapped)); + M.erase(Result); + } +} + void NewGVN::addAdditionalUsers(Value *To, Value *User) const { AdditionalUsers[To].insert(User); } @@ -1910,12 +1936,7 @@ void NewGVN::markUsersTouched(Value *V) { assert(isa(User) && "Use of value not within an instruction?"); TouchedInstructions.set(InstrToDFSNum(User)); } - const auto Result = AdditionalUsers.find(V); - if (Result != AdditionalUsers.end()) { - for (auto *User : Result->second) - TouchedInstructions.set(InstrToDFSNum(User)); - AdditionalUsers.erase(Result); - } + touchAndErase(AdditionalUsers, V); } void NewGVN::addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const { @@ -1932,12 +1953,7 @@ void NewGVN::markMemoryUsersTouched(const MemoryAccess *MA) { return; for (auto U : MA->users()) TouchedInstructions.set(MemoryToDFSNum(U)); - const auto Result = MemoryToUsers.find(MA); - if (Result != MemoryToUsers.end()) { - for (auto *User : Result->second) - TouchedInstructions.set(MemoryToDFSNum(User)); - MemoryToUsers.erase(Result); - } + touchAndErase(MemoryToUsers, MA); } // Add I to the set of users of a given predicate. @@ -1954,12 +1970,7 @@ void NewGVN::addPredicateUsers(const PredicateBase *PB, Instruction *I) const { // Touch all the predicates that depend on this instruction. void NewGVN::markPredicateUsersTouched(Instruction *I) { - const auto Result = PredicateToUsers.find(I); - if (Result != PredicateToUsers.end()) { - for (auto *User : Result->second) - TouchedInstructions.set(InstrToDFSNum(User)); - PredicateToUsers.erase(Result); - } + touchAndErase(PredicateToUsers, I); } // Mark users affected by a memory leader change. @@ -2162,13 +2173,9 @@ void NewGVN::moveValueToNewCongruenceClass(Instruction *I, const Expression *E, // For a given expression, mark the phi of ops instructions that could have // changed as a result. void NewGVN::markPhiOfOpsChanged(const HashedExpression &HE) { - auto PhiOfOpsSet = ExpressionToPhiOfOps.find_as(HE); - if (PhiOfOpsSet != ExpressionToPhiOfOps.end()) { - for (auto I : PhiOfOpsSet->second) - TouchedInstructions.set(InstrToDFSNum(I)); - ExpressionToPhiOfOps.erase(PhiOfOpsSet); - } + touchAndErase(ExpressionToPhiOfOps, HE); } + // Perform congruence finding on a given value numbering expression. void NewGVN::performCongruenceFinding(Instruction *I, const Expression *E) { // This is guaranteed to return something, since it will at least find @@ -2288,12 +2295,9 @@ void NewGVN::updateReachableEdge(BasicBlock *From, BasicBlock *To) { TouchedInstructions.set(InstrToDFSNum(&*BI)); ++BI; } - const auto PHIResult = PHIOfOpsPHIs.find(To); - if (PHIResult != PHIOfOpsPHIs.end()) { - const auto &PHIs = PHIResult->second; - for (auto I : PHIs) - TouchedInstructions.set(InstrToDFSNum(I)); - } + for_each_found(PHIOfOpsPHIs, To, [&](const PHINode *I) { + TouchedInstructions.set(InstrToDFSNum(I)); + }); } } } @@ -3517,7 +3521,8 @@ bool NewGVN::eliminateInstructions(Function &F) { // DFS numbers are updated, we compute some ourselves. DT->updateDFSNumbers(); - // Go through all of our phi nodes, and kill the arguments associated with unreachable edges. + // Go through all of our phi nodes, and kill the arguments associated with + // unreachable edges. auto ReplaceUnreachablePHIArgs = [&](PHINode &PHI, BasicBlock *BB) { for (auto &Operand : PHI.incoming_values()) if (!ReachableEdges.count({PHI.getIncomingBlock(Operand), BB})) { @@ -3544,14 +3549,9 @@ bool NewGVN::eliminateInstructions(Function &F) { auto &PHI = cast(*II); ReplaceUnreachablePHIArgs(PHI, BB); } - auto PHIResult = PHIOfOpsPHIs.find(BB); - if (PHIResult != PHIOfOpsPHIs.end()) { - auto &PHIs = PHIResult->second; - for (auto I : PHIs) { - auto *PHI = dyn_cast(I); - ReplaceUnreachablePHIArgs(*PHI, BB); - } - } + for_each_found(PHIOfOpsPHIs, BB, [&](PHINode *PHI) { + ReplaceUnreachablePHIArgs(*PHI, BB); + }); } // Map to store the use counts -- 2.40.0