335 lines
12 KiB
Java
335 lines
12 KiB
Java
/*
|
|
* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
|
|
/*
|
|
* The Original Code is HAT. The Initial Developer of the
|
|
* Original Code is Bill Foote, with contributions from others
|
|
* at JavaSoft/Sun.
|
|
*/
|
|
|
|
package com.sun.tools.hat.internal.model;
|
|
|
|
import java.io.IOException;
|
|
import com.sun.tools.hat.internal.parser.ReadBuffer;
|
|
|
|
/**
|
|
* Represents Java instance
|
|
*
|
|
* @author Bill Foote
|
|
*/
|
|
public class JavaObject extends JavaLazyReadObject {
|
|
|
|
private Object clazz; // Number before resolve
|
|
// JavaClass after resolve
|
|
/**
|
|
* Construct a new JavaObject.
|
|
*
|
|
* @param classID id of the class object
|
|
* @param offset The offset of field data
|
|
*/
|
|
public JavaObject(long classID, long offset) {
|
|
super(offset);
|
|
this.clazz = makeId(classID);
|
|
}
|
|
|
|
public void resolve(Snapshot snapshot) {
|
|
if (clazz instanceof JavaClass) {
|
|
return;
|
|
}
|
|
if (clazz instanceof Number) {
|
|
long classID = getIdValue((Number)clazz);
|
|
clazz = snapshot.findThing(classID);
|
|
if (! (clazz instanceof JavaClass)) {
|
|
warn("Class " + Long.toHexString(classID) + " not found, " +
|
|
"adding fake class!");
|
|
int length;
|
|
ReadBuffer buf = snapshot.getReadBuffer();
|
|
int idSize = snapshot.getIdentifierSize();
|
|
long lenOffset = getOffset() + 2*idSize + 4;
|
|
try {
|
|
length = buf.getInt(lenOffset);
|
|
} catch (IOException exp) {
|
|
throw new RuntimeException(exp);
|
|
}
|
|
clazz = snapshot.addFakeInstanceClass(classID, length);
|
|
}
|
|
} else {
|
|
throw new InternalError("should not reach here");
|
|
}
|
|
|
|
JavaClass cl = (JavaClass) clazz;
|
|
cl.resolve(snapshot);
|
|
|
|
// while resolving, parse fields in verbose mode.
|
|
// but, getFields calls parseFields in non-verbose mode
|
|
// to avoid printing warnings repeatedly.
|
|
parseFields(getValue(), true);
|
|
|
|
cl.addInstance(this);
|
|
super.resolve(snapshot);
|
|
}
|
|
|
|
/**
|
|
* Are we the same type as other? We are iff our clazz is the
|
|
* same type as other's.
|
|
*/
|
|
public boolean isSameTypeAs(JavaThing other) {
|
|
if (!(other instanceof JavaObject)) {
|
|
return false;
|
|
}
|
|
JavaObject oo = (JavaObject) other;
|
|
return getClazz().equals(oo.getClazz());
|
|
}
|
|
|
|
/**
|
|
* Return our JavaClass object. This may only be called after resolve.
|
|
*/
|
|
public JavaClass getClazz() {
|
|
return (JavaClass) clazz;
|
|
}
|
|
|
|
public JavaThing[] getFields() {
|
|
// pass false to verbose mode so that dereference
|
|
// warnings are not printed.
|
|
return parseFields(getValue(), false);
|
|
}
|
|
|
|
// returns the value of field of given name
|
|
public JavaThing getField(String name) {
|
|
JavaThing[] flds = getFields();
|
|
JavaField[] instFields = getClazz().getFieldsForInstance();
|
|
for (int i = 0; i < instFields.length; i++) {
|
|
if (instFields[i].getName().equals(name)) {
|
|
return flds[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int compareTo(JavaThing other) {
|
|
if (other instanceof JavaObject) {
|
|
JavaObject oo = (JavaObject) other;
|
|
return getClazz().getName().compareTo(oo.getClazz().getName());
|
|
}
|
|
return super.compareTo(other);
|
|
}
|
|
|
|
public void visitReferencedObjects(JavaHeapObjectVisitor v) {
|
|
super.visitReferencedObjects(v);
|
|
JavaThing[] flds = getFields();
|
|
for (int i = 0; i < flds.length; i++) {
|
|
if (flds[i] != null) {
|
|
if (v.mightExclude()
|
|
&& v.exclude(getClazz().getClassForField(i),
|
|
getClazz().getFieldForInstance(i)))
|
|
{
|
|
// skip it
|
|
} else if (flds[i] instanceof JavaHeapObject) {
|
|
v.visit((JavaHeapObject) flds[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean refersOnlyWeaklyTo(Snapshot ss, JavaThing other) {
|
|
if (ss.getWeakReferenceClass() != null) {
|
|
final int referentFieldIndex = ss.getReferentFieldIndex();
|
|
if (ss.getWeakReferenceClass().isAssignableFrom(getClazz())) {
|
|
//
|
|
// REMIND: This introduces a dependency on the JDK
|
|
// implementation that is undesirable.
|
|
JavaThing[] flds = getFields();
|
|
for (int i = 0; i < flds.length; i++) {
|
|
if (i != referentFieldIndex && flds[i] == other) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Describe the reference that this thing has to target. This will only
|
|
* be called if target is in the array returned by getChildrenForRootset.
|
|
*/
|
|
public String describeReferenceTo(JavaThing target, Snapshot ss) {
|
|
JavaThing[] flds = getFields();
|
|
for (int i = 0; i < flds.length; i++) {
|
|
if (flds[i] == target) {
|
|
JavaField f = getClazz().getFieldForInstance(i);
|
|
return "field " + f.getName();
|
|
}
|
|
}
|
|
return super.describeReferenceTo(target, ss);
|
|
}
|
|
|
|
public String toString() {
|
|
if (getClazz().isString()) {
|
|
JavaThing value = getField("value");
|
|
if (value instanceof JavaValueArray) {
|
|
return ((JavaValueArray)value).valueString();
|
|
} else {
|
|
return "null";
|
|
}
|
|
} else {
|
|
return super.toString();
|
|
}
|
|
}
|
|
|
|
// Internals only below this point
|
|
|
|
/*
|
|
* Java instance record (HPROF_GC_INSTANCE_DUMP) looks as below:
|
|
*
|
|
* object ID
|
|
* stack trace serial number (int)
|
|
* class ID
|
|
* data length (int)
|
|
* byte[length]
|
|
*/
|
|
protected final int readValueLength() throws IOException {
|
|
JavaClass cl = getClazz();
|
|
int idSize = cl.getIdentifierSize();
|
|
long lengthOffset = getOffset() + 2*idSize + 4;
|
|
return cl.getReadBuffer().getInt(lengthOffset);
|
|
}
|
|
|
|
protected final byte[] readValue() throws IOException {
|
|
JavaClass cl = getClazz();
|
|
int idSize = cl.getIdentifierSize();
|
|
ReadBuffer buf = cl.getReadBuffer();
|
|
long offset = getOffset() + 2*idSize + 4;
|
|
int length = buf.getInt(offset);
|
|
if (length == 0) {
|
|
return Snapshot.EMPTY_BYTE_ARRAY;
|
|
} else {
|
|
byte[] res = new byte[length];
|
|
buf.get(offset + 4, res);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
private JavaThing[] parseFields(byte[] data, boolean verbose) {
|
|
JavaClass cl = getClazz();
|
|
int target = cl.getNumFieldsForInstance();
|
|
JavaField[] fields = cl.getFields();
|
|
JavaThing[] fieldValues = new JavaThing[target];
|
|
Snapshot snapshot = cl.getSnapshot();
|
|
int idSize = snapshot.getIdentifierSize();
|
|
int fieldNo = 0;
|
|
// In the dump file, the fields are stored in this order:
|
|
// fields of most derived class (immediate class) are stored
|
|
// first and then the super class and so on. In this object,
|
|
// fields are stored in the reverse ("natural") order. i.e.,
|
|
// fields of most super class are stored first.
|
|
|
|
// target variable is used to compensate for the fact that
|
|
// the dump file starts field values from the leaf working
|
|
// upwards in the inheritance hierarchy, whereas JavaObject
|
|
// starts with the top of the inheritance hierarchy and works down.
|
|
target -= fields.length;
|
|
JavaClass currClass = cl;
|
|
int index = 0;
|
|
for (int i = 0; i < fieldValues.length; i++, fieldNo++) {
|
|
while (fieldNo >= fields.length) {
|
|
currClass = currClass.getSuperclass();
|
|
fields = currClass.getFields();
|
|
fieldNo = 0;
|
|
target -= fields.length;
|
|
}
|
|
JavaField f = fields[fieldNo];
|
|
char sig = f.getSignature().charAt(0);
|
|
switch (sig) {
|
|
case 'L':
|
|
case '[': {
|
|
long id = objectIdAt(index, data);
|
|
index += idSize;
|
|
JavaObjectRef ref = new JavaObjectRef(id);
|
|
fieldValues[target+fieldNo] = ref.dereference(snapshot, f, verbose);
|
|
break;
|
|
}
|
|
case 'Z': {
|
|
byte value = byteAt(index, data);
|
|
index++;
|
|
fieldValues[target+fieldNo] = new JavaBoolean(value != 0);
|
|
break;
|
|
}
|
|
case 'B': {
|
|
byte value = byteAt(index, data);
|
|
index++;
|
|
fieldValues[target+fieldNo] = new JavaByte(value);
|
|
break;
|
|
}
|
|
case 'S': {
|
|
short value = shortAt(index, data);
|
|
index += 2;
|
|
fieldValues[target+fieldNo] = new JavaShort(value);
|
|
break;
|
|
}
|
|
case 'C': {
|
|
char value = charAt(index, data);
|
|
index += 2;
|
|
fieldValues[target+fieldNo] = new JavaChar(value);
|
|
break;
|
|
}
|
|
case 'I': {
|
|
int value = intAt(index, data);
|
|
index += 4;
|
|
fieldValues[target+fieldNo] = new JavaInt(value);
|
|
break;
|
|
}
|
|
case 'J': {
|
|
long value = longAt(index, data);
|
|
index += 8;
|
|
fieldValues[target+fieldNo] = new JavaLong(value);
|
|
break;
|
|
}
|
|
case 'F': {
|
|
float value = floatAt(index, data);
|
|
index += 4;
|
|
fieldValues[target+fieldNo] = new JavaFloat(value);
|
|
break;
|
|
}
|
|
case 'D': {
|
|
double value = doubleAt(index, data);
|
|
index += 8;
|
|
fieldValues[target+fieldNo] = new JavaDouble(value);
|
|
break;
|
|
}
|
|
default:
|
|
throw new RuntimeException("invalid signature: " + sig);
|
|
}
|
|
}
|
|
return fieldValues;
|
|
}
|
|
|
|
private void warn(String msg) {
|
|
System.out.println("WARNING: " + msg);
|
|
}
|
|
}
|