6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-15 20:29:48 +00:00
Code Issues Projects Releases Wiki Activity

remove function names from comments; NFC

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230391 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2015-02-24 22:43:06 +00:00
parent 41cda40157
commit 7b59672e39
1 changed files with 38 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
lib/Transforms/Scalar/GVN.cpp
View File

@ -458,7 +458,7 @@ uint32_t ValueTable::lookup_or_add(Value *V) {
return e; return e;
} }
/// lookup - Returns the value number of the specified value. Fails if /// Returns the value number of the specified value. Fails if
/// the value has not yet been numbered. /// the value has not yet been numbered.
uint32_t ValueTable::lookup(Value *V) const { uint32_t ValueTable::lookup(Value *V) const {
DenseMap<Value*, uint32_t>::const_iterator VI = valueNumbering.find(V); DenseMap<Value*, uint32_t>::const_iterator VI = valueNumbering.find(V);
@ -466,7 +466,7 @@ uint32_t ValueTable::lookup(Value *V) const {
return VI->second; return VI->second;
} }
/// lookup_or_add_cmp - Returns the value number of the given comparison, /// Returns the value number of the given comparison,
/// assigning it a new number if it did not have one before. Useful when /// assigning it a new number if it did not have one before. Useful when
/// we deduced the result of a comparison, but don't immediately have an /// we deduced the result of a comparison, but don't immediately have an
/// instruction realizing that comparison to hand. /// instruction realizing that comparison to hand.
@ -479,14 +479,14 @@ uint32_t ValueTable::lookup_or_add_cmp(unsigned Opcode,
return e; return e;
} }
/// clear - Remove all entries from the ValueTable. /// Remove all entries from the ValueTable.
void ValueTable::clear() { void ValueTable::clear() {
valueNumbering.clear(); valueNumbering.clear();
expressionNumbering.clear(); expressionNumbering.clear();
nextValueNumber = 1; nextValueNumber = 1;
} }
/// erase - Remove a value from the value numbering. /// Remove a value from the value numbering.
void ValueTable::erase(Value *V) { void ValueTable::erase(Value *V) {
valueNumbering.erase(V); valueNumbering.erase(V);
} }
@ -582,8 +582,8 @@ namespace {
return cast<MemIntrinsic>(Val.getPointer()); return cast<MemIntrinsic>(Val.getPointer());
} }
/// MaterializeAdjustedValue - Emit code into this block to adjust the value /// Emit code into this block to adjust the value defined here to the
/// defined here to the specified type. This handles various coercion cases. /// specified type. This handles various coercion cases.
Value *MaterializeAdjustedValue(Type *LoadTy, GVN &gvn) const; Value *MaterializeAdjustedValue(Type *LoadTy, GVN &gvn) const;
}; };
@ -598,7 +598,7 @@ namespace {
ValueTable VN; ValueTable VN;
/// LeaderTable - A mapping from value numbers to lists of Value*'s that /// A mapping from value numbers to lists of Value*'s that
/// have that value number. Use findLeader to query it. /// have that value number. Use findLeader to query it.
struct LeaderTableEntry { struct LeaderTableEntry {
Value *Val; Value *Val;
@ -623,7 +623,7 @@ namespace {
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
/// markInstructionForDeletion - This removes the specified instruction from /// This removes the specified instruction from
/// our various maps and marks it for deletion. /// our various maps and marks it for deletion.
void markInstructionForDeletion(Instruction *I) { void markInstructionForDeletion(Instruction *I) {
VN.erase(I); VN.erase(I);
@ -635,8 +635,7 @@ namespace {
AliasAnalysis *getAliasAnalysis() const { return VN.getAliasAnalysis(); } AliasAnalysis *getAliasAnalysis() const { return VN.getAliasAnalysis(); }
MemoryDependenceAnalysis &getMemDep() const { return *MD; } MemoryDependenceAnalysis &getMemDep() const { return *MD; }
private: private:
/// addToLeaderTable - Push a new Value to the LeaderTable onto the list for /// Push a new Value to the LeaderTable onto the list for its value number.
/// its value number.
void addToLeaderTable(uint32_t N, Value *V, const BasicBlock *BB) { void addToLeaderTable(uint32_t N, Value *V, const BasicBlock *BB) {
LeaderTableEntry &Curr = LeaderTable[N]; LeaderTableEntry &Curr = LeaderTable[N];
if (!Curr.Val) { if (!Curr.Val) {
@ -652,7 +651,7 @@ namespace {
Curr.Next = Node; Curr.Next = Node;
} }
/// removeFromLeaderTable - Scan the list of values corresponding to a given /// Scan the list of values corresponding to a given
/// value number, and remove the given instruction if encountered. /// value number, and remove the given instruction if encountered.
void removeFromLeaderTable(uint32_t N, Instruction *I, BasicBlock *BB) { void removeFromLeaderTable(uint32_t N, Instruction *I, BasicBlock *BB) {
LeaderTableEntry* Prev = nullptr; LeaderTableEntry* Prev = nullptr;
@ -729,7 +728,7 @@ namespace {
char GVN::ID = 0; char GVN::ID = 0;
} }
// createGVNPass - The public interface to this file... // The public interface to this file...
FunctionPass *llvm::createGVNPass(bool NoLoads) { FunctionPass *llvm::createGVNPass(bool NoLoads) {
return new GVN(NoLoads); return new GVN(NoLoads);
} }
@ -754,7 +753,7 @@ void GVN::dump(DenseMap<uint32_t, Value*>& d) {
} }
#endif #endif
/// IsValueFullyAvailableInBlock - Return true if we can prove that the value /// Return true if we can prove that the value
/// we're analyzing is fully available in the specified block. As we go, keep /// we're analyzing is fully available in the specified block. As we go, keep
/// track of which blocks we know are fully alive in FullyAvailableBlocks. This /// track of which blocks we know are fully alive in FullyAvailableBlocks. This
/// map is actually a tri-state map with the following values: /// map is actually a tri-state map with the following values:
@ -800,7 +799,7 @@ static bool IsValueFullyAvailableInBlock(BasicBlock *BB,
return true; return true;
// SpeculationFailure - If we get here, we found out that this is not, after // If we get here, we found out that this is not, after
// all, a fully-available block. We have a problem if we speculated on this and // all, a fully-available block. We have a problem if we speculated on this and
// used the speculation to mark other blocks as available. // used the speculation to mark other blocks as available.
SpeculationFailure: SpeculationFailure:
@ -835,8 +834,7 @@ SpeculationFailure:
} }
/// CanCoerceMustAliasedValueToLoad - Return true if /// Return true if CoerceAvailableValueToLoadType will succeed.
/// CoerceAvailableValueToLoadType will succeed.
static bool CanCoerceMustAliasedValueToLoad(Value *StoredVal, static bool CanCoerceMustAliasedValueToLoad(Value *StoredVal,
Type *LoadTy, Type *LoadTy,
const DataLayout &DL) { const DataLayout &DL) {
@ -855,7 +853,7 @@ static bool CanCoerceMustAliasedValueToLoad(Value *StoredVal,
return true; return true;
} }
/// CoerceAvailableValueToLoadType - If we saw a store of a value to memory, and /// If we saw a store of a value to memory, and
/// then a load from a must-aliased pointer of a different type, try to coerce /// then a load from a must-aliased pointer of a different type, try to coerce
/// the stored value. LoadedTy is the type of the load we want to replace and /// the stored value. LoadedTy is the type of the load we want to replace and
/// InsertPt is the place to insert new instructions. /// InsertPt is the place to insert new instructions.
@ -940,7 +938,7 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal,
return new BitCastInst(StoredVal, LoadedTy, "bitcast", InsertPt); return new BitCastInst(StoredVal, LoadedTy, "bitcast", InsertPt);
} }
/// AnalyzeLoadFromClobberingWrite - This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being a clobbering memory write (store, /// memdep query of a load that ends up being a clobbering memory write (store,
/// memset, memcpy, memmove). This means that the write *may* provide bits used /// memset, memcpy, memmove). This means that the write *may* provide bits used
/// by the load but we can't be sure because the pointers don't mustalias. /// by the load but we can't be sure because the pointers don't mustalias.
@ -1020,7 +1018,7 @@ static int AnalyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
return LoadOffset-StoreOffset; return LoadOffset-StoreOffset;
} }
/// AnalyzeLoadFromClobberingStore - This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being a clobbering store. /// memdep query of a load that ends up being a clobbering store.
static int AnalyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr, static int AnalyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
StoreInst *DepSI, StoreInst *DepSI,
@ -1036,7 +1034,7 @@ static int AnalyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
StorePtr, StoreSize, DL); StorePtr, StoreSize, DL);
} }
/// AnalyzeLoadFromClobberingLoad - This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being clobbered by another load. See if /// memdep query of a load that ends up being clobbered by another load. See if
/// the other load can feed into the second load. /// the other load can feed into the second load.
static int AnalyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, static int AnalyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr,
@ -1112,7 +1110,7 @@ static int AnalyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
} }
/// GetStoreValueForLoad - This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being a clobbering store. This means /// memdep query of a load that ends up being a clobbering store. This means
/// that the store provides bits used by the load but we the pointers don't /// that the store provides bits used by the load but we the pointers don't
/// mustalias. Check this case to see if there is anything more we can do /// mustalias. Check this case to see if there is anything more we can do
@ -1151,7 +1149,7 @@ static Value *GetStoreValueForLoad(Value *SrcVal, unsigned Offset,
return CoerceAvailableValueToLoadType(SrcVal, LoadTy, InsertPt, DL); return CoerceAvailableValueToLoadType(SrcVal, LoadTy, InsertPt, DL);
} }
/// GetLoadValueForLoad - This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being a clobbering load. This means /// memdep query of a load that ends up being a clobbering load. This means
/// that the load *may* provide bits used by the load but we can't be sure /// that the load *may* provide bits used by the load but we can't be sure
/// because the pointers don't mustalias. Check this case to see if there is /// because the pointers don't mustalias. Check this case to see if there is
@ -1214,7 +1212,7 @@ static Value *GetLoadValueForLoad(LoadInst *SrcVal, unsigned Offset,
} }
/// GetMemInstValueForLoad - This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being a clobbering mem intrinsic. /// memdep query of a load that ends up being a clobbering mem intrinsic.
static Value *GetMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset, static Value *GetMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
Type *LoadTy, Instruction *InsertPt, Type *LoadTy, Instruction *InsertPt,
@ -1271,7 +1269,7 @@ static Value *GetMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
} }
/// ConstructSSAForLoadSet - Given a set of loads specified by ValuesPerBlock, /// Given a set of loads specified by ValuesPerBlock,
/// construct SSA form, allowing us to eliminate LI. This returns the value /// construct SSA form, allowing us to eliminate LI. This returns the value
/// that should be used at LI's definition site. /// that should be used at LI's definition site.
static Value *ConstructSSAForLoadSet(LoadInst *LI, static Value *ConstructSSAForLoadSet(LoadInst *LI,
@ -1706,7 +1704,7 @@ bool GVN::PerformLoadPRE(LoadInst *LI, AvailValInBlkVect &ValuesPerBlock,
return true; return true;
} }
/// processNonLocalLoad - Attempt to eliminate a load whose dependencies are /// Attempt to eliminate a load whose dependencies are
/// non-local by performing PHI construction. /// non-local by performing PHI construction.
bool GVN::processNonLocalLoad(LoadInst *LI) { bool GVN::processNonLocalLoad(LoadInst *LI) {
// Step 1: Find the non-local dependencies of the load. // Step 1: Find the non-local dependencies of the load.
@ -1819,7 +1817,7 @@ static void patchAndReplaceAllUsesWith(Instruction *I, Value *Repl) {
I->replaceAllUsesWith(Repl); I->replaceAllUsesWith(Repl);
} }
/// processLoad - Attempt to eliminate a load, first by eliminating it /// Attempt to eliminate a load, first by eliminating it
/// locally, and then attempting non-local elimination if that fails. /// locally, and then attempting non-local elimination if that fails.
bool GVN::processLoad(LoadInst *L) { bool GVN::processLoad(LoadInst *L) {
if (!MD) if (!MD)
@ -2018,7 +2016,7 @@ bool GVN::processLoad(LoadInst *L) {
return false; return false;
} }
// findLeader - In order to find a leader for a given value number at a // In order to find a leader for a given value number at a
// specific basic block, we first obtain the list of all Values for that number, // specific basic block, we first obtain the list of all Values for that number,
// and then scan the list to find one whose block dominates the block in // and then scan the list to find one whose block dominates the block in
// question. This is fast because dominator tree queries consist of only // question. This is fast because dominator tree queries consist of only
@ -2046,9 +2044,8 @@ Value *GVN::findLeader(const BasicBlock *BB, uint32_t num) {
return Val; return Val;
} }
/// replaceAllDominatedUsesWith - Replace all uses of 'From' with 'To' if the /// Replace all uses of 'From' with 'To' if the use is dominated by the given
/// use is dominated by the given basic block. Returns the number of uses that /// basic block. Returns the number of uses that were replaced.
/// were replaced.
unsigned GVN::replaceAllDominatedUsesWith(Value *From, Value *To, unsigned GVN::replaceAllDominatedUsesWith(Value *From, Value *To,
const BasicBlockEdge &Root) { const BasicBlockEdge &Root) {
unsigned Count = 0; unsigned Count = 0;
@ -2064,7 +2061,7 @@ unsigned GVN::replaceAllDominatedUsesWith(Value *From, Value *To,
return Count; return Count;
} }
/// isOnlyReachableViaThisEdge - There is an edge from 'Src' to 'Dst'. Return /// There is an edge from 'Src' to 'Dst'. Return
/// true if every path from the entry block to 'Dst' passes via this edge. In /// true if every path from the entry block to 'Dst' passes via this edge. In
/// particular 'Dst' must not be reachable via another edge from 'Src'. /// particular 'Dst' must not be reachable via another edge from 'Src'.
static bool isOnlyReachableViaThisEdge(const BasicBlockEdge &E, static bool isOnlyReachableViaThisEdge(const BasicBlockEdge &E,
@ -2081,7 +2078,7 @@ static bool isOnlyReachableViaThisEdge(const BasicBlockEdge &E,
return Pred != nullptr; return Pred != nullptr;
} }
/// propagateEquality - The given values are known to be equal in every block /// The given values are known to be equal in every block
/// dominated by 'Root'. Exploit this, for example by replacing 'LHS' with /// dominated by 'Root'. Exploit this, for example by replacing 'LHS' with
/// 'RHS' everywhere in the scope. Returns whether a change was made. /// 'RHS' everywhere in the scope. Returns whether a change was made.
bool GVN::propagateEquality(Value *LHS, Value *RHS, bool GVN::propagateEquality(Value *LHS, Value *RHS,
@ -2227,7 +2224,7 @@ bool GVN::propagateEquality(Value *LHS, Value *RHS,
return Changed; return Changed;
} }
/// processInstruction - When calculating availability, handle an instruction /// When calculating availability, handle an instruction
/// by inserting it into the appropriate sets /// by inserting it into the appropriate sets
bool GVN::processInstruction(Instruction *I) { bool GVN::processInstruction(Instruction *I) {
// Ignore dbg info intrinsics. // Ignore dbg info intrinsics.
@ -2636,7 +2633,7 @@ bool GVN::performScalarPRE(Instruction *CurInst) {
return true; return true;
} }
/// performPRE - Perform a purely local form of PRE that looks for diamond /// Perform a purely local form of PRE that looks for diamond
/// control flow patterns and attempts to perform simple PRE at the join point. /// control flow patterns and attempts to perform simple PRE at the join point.
bool GVN::performPRE(Function &F) { bool GVN::performPRE(Function &F) {
bool Changed = false; bool Changed = false;
@ -2673,7 +2670,7 @@ BasicBlock *GVN::splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ) {
return BB; return BB;
} }
/// splitCriticalEdges - Split critical edges found during the previous /// Split critical edges found during the previous
/// iteration that may enable further optimization. /// iteration that may enable further optimization.
bool GVN::splitCriticalEdges() { bool GVN::splitCriticalEdges() {
if (toSplit.empty()) if (toSplit.empty())
@ -2687,7 +2684,7 @@ bool GVN::splitCriticalEdges() {
return true; return true;
} }
/// iterateOnFunction - Executes one iteration of GVN /// Executes one iteration of GVN
bool GVN::iterateOnFunction(Function &F) { bool GVN::iterateOnFunction(Function &F) {
cleanupGlobalSets(); cleanupGlobalSets();
@ -2718,7 +2715,7 @@ void GVN::cleanupGlobalSets() {
TableAllocator.Reset(); TableAllocator.Reset();
} }
/// verifyRemoved - Verify that the specified instruction does not occur in our /// Verify that the specified instruction does not occur in our
/// internal data structures. /// internal data structures.
void GVN::verifyRemoved(const Instruction *Inst) const { void GVN::verifyRemoved(const Instruction *Inst) const {
VN.verifyRemoved(Inst); VN.verifyRemoved(Inst);
@ -2737,11 +2734,10 @@ void GVN::verifyRemoved(const Instruction *Inst) const {
} }
} }
// BB is declared dead, which implied other blocks become dead as well. This /// BB is declared dead, which implied other blocks become dead as well. This
// function is to add all these blocks to "DeadBlocks". For the dead blocks' /// function is to add all these blocks to "DeadBlocks". For the dead blocks'
// live successors, update their phi nodes by replacing the operands /// live successors, update their phi nodes by replacing the operands
// corresponding to dead blocks with UndefVal. /// corresponding to dead blocks with UndefVal.
//
void GVN::addDeadBlock(BasicBlock *BB) { void GVN::addDeadBlock(BasicBlock *BB) {
SmallVector<BasicBlock *, 4> NewDead; SmallVector<BasicBlock *, 4> NewDead;
SmallSetVector<BasicBlock *, 4> DF; SmallSetVector<BasicBlock *, 4> DF;