ojluni/src/main/java/com/sun/tools/hat/internal/model/JavaObject.java - platform/libcore - Git at Google

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