import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
boolean isAssignableTo(ReferenceType destType) {
    if (destType instanceof ArrayType) {
        try {
            Type destComponentType = ((ArrayType)destType).componentType();
            return isComponentAssignable(destComponentType, componentType());
        } catch (ClassNotLoadedException e) {
            // One or both component types has not yet been
            // loaded => can't assign
            return false;
        }
    } else {
        Symbol typeName = ((ReferenceTypeImpl)destType).typeNameAsSymbol();
        if (destType instanceof InterfaceType) {
            // Every array type implements java.io.Serializable and
            // java.lang.Cloneable. fixme in JVMDI-JDI, includes only
            // Cloneable but not Serializable.
            return typeName.equals(vm.javaLangCloneable()) ||
                   typeName.equals(vm.javaIoSerializable());
        } else {
            // Only valid ClassType assignee is Object
            return typeName.equals(vm.javaLangObject());
        }
    }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
private void writeFieldDescriptors(List fields, InstanceKlass ik)
    throws IOException {
  // ik == null for instance fields.
  out.writeShort((short) fields.size());
  for (Iterator itr = fields.iterator(); itr.hasNext();) {
    Field field = (Field) itr.next();
    Symbol name = symTbl.probe(field.getID().getName());
    writeSymbolID(name);
    char typeCode = (char) field.getSignature().getByteAt(0);
    int kind = signatureToHprofKind(typeCode);
    out.writeByte((byte)kind);
    if (ik != null) {
      // static field
      writeField(field, ik.getJavaMirror());
    }
  }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的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.Symbol; //导入依赖的package包/类
String baseSourceName() throws AbsentInformationException {
  if (saKlass instanceof ArrayKlass) {
        throw new AbsentInformationException();
  }
  Symbol sym = ((InstanceKlass)saKlass).getSourceFileName();
  if (sym != null) {
      return sym.asString();
  } else {
      throw new AbsentInformationException();
  }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
private SDE sourceDebugExtensionInfo() {
    if (!vm.canGetSourceDebugExtension()) {
        return NO_SDE_INFO_MARK;
    }
    SDE sde = null;
    sde = (sdeRef == null) ?  null : (SDE)sdeRef.get();
    if (sde == null) {
       String extension = null;
       if (saKlass instanceof InstanceKlass) {
          Symbol sdeSym = ((InstanceKlass)saKlass).getSourceDebugExtension();
          extension = (sdeSym != null)? sdeSym.asString() : null;
       }
       if (extension == null) {
          sde = NO_SDE_INFO_MARK;
       } else {
          sde = new SDE(extension);
       }
       sdeRef = new SoftReference(sde);
    }
    return sde;
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的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.Symbol; //导入依赖的package包/类
public void doit(Tokens t) {
    if (t.countTokens() != 1) {
        usage();
    } else {
        Address a = VM.getVM().getDebugger().parseAddress(t.nextToken());
        Symbol.create(a).printValueOn(out);
        out.println();
    }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
private JNITypeParser getParser() {
    if (signatureParser == null) {
        Symbol sig1 = saMethod.getSignature();
        signature = sig1.asString();
        signatureParser = new JNITypeParser(signature);
    }
    return signatureParser;
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
public String genericSignature() {
    if (saKlass instanceof ArrayKlass) {
        return null;
    } else {
        Symbol genSig = ((InstanceKlass)saKlass).getGenericSignature();
        return (genSig != null)? genSig.asString() : null;
    }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
private void getParser() {
    if (signatureParser == null) {
        Symbol sig1 = saField.getSignature();
        signature = sig1.asString();
        signatureParser = new JNITypeParser(signature);
    }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
private synchronized List findReferenceTypes(String signature) {
    if (typesByID == null) {
        return new ArrayList(0);
    }

    // we haven't sorted types by signatures. But we can take
    // advantage of comparing symbols instead of name. In the worst
    // case, we will be comparing N addresses rather than N strings
    // where N being total no. of classes in allClasses() list.

    // The signature could be Lx/y/z; or [....
    // If it is Lx/y/z; the internal type name is x/y/x
    // for array klasses internal type name is same as
    // signature
    String typeName = null;
    if (signature.charAt(0) == 'L') {
        typeName = signature.substring(1, signature.length() - 1);
    } else {
        typeName = signature;
    }

    Symbol typeNameSym = saSymbolTable().probe(typeName);
    // if there is no symbol in VM, then we wouldn't have that type
    if (typeNameSym == null) {
        return new ArrayList(0);
    }

    Iterator iter = typesBySignature.iterator();
    List list = new ArrayList();
    while (iter.hasNext()) {
        // We have cached type name as symbol in reference type
        ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next();
        if (typeNameSym.equals(type.typeNameAsSymbol())) {
            list.add(type);
        }
    }
    return list;
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
private void writeSymbols() throws IOException {
  try {
    symTbl.symbolsDo(new SymbolTable.SymbolVisitor() {
      public void visit(Symbol sym) {
        try {
          writeSymbol(sym);
        } catch (IOException exp) {
          throw new RuntimeException(exp);
        }
      }
    });
  } catch (RuntimeException re) {
    handleRuntimeException(re);
  }
}
 

import sun.jvm.hotspot.oops.Symbol; //导入依赖的package包/类
@Override
public Oop newOop(OopHandle handle) {
  if (handle == null) {
    return null;
  }

  Address klassAddress;
  if (VM.getVM().isCompressedKlassPointersEnabled()) {
    klassAddress = handle.getCompKlassAddressAt(oopCompressedKlass.getOffset());
  } else {
    klassAddress = handle.getAddressAt(oopKlass.getOffset());
  }

  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 FastObjArray(handle, this, new FastObjArrayKlass(klassAddress, bottomKlass));
  } else if (tag == Klass.LH_ARRAY_TAG_TYPE_VALUE) {
    // primitive array
    return new FastTypeArray(handle, this, new TypeArrayKlass(klassAddress));
  } else {
    Symbol name = Symbol.create(klassAddress.getAddressAt(klassName.getOffset()));
    if (javaLangClass.equals(name)) {
      // instance of java.lang.Class, which has special handling for static members
      return new FastInstance(handle, this, new FastInstanceMirrorKlass(klassAddress));
    } else {
      // instance of anything else. we don't handle InstanceRefKlass or InstanceClassLoaderKlass
      // because they contain no extra logic
      return new FastInstance(handle, this, new FastInstanceKlass(klassAddress));
    }
  }
}