*** old/src/share/vm/utilities/hashtable.cpp	Fri Feb 21 09:04:02 2014
--- new/src/share/vm/utilities/hashtable.cpp	Fri Feb 21 09:04:02 2014

*** 23,32 ****
--- 23,33 ----
   */
  
  #include "precompiled.hpp"
  #include "classfile/altHashing.hpp"
  #include "classfile/javaClasses.hpp"
+ #include "code/dependencies.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/filemap.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/safepoint.hpp"

*** 336,346 ****
--- 337,346 ----
  }
  
  
  #endif // PRODUCT
  
  
  #ifdef ASSERT
  
  template <MEMFLAGS F> void BasicHashtable<F>::verify_lookup_length(double load) {
    if ((double)_lookup_length / (double)_lookup_count > load * 2.0) {
      warning("Performance bug: SystemDictionary lookup_count=%d "

*** 349,358 ****
--- 349,410 ----
              (double) _lookup_length / _lookup_count, load);
    }
  }
  
  #endif
+ 
+ 
+ template<class T, class M> GenericHashtable<T, M>::GenericHashtable(int size, bool resource_mark, MEMFLAGS memflag) {
+   assert(size > 0, " Invalid hashtable size");
+   _size = size;
+   // Perform subtype-specific resource allocation
+   _elements = (resource_mark) ? NEW_RESOURCE_ARRAY(T*, size) : NEW_C_HEAP_ARRAY(T*, size, memflag);
+   memset(_elements, 0, sizeof(T*) * size);
+ }
+ 
+ 
+ /**
+  * Add item to the hashtable. Returns 'true' if an element was added
+  * and false otherwise.
+  */
+ template<class T, class F> bool GenericHashtable<T, F>::add(T* item) {
+   if ((item == NULL) || contains(item)) {
+     return false;
+   }
+ 
+   uintptr_t hash = item->hash();
+   int idx = hash % size();
+ 
+   // Add to linked list
+   if (element_at(idx) != NULL) {
+     item->set_next(element_at(idx));
+   }
+ 
+   set_element_at(item, idx);
+   return true;
+ }
+ 
+ template<class T, class F> bool GenericHashtable<T, F>::contains(T* element) {
+   if (element == NULL) {
+     return false;
+   }
+ 
+   uintptr_t hash = element->hash();
+   int idx = hash % size();
+   if (element_at(idx) != NULL) {
+     T* current_element = element_at(idx);
+     while (current_element != NULL) {
+       if (current_element->equals(element)) {
+         return true;
+       }
+       current_element = current_element->next();
+     }
+   }
+   return false;
+ }
+ 
+ 
  // Explicitly instantiate these types
  template class Hashtable<ConstantPool*, mtClass>;
  template class Hashtable<Symbol*, mtSymbol>;
  template class Hashtable<Klass*, mtClass>;
  template class Hashtable<oop, mtClass>;

*** 368,372 ****
--- 420,426 ----
  template class BasicHashtableEntry<mtCode>;
  template class BasicHashtable<mtClass>;
  template class BasicHashtable<mtSymbol>;
  template class BasicHashtable<mtCode>;
  template class BasicHashtable<mtInternal>;
+ 
+ template class GenericHashtable<DependencySignature, ResourceObj>;