View Javadoc
1   /*
2    * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.
8    *
9    * This code is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12   * version 2 for more details (a copy is included in the LICENSE file that
13   * accompanied this code).
14   *
15   * You should have received a copy of the GNU General Public License version
16   * 2 along with this work; if not, write to the Free Software Foundation,
17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18   *
19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20   * or visit www.oracle.com if you need additional information or have any
21   * questions.
22   *
23   */
24  
25  package sun.jvm.hotspot.types;
26  
27  import java.util.Iterator;
28  import sun.jvm.hotspot.debugger.Address;
29  
30  public interface TypeDataBase {
31    /** Equivalent to lookupType(cTypeName, true) */
32    public Type lookupType(String cTypeName);
33  
34    /** For simplicity of the initial implementation, this is not
35        guaranteed to work for primitive types. If throwException is
36        true, throws an (unspecified) run-time exception if the type is
37        not found. */
38    public Type lookupType(String cTypeName, boolean throwException);
39  
40    /** Equivalent to lookupIntConstant(constantName, true) */
41    public Integer lookupIntConstant(String constantName);
42  
43    /* For convenience, this interface also encapsulates the fetching of
44       integer constants, i.e., enums. If no constant of this name was
45       present, either throws an (unspecified) run-time exception or
46       returns null. */
47    public Integer lookupIntConstant(String constantName, boolean throwException);
48  
49    /** Equivalent to lookupLongConstant(constantName, true) */
50    public Long lookupLongConstant(String constantName);
51  
52    /* For convenience, this interface also encapsulates the fetching of
53       long constants (those requiring 64 bits on 64-bit platforms). If
54       no constant of this name was present, either throws an
55       (unspecified) run-time exception or returns null. */
56    public Long lookupLongConstant(String constantName, boolean throwException);
57  
58    /** Accessors for types representing the Java primitive types; used
59        for both proper type checking and for walking down Java arrays. */
60    public Type getJBooleanType();
61    public Type getJByteType();
62    public Type getJCharType();
63    public Type getJDoubleType();
64    public Type getJFloatType();
65    public Type getJIntType();
66    public Type getJLongType();
67    public Type getJShortType();
68  
69    /** Returns the size of a C address in bytes. This is currently
70        needed in order to properly traverse an array of pointers.
71        Traversing an array of structs, for example, is possible by
72        looking up the type of the struct and multiplying the index by
73        its size when indexing off of a base Address. (FIXME: what about
74        alignment?) */
75    public long getAddressSize();
76  
77    /** Returns the size of an oop in bytes. This is currently needed in
78        order to properly traverse an array of oops; it is distinguished
79        from the address size, above, because object pointers could
80        conceivably have a different representation than direct
81        pointers. Traversing an array of structs, for example, is
82        possible by looking up the type of the struct and multiplying
83        the index by its size when indexing off of a base Address. */
84    public long getOopSize();
85  
86    /** <P> This is an experimental interface emulating C++'s run-time
87        type information (RTTI) mechanism: determines whether the given
88        address is a pointer to the start of a C++ object of precisely
89        the given type -- it does not search superclasses of the type.
90        The convention is that this returns false for the null pointer.
91        It is needed to allow wrapper Java objects of the appropriate
92        type to be constructed for existing C++ objects of polymorphic
93        type. This method is only intended to work for C++ types
94        (implying that we should rename this package and the classes
95        contained within back to "ctypes"). Further, since the vptr
96        offset in an object is known at compile time but not necessarily
97        at runtime (unless debugging information is available), it is
98        reasonable for an implementation of this method to search nearby
99        memory for the (known) vtbl value for the given type. For this
100       reason, this method is not intended to support scans through
101       memory finding C++ objects, but is instead targeted towards
102       discovering the true type of a pointer assumed to be
103       intact. </P>
104 
105       <P> The reason this method was placed in the type database is
106       that the latter is the first level at which it could be exposed,
107       and placing it here could avoid modifying the Type interface. It
108       is unclear what other, if any, vtbl access would be useful (or
109       implementable), so we are trying to avoid changing interfaces at
110       this point to support this kind of functionality. </P>
111 
112       <P> This method necessarily does not support multiple
113       inheritance. </P> */
114   public boolean addressTypeIsEqualToType(Address addr, Type type);
115 
116   /** Helper routine for guessing the most derived type of a
117       polymorphic C++ object. Iterates the type database calling
118       addressTypeIsEqualToType for all known types. Returns a matching
119       Type for the given address if one was found, or null if none was
120       found. */
121   public Type guessTypeForAddress(Address addr);
122 
123   /** Helper routine for guessing the most derived type of a
124       polymorphic C++ object. Requires a baseType that must be virtual
125       so that lookup can be performed without false positives */
126   public Type findDynamicTypeForAddress(Address addr, Type baseType);
127 
128   /** Returns an Iterator over the Types in the database. */
129   public Iterator getTypes();
130 
131   /** Returns an Iterator over the String names of the integer
132       constants in the database. */
133   public Iterator getIntConstants();
134 
135   /** Returns an Iterator over the String names of the long constants
136       in the database. */
137   public Iterator getLongConstants();
138 }