Mercurial > hg > graal-jvmci-8
comparison 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 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a61af66fc99e |
---|---|
1 /* | |
2 * Copyright 2000-2004 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any 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 /** Returns an Iterator over the Types in the database. */ | |
124 public Iterator getTypes(); | |
125 | |
126 /** Returns an Iterator over the String names of the integer | |
127 constants in the database. */ | |
128 public Iterator getIntConstants(); | |
129 | |
130 /** Returns an Iterator over the String names of the long constants | |
131 in the database. */ | |
132 public Iterator getLongConstants(); | |
133 } |