replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use find instead of lower_bound. 

llvm-svn: 53474
This commit is contained in:
Dan Gohman 2008-07-11 20:58:19 +00:00
parent aced3ad4b8
commit 3707f1daba
6 changed files with 16 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
llvm/include/llvm/Analysis/LoopInfo.h
View File

@ -823,8 +823,8 @@ public:
for (typename std::vector<BlockT*>::iterator I = L->Blocks.begin(),
E = L->Blocks.end(); I != E; ++I) {
typename std::map<BlockT*, LoopBase<BlockT>*>::iterator BBMI =
BBMap.lower_bound(*I);
if (BBMI == BBMap.end() || BBMI->first != *I) // Not in map yet...
BBMap.find(*I);
if (BBMI == BBMap.end()) // Not in map yet...
BBMap.insert(BBMI, std::make_pair(*I, L)); // Must be at this level
}

4
llvm/lib/Analysis/LoadValueNumbering.cpp
View File

@ -117,9 +117,9 @@ static bool isPathTransparentTo(BasicBlock *CurBlock, BasicBlock *Dom,
// Check whether this block is known transparent or not.
std::map<BasicBlock*, bool>::iterator TBI =
TransparentBlocks.lower_bound(CurBlock);
TransparentBlocks.find(CurBlock);
if (TBI == TransparentBlocks.end() || TBI->first != CurBlock) {
if (TBI == TransparentBlocks.end()) {
// If this basic block can modify the memory location, then the path is not
// transparent!
if (AA.canBasicBlockModify(*CurBlock, Ptr, Size)) {

4
llvm/lib/Support/Timer.cpp
View File

@ -185,8 +185,8 @@ void Timer::addPeakMemoryMeasurement() {
static ManagedStatic<std::map<std::string, Timer> > NamedTimers;
static Timer &getNamedRegionTimer(const std::string &Name) {
std::map<std::string, Timer>::iterator I = NamedTimers->lower_bound(Name);
if (I != NamedTimers->end() && I->first == Name)
std::map<std::string, Timer>::iterator I = NamedTimers->find(Name);
if (I != NamedTimers->end())
return I->second;
return NamedTimers->insert(I, std::make_pair(Name, Timer(Name)))->second;

4
llvm/lib/Transforms/IPO/GlobalDCE.cpp
View File

@ -134,10 +134,10 @@ bool GlobalDCE::runOnModule(Module &M) {
/// MarkGlobalIsNeeded - the specific global value as needed, and
/// recursively mark anything that it uses as also needed.
void GlobalDCE::GlobalIsNeeded(GlobalValue *G) {
std::set<GlobalValue*>::iterator I = AliveGlobals.lower_bound(G);
std::set<GlobalValue*>::iterator I = AliveGlobals.find(G);
// If the global is already in the set, no need to reprocess it.
if (I != AliveGlobals.end() && *I == G) return;
if (I != AliveGlobals.end()) return;
// Otherwise insert it now, so we do not infinitely recurse
AliveGlobals.insert(I, G);

9
llvm/lib/VMCore/Constants.cpp
View File

@ -1100,9 +1100,9 @@ public:
/// necessary.
ConstantClass *getOrCreate(const TypeClass *Ty, const ValType &V) {
MapKey Lookup(Ty, V);
typename MapTy::iterator I = Map.lower_bound(Lookup);
typename MapTy::iterator I = Map.find(Lookup);
// Is it in the map?
if (I != Map.end() && I->first == Lookup)
if (I != Map.end())
return static_cast<ConstantClass *>(I->second);
// If no preexisting value, create one now...
@ -1119,10 +1119,9 @@ public:
// If the type of the constant is abstract, make sure that an entry exists
// for it in the AbstractTypeMap.
if (Ty->isAbstract()) {
typename AbstractTypeMapTy::iterator TI =
AbstractTypeMap.lower_bound(Ty);
typename AbstractTypeMapTy::iterator TI = AbstractTypeMap.find(Ty);
if (TI == AbstractTypeMap.end() || TI->first != Ty) {
if (TI == AbstractTypeMap.end()) {
// Add ourselves to the ATU list of the type.
cast<DerivedType>(Ty)->addAbstractTypeUser(this);

8
llvm/lib/VMCore/Type.cpp
View File

@ -251,8 +251,8 @@ static std::string getTypeDescription(const Type *Ty,
std::vector<const Type *> &TypeStack) {
if (isa<OpaqueType>(Ty)) { // Base case for the recursion
std::map<const Type*, std::string>::iterator I =
AbstractTypeDescriptions->lower_bound(Ty);
if (I != AbstractTypeDescriptions->end() && I->first == Ty)
AbstractTypeDescriptions->find(Ty);
if (I != AbstractTypeDescriptions->end())
return I->second;
std::string Desc = "opaque";
AbstractTypeDescriptions->insert(std::make_pair(Ty, Desc));
@ -655,8 +655,8 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2,
if (isa<OpaqueType>(Ty))
return false; // Two unequal opaque types are never equal
std::map<const Type*, const Type*>::iterator It = EqTypes.lower_bound(Ty);
if (It != EqTypes.end() && It->first == Ty)
std::map<const Type*, const Type*>::iterator It = EqTypes.find(Ty);
if (It != EqTypes.end())
return It->second == Ty2; // Looping back on a type, check for equality
// Otherwise, add the mapping to the table to make sure we don't get