Mercurial > hg > truffle
diff agent/src/share/classes/sun/jvm/hotspot/types/TypeDataBase.java @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | c18cbe5936b8 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/agent/src/share/classes/sun/jvm/hotspot/types/TypeDataBase.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,133 @@ +/* + * Copyright 2000-2004 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package sun.jvm.hotspot.types; + +import java.util.Iterator; +import sun.jvm.hotspot.debugger.Address; + +public interface TypeDataBase { + /** Equivalent to lookupType(cTypeName, true) */ + public Type lookupType(String cTypeName); + + /** For simplicity of the initial implementation, this is not + guaranteed to work for primitive types. If throwException is + true, throws an (unspecified) run-time exception if the type is + not found. */ + public Type lookupType(String cTypeName, boolean throwException); + + /** Equivalent to lookupIntConstant(constantName, true) */ + public Integer lookupIntConstant(String constantName); + + /* For convenience, this interface also encapsulates the fetching of + integer constants, i.e., enums. If no constant of this name was + present, either throws an (unspecified) run-time exception or + returns null. */ + public Integer lookupIntConstant(String constantName, boolean throwException); + + /** Equivalent to lookupLongConstant(constantName, true) */ + public Long lookupLongConstant(String constantName); + + /* For convenience, this interface also encapsulates the fetching of + long constants (those requiring 64 bits on 64-bit platforms). If + no constant of this name was present, either throws an + (unspecified) run-time exception or returns null. */ + public Long lookupLongConstant(String constantName, boolean throwException); + + /** Accessors for types representing the Java primitive types; used + for both proper type checking and for walking down Java arrays. */ + public Type getJBooleanType(); + public Type getJByteType(); + public Type getJCharType(); + public Type getJDoubleType(); + public Type getJFloatType(); + public Type getJIntType(); + public Type getJLongType(); + public Type getJShortType(); + + /** Returns the size of a C address in bytes. This is currently + needed in order to properly traverse an array of pointers. + Traversing an array of structs, for example, is possible by + looking up the type of the struct and multiplying the index by + its size when indexing off of a base Address. (FIXME: what about + alignment?) */ + public long getAddressSize(); + + /** Returns the size of an oop in bytes. This is currently needed in + order to properly traverse an array of oops; it is distinguished + from the address size, above, because object pointers could + conceivably have a different representation than direct + pointers. Traversing an array of structs, for example, is + possible by looking up the type of the struct and multiplying + the index by its size when indexing off of a base Address. */ + public long getOopSize(); + + /** <P> This is an experimental interface emulating C++'s run-time + type information (RTTI) mechanism: determines whether the given + address is a pointer to the start of a C++ object of precisely + the given type -- it does not search superclasses of the type. + The convention is that this returns false for the null pointer. + It is needed to allow wrapper Java objects of the appropriate + type to be constructed for existing C++ objects of polymorphic + type. This method is only intended to work for C++ types + (implying that we should rename this package and the classes + contained within back to "ctypes"). Further, since the vptr + offset in an object is known at compile time but not necessarily + at runtime (unless debugging information is available), it is + reasonable for an implementation of this method to search nearby + memory for the (known) vtbl value for the given type. For this + reason, this method is not intended to support scans through + memory finding C++ objects, but is instead targeted towards + discovering the true type of a pointer assumed to be + intact. </P> + + <P> The reason this method was placed in the type database is + that the latter is the first level at which it could be exposed, + and placing it here could avoid modifying the Type interface. It + is unclear what other, if any, vtbl access would be useful (or + implementable), so we are trying to avoid changing interfaces at + this point to support this kind of functionality. </P> + + <P> This method necessarily does not support multiple + inheritance. </P> */ + public boolean addressTypeIsEqualToType(Address addr, Type type); + + /** Helper routine for guessing the most derived type of a + polymorphic C++ object. Iterates the type database calling + addressTypeIsEqualToType for all known types. Returns a matching + Type for the given address if one was found, or null if none was + found. */ + public Type guessTypeForAddress(Address addr); + + /** Returns an Iterator over the Types in the database. */ + public Iterator getTypes(); + + /** Returns an Iterator over the String names of the integer + constants in the database. */ + public Iterator getIntConstants(); + + /** Returns an Iterator over the String names of the long constants + in the database. */ + public Iterator getLongConstants(); +}