Remove some uses of STL map.

runtime/vm/redundancy_elimination.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/redundancy_elimination.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
@@ skipping 27 matching lines @@
         dependent_(other.dependent_) {
   }
 
   void RemoveAffected(EffectSet effects) {
     if (!effects.IsNone()) {
       dependent_.Clear();
     }
   }
 
   Instruction* Lookup(Instruction* other) const {
-    return GetMapFor(other)->Lookup(other);
+    return GetMapFor(other)->LookupValue(other);
   }
 
   void Insert(Instruction* instr) {
     return GetMapFor(instr)->Insert(instr);
   }
 
  private:
   typedef DirectChainedHashMap<PointerKeyValueTrait<Instruction> >  Map;
 
   Map* GetMapFor(Instruction* instr) {
@@ skipping 641 matching lines @@
         aliased_by_effects_(new(zone) BitVector(zone, places->length())) {
     InsertAlias(Place::CreateAnyInstanceAnyIndexAlias(zone_,
         kAnyInstanceAnyIndexAlias));
     for (intptr_t i = 0; i < places_.length(); i++) {
       AddRepresentative(places_[i]);
     }
     ComputeKillSets();
   }
 
   intptr_t LookupAliasId(const Place& alias) {
-    const Place* result = aliases_map_.Lookup(&alias);
+    const Place* result = aliases_map_.LookupValue(&alias);
     return (result != NULL) ? result->id() : static_cast<intptr_t>(kNoAlias);
   }
 
   BitVector* GetKilledSet(intptr_t alias) {
     return (alias < killed_.length()) ? killed_[alias] : NULL;
   }
 
   intptr_t max_place_id() const { return places().length(); }
   bool IsEmpty() const { return max_place_id() == 0; }
 
   BitVector* aliased_by_effects() const { return aliased_by_effects_; }
 
   const ZoneGrowableArray<Place*>& places() const {
     return places_;
   }
 
   Place* LookupCanonical(Place* place) const {
-    return places_map_->Lookup(place);
+    return places_map_->LookupValue(place);
   }
 
   void PrintSet(BitVector* set) {
     bool comma = false;
     for (BitVector::Iterator it(set);
          !it.Done();
          it.Advance()) {
       if (comma) {
         THR_Print(", ");
       }
@@ skipping 105 matching lines @@
       }
     }
   }
 
   void InsertAlias(const Place* alias) {
     aliases_map_.Insert(alias);
     aliases_.Add(alias);
   }
 
   const Place* CanonicalizeAlias(const Place& alias) {
-    const Place* canonical = aliases_map_.Lookup(&alias);
+    const Place* canonical = aliases_map_.LookupValue(&alias);
     if (canonical == NULL) {
       canonical = Place::Wrap(zone_,
                               alias,
                               kAnyInstanceAnyIndexAlias + aliases_.length());
       InsertAlias(canonical);
     }
-    ASSERT(aliases_map_.Lookup(&alias) == canonical);
+    ASSERT(aliases_map_.LookupValue(&alias) == canonical);
     return canonical;
   }
 
   BitVector* GetRepresentativesSet(intptr_t alias) {
     return (alias < representatives_.length()) ? representatives_[alias] : NULL;
   }
 
   BitVector* EnsureSet(GrowableArray<BitVector*>* sets,
                        intptr_t alias) {
     while (sets->length() <= alias) {
@@ skipping 355 matching lines @@
       BlockEntryInstr* block = phi->GetBlock();
 
       if (FLAG_trace_optimization) {
         THR_Print("phi dependent place %s\n", place->ToCString());
       }
 
       Place input_place(*place);
       for (intptr_t j = 0; j < phi->InputCount(); j++) {
         input_place.set_instance(phi->InputAt(j)->definition());
 
-        Place* result = map->Lookup(&input_place);
+        Place* result = map->LookupValue(&input_place);
         if (result == NULL) {
           result = Place::Wrap(zone, input_place, places->length());
           map->Insert(result);
           places->Add(result);
           if (FLAG_trace_optimization) {
             THR_Print("  adding place %s as %" Pd "\n",
                       result->ToCString(),
                       result->id());
           }
         }
@@ skipping 34 matching lines @@
 
     for (ForwardInstructionIterator instr_it(block);
          !instr_it.Done();
          instr_it.Advance()) {
       Instruction* instr = instr_it.Current();
       Place place(instr, &has_loads, &has_stores);
       if (place.kind() == Place::kNone) {
         continue;
       }
 
-      Place* result = map->Lookup(&place);
+      Place* result = map->LookupValue(&place);
       if (result == NULL) {
         result = Place::Wrap(zone, place, places->length());
         map->Insert(result);
         places->Add(result);
 
         if (FLAG_trace_optimization) {
           THR_Print("numbering %s as %" Pd "\n",
                     result->ToCString(),
                     result->id());
         }
@@ skipping 2162 matching lines @@
         join->phis_ = NULL;
       } else {
         join->phis_->TruncateTo(to_index);
       }
     }
   }
 }
 
 
 }  // namespace dart