*** old/src/share/vm/code/dependencies.hpp	Fri Feb 21 09:04:02 2014
--- new/src/share/vm/code/dependencies.hpp	Fri Feb 21 09:04:02 2014

*** 30,39 ****
--- 30,40 ----
  #include "ci/ciMethodHandle.hpp"
  #include "classfile/systemDictionary.hpp"
  #include "code/compressedStream.hpp"
  #include "code/nmethod.hpp"
  #include "utilities/growableArray.hpp"
+ #include "utilities/hashtable.hpp"
  
  //** Dependencies represent assertions (approximate invariants) within
  // the runtime system, e.g. class hierarchy changes.  An example is an
  // assertion that a given method is not overridden; another example is
  // that a type has only one concrete subtype.  Compiled code which

*** 524,564 ****
--- 525,557 ----
  
    static void print_statistics() PRODUCT_RETURN;
  };
  
  
! class DependencySignature : public GenericHashtableEntry<DependencySignature, ResourceObj> {
   private:
    int                   _args_count;
    uintptr_t             _argument_hash[Dependencies::max_arg_count];
    Dependencies::DepType _type;
  
  
   public:
    DependencySignature(Dependencies::DepStream& dep) {
      _args_count = dep.argument_count();
      _type = dep.type();
      for (int i = 0; i < _args_count; i++) {
        _argument_hash[i] = dep.get_identifier(i);
      }
    }
  
!   bool equals(const DependencySignature& sig) const;
!   bool equals(DependencySignature* sig) const;
+   uintptr_t hash() const { return _argument_hash[0] >> 2; }
  
    int args_count()             const { return _args_count; }
    uintptr_t arg(int idx)       const { return _argument_hash[idx]; }
    Dependencies::DepType type() const { return _type; }
  };
  
  class DependencySignatureBuffer : public StackObj {
   private:
    GrowableArray<DependencySignature*>**  _signatures;
  
   public:
    DependencySignatureBuffer();
    bool add_if_missing(const DependencySignature& sig);
  };
  
  // Every particular DepChange is a sub-class of this class.
  class DepChange : public StackObj {
   public:
    // What kind of DepChange is this?