/*
* Copyright (c) 2000, 2013, 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.
*
* 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.
*
*/
package sun.jvm.hotspot.types.basic;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import sun.jvm.hotspot.debugger.Address;
import sun.jvm.hotspot.debugger.MachineDescription;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
/** <P> This is a basic implementation of the TypeDataBase interface.
It allows an external type database builder to add types to be
consumed by a client through the Type interfaces. It has no
knowledge of symbol lookup; for example, the builder is
responsible for providing the addresses of static fields. </P>
<P> Among other things, the database builder is responsible for
providing the Types for the Java primitive types, as well as their
sizes. </P>
*/
public class BasicTypeDataBase implements TypeDataBase {
private MachineDescription machDesc;
private VtblAccess vtblAccess;
/** Maps strings to Type objects. This does not contain the primitive types. */
private Map nameToTypeMap = new HashMap();
/** Maps strings to Integers, used for enums, etc. */
private Map nameToIntConstantMap = new HashMap();
/** Maps strings to Longs, used for 32/64-bit constants, etc. */
private Map nameToLongConstantMap = new HashMap();
/** Primitive types. */
private Type jbooleanType;
private Type jbyteType;
private Type jcharType;
private Type jdoubleType;
private Type jfloatType;
private Type jintType;
private Type jlongType;
private Type jshortType;
/** For debugging */
private static final boolean DEBUG;
static {
DEBUG = System.getProperty("sun.jvm.hotspot.types.basic.BasicTypeDataBase.DEBUG") != null;
}
public BasicTypeDataBase(MachineDescription machDesc, VtblAccess vtblAccess) {
this.machDesc = machDesc;
this.vtblAccess = vtblAccess;
}
public Type lookupType(String cTypeName) {
return lookupType(cTypeName, true);
}
public Type lookupType(String cTypeName, boolean throwException) {
Type type = (Type) nameToTypeMap.get(cTypeName);
if (type == null && throwException) {
throw new RuntimeException("No type named \"" + cTypeName + "\" in database");
}
return type;
}
public Integer lookupIntConstant(String constantName) {
return lookupIntConstant(constantName, true);
}
public Integer lookupIntConstant(String constantName, boolean throwException) {
Integer i = (Integer) nameToIntConstantMap.get(constantName);
if (i == null) {
if (throwException) {
throw new RuntimeException("No integer constant named \"" + constantName + "\" present in type database");
}
}
return i;
}
public Long lookupLongConstant(String constantName) {
return lookupLongConstant(constantName, true);
}
public Long lookupLongConstant(String constantName, boolean throwException) {
Long i = (Long) nameToLongConstantMap.get(constantName);
if (i == null) {
if (throwException) {
throw new RuntimeException("No long constant named \"" + constantName + "\" present in type database");
}
}
return i;
}
public Type getJBooleanType() {
return jbooleanType;
}
public Type getJByteType() {
return jbyteType;
}
public Type getJCharType() {
return jcharType;
}
public Type getJDoubleType() {
return jdoubleType;
}
public Type getJFloatType() {
return jfloatType;
}
public Type getJIntType() {
return jintType;
}
public Type getJLongType() {
return jlongType;
}
public Type getJShortType() {
return jshortType;
}
public long getAddressSize() {
return machDesc.getAddressSize();
}
public long getOopSize() {
return VM.getVM().getOopSize();
}
HashMap typeToVtbl = new HashMap();
private Address vtblForType(Type type) {
Address vtblAddr = (Address)typeToVtbl.get(type);
if (vtblAddr == null) {
vtblAddr = vtblAccess.getVtblForType(type);
if (vtblAddr != null) {
typeToVtbl.put(type, vtblAddr);
}
}
return vtblAddr;
}
public boolean addressTypeIsEqualToType(Address addr, Type type) {
if (addr == null) {
return false;
}
// This implementation should be suitably platform-independent; we
// search nearby memory for the vtbl value of the given type.
Address vtblAddr = vtblForType(type);
if (vtblAddr == null) {
// Type was not polymorphic, or an error occurred during lookup
if (DEBUG) {
System.err.println("BasicTypeDataBase.addressTypeIsEqualToType: vtblAddr == null");
}
return false;
}
// The first implementation searched three locations for this vtbl
// value; scanning through the entire object was considered, but
// we thought we knew where we were looking, and looking only in
// these specific locations should reduce the probability of
// mistaking random bits as a pointer (although, realistically
// speaking, the likelihood of finding a match between the bit
// pattern of, for example, a double and the vtbl is vanishingly
// small.)
// 1. The first word of the object (should handle MSVC++ as
// well as the SparcWorks compilers with compatibility set to
// v5.0 or greater)
// 2. and 3. The last two Address-aligned words of the part of
// the object defined by its topmost polymorphic superclass.
// This should handle the SparcWorks compilers, v4.2 or
// earlier, as well as any other compilers which place the vptr
// at the end of the user-defined fields of the first base
// class with virtual functions.
//
// Unfortunately this algorithm did not work properly for the
// specific case of the ThreadShadow/Thread inheritance situation,
// because the Solaris compiler seems to cleverly eliminate the
// vtbl for ThreadShadow since the only virtual is empty. (We
// should get rid of the ThreadShadow and fix the include
// databases, but need to postpone this for the present.) The
// current solution performs the three-location check for this
// class and all of its known superclasses rather than just the
// topmost polymorphic one.
Type curType = type;
try {
while (curType != null) {
// Using the size information we have for this type, check the
// three locations described above.
// (1)
if (vtblAddr.equals(addr.getAddressAt(0))) {
return true;
}
// (2)
long offset = curType.getSize();
// I don't think this should be misaligned under any
// circumstances, but I'm not sure (FIXME: also not sure which
// way to go here, up or down -- assuming down)
offset -= (offset % getAddressSize());
if (offset <= 0) {
return false;
}
if (vtblAddr.equals(addr.getAddressAt(offset))) {
return true;
}
offset -= getAddressSize();
if (offset <= 0) {
return false;
}
if (vtblAddr.equals(addr.getAddressAt(offset))) {
return true;
}
curType = curType.getSuperclass();
}
}
catch (Exception e) {
// Any UnmappedAddressExceptions, etc. are a good indication
// that the pointer is not of the specified type
if (DEBUG) {
System.err.println("BasicTypeDataBase.addressTypeIsEqualToType: exception occurred during lookup:");
e.printStackTrace();
}
return false;
}
if (DEBUG) {
System.err.println("BasicTypeDataBase.addressTypeIsEqualToType: all vptr tests failed for type " +
type.getName());
}
return false;
}
public Type findDynamicTypeForAddress(Address addr, Type baseType) {
// This implementation should be suitably platform-independent; we
// search nearby memory for the vtbl value of the given type.
if (vtblForType(baseType) == null) {
// Type was not polymorphic which is an error of some sort
throw new InternalError(baseType + " does not appear to be polymorphic");
}
// This is a more restricted version of guessTypeForAddress since
// that function has some limitations since it doesn't really know
// where in the hierarchy a virtual type starts and just poking
// around in memory is likely to trip over some vtable address,
// resulting in false positives. Eventually all uses should
// switch to this logic but in the interests of stability it will
// be separate for the moment.
// Assuming that the base type is truly the first polymorphic type
// then the vtbl for all subclasss should be at several defined
// locations so only those locations will be checked. It's also
// required that the caller knows that the static type is at least
// baseType. See the notes in guessTypeForAddress for the logic of
// the locations searched.
Address loc1 = addr.getAddressAt(0);
Address loc2 = null;
Address loc3 = null;
long offset2 = baseType.getSize();
// I don't think this should be misaligned under any
// circumstances, but I'm not sure (FIXME: also not sure which
// way to go here, up or down -- assuming down)
offset2 = offset2 - (offset2 % getAddressSize()) - getAddressSize();
if (offset2 > 0) {
loc2 = addr.getAddressAt(offset2);
}
long offset3 = offset2 - getAddressSize();
if (offset3 > 0) {
loc3 = addr.getAddressAt(offset3);
}
Type loc2Match = null;
Type loc3Match = null;
for (Iterator iter = getTypes(); iter.hasNext(); ) {
Type type = (Type) iter.next();
Type superClass = type;
while (superClass != baseType && superClass != null) {
superClass = superClass.getSuperclass();
}
if (superClass == null) continue;
Address vtblAddr = vtblForType(type);
if (vtblAddr == null) {
// This occurs sometimes for intermediate types that are never
// instantiated.
if (DEBUG) {
System.err.println("null vtbl for " + type);
}
continue;
}
// Prefer loc1 match
if (vtblAddr.equals(loc1)) return type;
if (loc2 != null && loc2Match == null && vtblAddr.equals(loc2)) {
loc2Match = type;
}
if (loc3 != null && loc3Match == null && vtblAddr.equals(loc3)) {
loc3Match = type;
}
}
if (loc2Match != null) return loc2Match;
if (loc3Match != null) return loc3Match;
return null;
}
public Type guessTypeForAddress(Address addr) {
for (Iterator iter = getTypes(); iter.hasNext(); ) {
Type t = (Type) iter.next();
if (addressTypeIsEqualToType(addr, t)) {
return t;
}
}
return null;
}
public long cIntegerTypeMaxValue(long sizeInBytes, boolean isUnsigned) {
return machDesc.cIntegerTypeMaxValue(sizeInBytes, isUnsigned);
}
public long cIntegerTypeMinValue(long sizeInBytes, boolean isUnsigned) {
return machDesc.cIntegerTypeMinValue(sizeInBytes, isUnsigned);
}
public Iterator getTypes() {
return nameToTypeMap.values().iterator();
}
public Iterator getIntConstants() {
return nameToIntConstantMap.keySet().iterator();
}
public Iterator getLongConstants() {
return nameToLongConstantMap.keySet().iterator();
}
//--------------------------------------------------------------------------------
// Public routines only for use by the database builder
//
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJBooleanType(Type type) {
jbooleanType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJByteType(Type type) {
jbyteType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJCharType(Type type) {
jcharType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJDoubleType(Type type) {
jdoubleType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJFloatType(Type type) {
jfloatType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJIntType(Type type) {
jintType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJLongType(Type type) {
jlongType = type;
}
/** This method should only be called by the builder of the
TypeDataBase and at most once */
public void setJShortType(Type type) {
jshortType = type;
}
/** This method should only be used by the builder of the
TypeDataBase. Throws a RuntimeException if a class with this
name was already present. */
public void addType(Type type) {
if (nameToTypeMap.get(type.getName()) != null) {
throw new RuntimeException("type of name \"" + type.getName() + "\" already present");
}
nameToTypeMap.put(type.getName(), type);
}
/** This method should only be used by the builder of the
TypeDataBase. Throws a RuntimeException if this class was not
present. */
public void removeType(Type type) {
Type curType = (Type) nameToTypeMap.get(type.getName());
if (curType == null) {
throw new RuntimeException("type of name \"" + type.getName() + "\" not present");
}
if (!curType.equals(type)) {
throw new RuntimeException("a different type of name \"" + type.getName() + "\" was present");
}
nameToTypeMap.remove(type.getName());
}
/** This method should only be used by the builder of the
TypeDataBase. Throws a RuntimeException if an integer constant
with this name was already present. */
public void addIntConstant(String name, int value) {
if (nameToIntConstantMap.get(name) != null) {
throw new RuntimeException("int constant of name \"" + name + "\" already present");
}
nameToIntConstantMap.put(name, new Integer(value));
}
/** This method should only be used by the builder of the
TypeDataBase. Throws a RuntimeException if an integer constant
with this name was not present. */
public void removeIntConstant(String name) {
Integer curConstant = (Integer) nameToIntConstantMap.get(name);
if (curConstant == null) {
throw new RuntimeException("int constant of name \"" + name + "\" not present");
}
nameToIntConstantMap.remove(name);
}
/** This method should only be used by the builder of the
TypeDataBase. Throws a RuntimeException if a long constant with
this name was already present. */
public void addLongConstant(String name, long value) {
if (nameToLongConstantMap.get(name) != null) {
throw new RuntimeException("long constant of name \"" + name + "\" already present");
}
nameToLongConstantMap.put(name, new Long(value));
}
/** This method should only be used by the builder of the
TypeDataBase. Throws a RuntimeException if a long constant with
this name was not present. */
public void removeLongConstant(String name) {
Long curConstant = (Long) nameToLongConstantMap.get(name);
if (curConstant == null) {
throw new RuntimeException("long constant of name \"" + name + "\" not present");
}
nameToLongConstantMap.remove(name);
}
}