Back to index...

	/*
	* 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);
	}
	}

Back to index...