*** old/src/share/vm/code/dependencies.cpp	Wed Feb 26 07:50:02 2014
--- new/src/share/vm/code/dependencies.cpp	Wed Feb 26 07:50:02 2014

*** 723,782 ****
--- 723,745 ----
    // e.g. evol_method.
    return NULL;
  }
  
  // ----------------- DependencySignature --------------------------------------
! bool DependencySignature::equals(const DependencySignature& sig) const {
!   if (type() != sig.type()) {
! bool DependencySignature::equals(DependencySignature* sig) const {
!   if ((type() != sig->type()) || (args_count() != sig->args_count())) {
      return false;
    }
  
!   if (args_count() != sig.args_count()) {
      return false;
    }
  
    for (int i = 0; i < sig.args_count(); i++) {
      if (arg(i) != sig.arg(i)) {
!   for (int i = 0; i < sig->args_count(); i++) {
+     if (arg(i) != sig->arg(i)) {
        return false;
      }
    }
    return true;
  }
  
  
  // ----------------- DependencySignatureBuffer --------------------------------------
  DependencySignatureBuffer::DependencySignatureBuffer() {
    _signatures = NEW_RESOURCE_ARRAY(GrowableArray<DependencySignature*>*, Dependencies::TYPE_LIMIT);
    memset(_signatures, 0, sizeof(DependencySignature*) * Dependencies::TYPE_LIMIT);
  }
  
  /* Check if arguments are identical. Two dependency signatures are considered
   * identical, if the type as well as all argument identifiers are identical.
   * If the dependency has not already been checked, the dependency signature is
   * added to the checked dependencies of the same type. The function returns
   * false, which causes the dependency to be checked in the caller.
   */
  bool DependencySignatureBuffer::add_if_missing(const DependencySignature& sig) {
    const int index = sig.type();
    GrowableArray<DependencySignature*>* buffer = _signatures[index];
    if (buffer == NULL) {
      buffer = new GrowableArray<DependencySignature*>();
      _signatures[index] = buffer;
    }
  
    // Check if we have already checked the dependency
    for (int i = 0; i < buffer->length(); i++) {
      DependencySignature* checked_signature = buffer->at(i);
      if (checked_signature->equals(sig)) {
        return true;
      }
    }
    buffer->append((DependencySignature*)&sig);
    return false;
  }
  
  
  /// Checking dependencies:
  
  // This hierarchy walker inspects subtypes of a given type,
  // trying to find a "bad" class which breaks a dependency.
  // Such a class is called a "witness" to the broken dependency.