Use find instead of lower_bound.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53474 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Analysis/LoopInfo.h

@@ -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
     }
 

lib/Analysis/LoadValueNumbering.cpp

@@ -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)) {

lib/Support/Timer.cpp

@@ -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;

lib/Transforms/IPO/GlobalDCE.cpp

@@ -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);

lib/VMCore/Constants.cpp

@@ -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);
 

lib/VMCore/Type.cpp

@@ -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