import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public Type componentType() throws ClassNotLoadedException {
    ArrayKlass k = (ArrayKlass) ref();
    if (k instanceof ObjArrayKlass) {
        Klass elementKlass = ((ObjArrayKlass)k).getElementKlass();
        if (elementKlass == null) {
            throw new ClassNotLoadedException(componentSignature());
        } else {
            return vm.referenceType(elementKlass);
        }
    } else {
        // It's a primitive type
        return vm.primitiveTypeMirror(signature().charAt(1));
    }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public void doit(Tokens t) {
    if (t.countTokens() != 0) {
        usage();
    } else {
        SystemDictionary sysDict = VM.getVM().getSystemDictionary();
        sysDict.allClassesDo(new SystemDictionary.ClassVisitor() {
                public void visit(Klass k) {
                    if (k instanceof InstanceKlass && ((InstanceKlass)k).getConstants().getCache() != null) {
                        MethodArray methods = ((InstanceKlass)k).getMethods();
                        for (int i = 0; i < methods.length(); i++) {
                            Method m = methods.at(i);
                            HTMLGenerator gen = new HTMLGenerator(false);
                            out.println(gen.genHTML(m));
                        }
                    }
                }
            }
            );
    }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public int compareTo(ReferenceType refType) {
    /*
     * Note that it is critical that compareTo() == 0
     * implies that equals() == true. Otherwise, TreeSet
     * will collapse classes.
     *
     * (Classes of the same name loaded by different class loaders
     * or in different VMs must not return 0).
     */
    ReferenceTypeImpl other = (ReferenceTypeImpl)refType;
    int comp = name().compareTo(other.name());
    if (comp == 0) {
        Klass rf1 = ref();
        Klass rf2 = other.ref();
        // optimize for typical case: refs equal and VMs equal
        if (rf1.equals(rf2)) {
            // sequenceNumbers are always positive
            comp = vm.sequenceNumber -
             ((VirtualMachineImpl)(other.virtualMachine())).sequenceNumber;
        } else {
            comp = rf1.getAddress().minus(rf2.getAddress()) < 0? -1 : 1;
        }
    }
    return comp;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public ReferenceType reflectedType() {
    if (reflectedType == null) {
        Klass k = java_lang_Class.asKlass(ref());
        reflectedType = vm.referenceType(k);
    }
    return reflectedType;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
private synchronized ReferenceTypeImpl addReferenceType(Klass kk) {
    if (typesByID == null) {
        initReferenceTypes();
    }
    ReferenceTypeImpl newRefType = null;
    if (kk instanceof ObjArrayKlass || kk instanceof TypeArrayKlass) {
        newRefType = new ArrayTypeImpl(this, (ArrayKlass)kk);
    } else if (kk instanceof InstanceKlass) {
        if (kk.isInterface()) {
            newRefType = new InterfaceTypeImpl(this, (InstanceKlass)kk);
        } else {
            newRefType = new ClassTypeImpl(this, (InstanceKlass)kk);
        }
    } else {
        throw new RuntimeException("should not reach here:" + kk);
    }

    typesByID.put(kk, newRefType);
    typesBySignature.add(newRefType);
    return newRefType;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public ClassLoaderReference classLoader() {
    if (ref() instanceof TypeArrayKlass) {
        // primitive array klasses are loaded by bootstrap loader
        return null;
    } else {
        Klass bottomKlass = ((ObjArrayKlass)ref()).getBottomKlass();
        if (bottomKlass instanceof TypeArrayKlass) {
            // multidimensional primitive array klasses are loaded by bootstrap loader
            return null;
        } else {
            // class loader of any other obj array klass is same as the loader
            // that loaded the bottom InstanceKlass
            Instance xx = (Instance)(((InstanceKlass) bottomKlass).getClassLoader());
            return vm.classLoaderMirror(xx);
        }
    }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public void doit(Tokens t) {
    if (t.countTokens() != 0) {
        usage();
    } else {
        ClassLoaderDataGraph cldg = VM.getVM().getClassLoaderDataGraph();
        cldg.classesDo(new ClassLoaderDataGraph.ClassVisitor() {
                public void visit(Klass k) {
                    if (k instanceof InstanceKlass && ((InstanceKlass)k).getConstants().getCache() != null) {
                        MethodArray methods = ((InstanceKlass)k).getMethods();
                        for (int i = 0; i < methods.length(); i++) {
                            Method m = methods.at(i);
                            HTMLGenerator gen = new HTMLGenerator(false);
                            out.println(gen.genHTML(m));
                        }
                    }
                }
            }
            );
    }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
private void writeClassDumpRecords() throws IOException {
  SystemDictionary sysDict = VM.getVM().getSystemDictionary();
  try {
    sysDict.allClassesDo(new SystemDictionary.ClassVisitor() {
      public void visit(Klass k) {
        try {
          writeHeapRecordPrologue();
          writeClassDumpRecord(k);
          writeHeapRecordEpilogue();
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
    });
  } catch (RuntimeException re) {
    handleRuntimeException(re);
  }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public Klass getKlassAtAddress(Address klassAddress) {
  int layoutHelper = klassAddress.getJIntAt(klassLayoutHelper.getOffset());
  int tag = layoutHelper >> Klass.LH_ARRAY_TAG_SHIFT;

  if (tag == Klass.LH_ARRAY_TAG_OBJ_VALUE) {
    // object array
    Klass bottomKlass = getKlassAtAddress(objArrayBottomKlass.getValue(klassAddress));
    return new FastObjArrayKlass(klassAddress, bottomKlass);
  } else if (tag == Klass.LH_ARRAY_TAG_TYPE_VALUE) {
    // primitive array
    return new TypeArrayKlass(klassAddress);
  } else {
    Symbol name = Symbol.create(klassAddress.getAddressAt(klassName.getOffset()));
    if (javaLangClass.equals(name)) {
      // java.lang.Class
      return new FastInstanceMirrorKlass(klassAddress);
    } else {
      // any other non-array class
      return new FastInstanceKlass(klassAddress);
    }
  }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
private synchronized ReferenceTypeImpl addReferenceType(Klass kk) {
    if (typesByID == null) {
        initReferenceTypes();
    }
    ReferenceTypeImpl newRefType = null;
    if (kk instanceof ObjArrayKlass || kk instanceof TypeArrayKlass) {
        newRefType = new ArrayTypeImpl(this, (ArrayKlass)kk);
    } else if (kk instanceof InstanceKlass) {
        if (kk.isInterface()) {
            newRefType = new InterfaceTypeImpl(this, (InstanceKlass)kk);
        } else {
            newRefType = new ClassTypeImpl(this, (InstanceKlass)kk);
        }
    } else {
        throw new RuntimeException("should not reach here");
    }

    typesByID.put(kk, newRefType);
    typesBySignature.add(newRefType);
    return newRefType;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
@Override
public void run() {
    SystemDictionary dictionary = VM.getVM().getSystemDictionary();
    Klass klass = dictionary.find("java/security/PrivateKey", null, null);

    VM.getVM().getObjectHeap().iterateObjectsOfKlass(new DefaultHeapVisitor() {
        @Override
        public boolean doObj(Oop oop) {
            oop.iterate(new KeyPrinter(), false);
            return false;
        }
    }, klass);
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
void printOopValue(Oop oop) {
    if (oop != null) {
        Klass k = oop.getKlass();
        Symbol s = k.getName();
        if (s != null) {
            out.print("Oop for " + s.asString() + " @ ");
        } else {
            out.print("Oop @ ");
        }
        Oop.printOopAddressOn(oop, out);
    } else {
        out.print("null");
    }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
protected ReferenceTypeImpl(VirtualMachine aVm, sun.jvm.hotspot.oops.Klass klass) {
    super(aVm);
    saKlass = klass;
    typeNameSymbol = saKlass.getName();
    if (Assert.ASSERTS_ENABLED) {
        Assert.that(typeNameSymbol != null, "null type name for a Klass");
    }
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public List instances(long maxInstances) {
    if (!vm.canGetInstanceInfo()) {
        throw new UnsupportedOperationException(
                  "target does not support getting instances");
    }

    if (maxInstances < 0) {
        throw new IllegalArgumentException("maxInstances is less than zero: "
                                          + maxInstances);
    }

    final List objects = new ArrayList(0);
    if (isAbstract() || (this instanceof InterfaceType)) {
        return objects;
    }

    final Klass givenKls = this.ref();
    final long max = maxInstances;
    vm.saObjectHeap().iterate(new DefaultHeapVisitor() {
            private long instCount=0;
            public boolean doObj(Oop oop) {
                if (givenKls.equals(oop.getKlass())) {
                    objects.add(vm.objectMirror(oop));
                                            instCount++;
                }
                if (max > 0 && instCount >= max) {
                    return true;
                                    }
                                    return false;
            }
        });
    return objects;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
ReferenceTypeImpl referenceType(Klass kk) {
    ReferenceTypeImpl retType = null;
    synchronized (this) {
        if (typesByID != null) {
            retType = (ReferenceTypeImpl)typesByID.get(kk);
        }
        if (retType == null) {
            retType = addReferenceType(kk);
        }
    }
    return retType;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
private List/*<ObjectReference>*/ objectsByExactType(ReferenceType type) {
    final List objects = new ArrayList(0);
    final Klass givenKls = ((ReferenceTypeImpl)type).ref();
    saObjectHeap.iterate(new DefaultHeapVisitor() {
            public boolean doObj(Oop oop) {
                if (givenKls.equals(oop.getKlass())) {
                    objects.add(objectMirror(oop));
                }
                    return false;
            }
        });
    return objects;
}
 

import sun.jvm.hotspot.oops.Klass; //导入依赖的package包/类
public List/*<ObjectReference>*/ objectsByType(ReferenceType type, boolean includeSubtypes) {
    Klass kls = ((ReferenceTypeImpl)type).ref();
    if (kls instanceof InstanceKlass) {
        InstanceKlass ik = (InstanceKlass) kls;
        // if the Klass is final or if there are no subklasses loaded yet
        if (ik.getAccessFlagsObj().isFinal() || ik.getSubklassKlass() == null) {
            includeSubtypes = false;
        }
    } else {
        // no subtypes for primitive array types
        ArrayTypeImpl arrayType = (ArrayTypeImpl) type;
        try {
            Type componentType = arrayType.componentType();
            if (componentType instanceof PrimitiveType) {
                includeSubtypes = false;
            }
        } catch (ClassNotLoadedException cnle) {
            // ignore. component type not yet loaded
        }
    }

    if (includeSubtypes) {
        return objectsBySubType(type);
    } else {
        return objectsByExactType(type);
    }
}