Mercurial > hg > graal-compiler
comparison agent/src/share/classes/sun/jvm/hotspot/types/basic/BasicField.java @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | ba764ed4b6f2 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a61af66fc99e |
---|---|
1 /* | |
2 * Copyright 2000 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.basic; | |
26 | |
27 import sun.jvm.hotspot.debugger.*; | |
28 import sun.jvm.hotspot.types.*; | |
29 | |
30 /** A basic implementation of Field which should be suitable for | |
31 cross-platform use. */ | |
32 | |
33 public class BasicField implements Field { | |
34 protected BasicTypeDataBase db; | |
35 protected Type type; | |
36 | |
37 private Type containingType; | |
38 private String name; | |
39 private long size; | |
40 private boolean isStatic; | |
41 /** Used for nonstatic fields only */ | |
42 private long offset; | |
43 /** Used for static fields only */ | |
44 private Address staticFieldAddress; | |
45 | |
46 /** offsetInBytes is ignored if the field is static; | |
47 staticFieldAddress is used only if the field is static. */ | |
48 public BasicField(BasicTypeDataBase db, Type containingType, String name, Type type, | |
49 boolean isStatic, long offsetInBytes, Address staticFieldAddress) { | |
50 this.db = db; | |
51 this.containingType = containingType; | |
52 this.name = name; | |
53 this.type = type; | |
54 this.size = type.getSize(); | |
55 this.isStatic = isStatic; | |
56 this.offset = offsetInBytes; | |
57 this.staticFieldAddress = staticFieldAddress; | |
58 } | |
59 | |
60 public String getName() { | |
61 return name; | |
62 } | |
63 | |
64 public Type getType() { | |
65 return type; | |
66 } | |
67 | |
68 public long getSize() { | |
69 return size; | |
70 } | |
71 | |
72 public boolean isStatic() { | |
73 return isStatic; | |
74 } | |
75 | |
76 public long getOffset() throws WrongTypeException { | |
77 if (isStatic) { | |
78 throw new WrongTypeException("field \"" + name + "\" in class " + | |
79 containingType.getName() + " is static"); | |
80 } | |
81 return offset; | |
82 } | |
83 | |
84 public Address getStaticFieldAddress() throws WrongTypeException { | |
85 if (!isStatic) { | |
86 throw new WrongTypeException("field \"" + name + "\" in class " + | |
87 containingType.getName() + " is not static"); | |
88 } | |
89 return staticFieldAddress; | |
90 } | |
91 | |
92 //-------------------------------------------------------------------------------- | |
93 // Dereferencing operations for non-static fields | |
94 // | |
95 | |
96 public boolean getJBoolean (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
97 if (isStatic) { | |
98 throw new WrongTypeException(); | |
99 } | |
100 return addr.getJBooleanAt(offset); | |
101 } | |
102 public byte getJByte (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
103 if (isStatic) { | |
104 throw new WrongTypeException(); | |
105 } | |
106 return addr.getJByteAt(offset); | |
107 } | |
108 public char getJChar (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
109 if (isStatic) { | |
110 throw new WrongTypeException(); | |
111 } | |
112 return addr.getJCharAt(offset); | |
113 } | |
114 public double getJDouble (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
115 if (isStatic) { | |
116 throw new WrongTypeException(); | |
117 } | |
118 return addr.getJDoubleAt(offset); | |
119 } | |
120 public float getJFloat (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
121 if (isStatic) { | |
122 throw new WrongTypeException(); | |
123 } | |
124 return addr.getJFloatAt(offset); | |
125 } | |
126 public int getJInt (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
127 if (isStatic) { | |
128 throw new WrongTypeException(); | |
129 } | |
130 return addr.getJIntAt(offset); | |
131 } | |
132 public long getJLong (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
133 if (isStatic) { | |
134 throw new WrongTypeException(); | |
135 } | |
136 return addr.getJLongAt(offset); | |
137 } | |
138 public short getJShort (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
139 if (isStatic) { | |
140 throw new WrongTypeException(); | |
141 } | |
142 return addr.getJShortAt(offset); | |
143 } | |
144 public long getCInteger (Address addr, CIntegerType type) | |
145 throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
146 if (isStatic) { | |
147 throw new WrongTypeException(); | |
148 } | |
149 return addr.getCIntegerAt(offset, type.getSize(), type.isUnsigned()); | |
150 } | |
151 public Address getAddress (Address addr) throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
152 if (isStatic) { | |
153 throw new WrongTypeException(); | |
154 } | |
155 return addr.getAddressAt(offset); | |
156 } | |
157 public OopHandle getOopHandle(Address addr) | |
158 throws UnmappedAddressException, UnalignedAddressException, WrongTypeException, NotInHeapException { | |
159 if (isStatic) { | |
160 throw new WrongTypeException(); | |
161 } | |
162 return addr.getOopHandleAt(offset); | |
163 } | |
164 | |
165 //-------------------------------------------------------------------------------- | |
166 // Dereferencing operations for static fields | |
167 // | |
168 | |
169 public boolean getJBoolean () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
170 if (!isStatic) { | |
171 throw new WrongTypeException(); | |
172 } | |
173 return staticFieldAddress.getJBooleanAt(0); | |
174 } | |
175 public byte getJByte () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
176 if (!isStatic) { | |
177 throw new WrongTypeException(); | |
178 } | |
179 return staticFieldAddress.getJByteAt(0); | |
180 } | |
181 public char getJChar () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
182 if (!isStatic) { | |
183 throw new WrongTypeException(); | |
184 } | |
185 return staticFieldAddress.getJCharAt(0); | |
186 } | |
187 public double getJDouble () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
188 if (!isStatic) { | |
189 throw new WrongTypeException(); | |
190 } | |
191 return staticFieldAddress.getJDoubleAt(0); | |
192 } | |
193 public float getJFloat () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
194 if (!isStatic) { | |
195 throw new WrongTypeException(); | |
196 } | |
197 return staticFieldAddress.getJFloatAt(0); | |
198 } | |
199 public int getJInt () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
200 if (!isStatic) { | |
201 throw new WrongTypeException(); | |
202 } | |
203 return staticFieldAddress.getJIntAt(0); | |
204 } | |
205 public long getJLong () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
206 if (!isStatic) { | |
207 throw new WrongTypeException(); | |
208 } | |
209 return staticFieldAddress.getJLongAt(0); | |
210 } | |
211 public short getJShort () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
212 if (!isStatic) { | |
213 throw new WrongTypeException(); | |
214 } | |
215 return staticFieldAddress.getJShortAt(0); | |
216 } | |
217 public long getCInteger (CIntegerType type) | |
218 throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
219 if (!isStatic) { | |
220 throw new WrongTypeException(); | |
221 } | |
222 return staticFieldAddress.getCIntegerAt(0, type.getSize(), type.isUnsigned()); | |
223 } | |
224 public Address getAddress () throws UnmappedAddressException, UnalignedAddressException, WrongTypeException { | |
225 if (!isStatic) { | |
226 throw new WrongTypeException(); | |
227 } | |
228 return staticFieldAddress.getAddressAt(0); | |
229 } | |
230 public OopHandle getOopHandle() | |
231 throws UnmappedAddressException, UnalignedAddressException, WrongTypeException, NotInHeapException { | |
232 if (!isStatic) { | |
233 throw new WrongTypeException(); | |
234 } | |
235 return staticFieldAddress.getOopHandleAt(0); | |
236 } | |
237 } |