Mercurial > hg > graal-compiler
annotate src/share/vm/classfile/verificationType.hpp @ 1662:e0ba4e04c839
6969574: invokedynamic call sites deoptimize instead of executing
Reviewed-by: kvn
author | jrose |
---|---|
date | Fri, 16 Jul 2010 18:14:19 -0700 |
parents | c18cbe5936b8 |
children | f95d63e2154a |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 enum { | |
26 // As specifed in the JVM spec | |
27 ITEM_Top = 0, | |
28 ITEM_Integer = 1, | |
29 ITEM_Float = 2, | |
30 ITEM_Double = 3, | |
31 ITEM_Long = 4, | |
32 ITEM_Null = 5, | |
33 ITEM_UninitializedThis = 6, | |
34 ITEM_Object = 7, | |
35 ITEM_Uninitialized = 8, | |
36 ITEM_Bogus = (uint)-1 | |
37 }; | |
38 | |
39 class VerificationType VALUE_OBJ_CLASS_SPEC { | |
40 private: | |
41 // Least significant bits of _handle are always 0, so we use these as | |
42 // the indicator that the _handle is valid. Otherwise, the _data field | |
43 // contains encoded data (as specified below). Should the VM change | |
44 // and the lower bits on oops aren't 0, the assert in the constructor | |
45 // will catch this and we'll have to add a descriminator tag to this | |
46 // structure. | |
47 union { | |
48 symbolOop* _handle; | |
49 uintptr_t _data; | |
50 } _u; | |
51 | |
52 enum { | |
53 // These rest are not found in classfiles, but used by the verifier | |
54 ITEM_Boolean = 9, ITEM_Byte, ITEM_Short, ITEM_Char, | |
55 ITEM_Long_2nd, ITEM_Double_2nd | |
56 }; | |
57 | |
58 // Enum for the _data field | |
59 enum { | |
60 // Bottom two bits determine if the type is a reference, primitive, | |
61 // uninitialized or a query-type. | |
62 TypeMask = 0x00000003, | |
63 | |
64 // Topmost types encoding | |
65 Reference = 0x0, // _handle contains the name | |
66 Primitive = 0x1, // see below for primitive list | |
67 Uninitialized = 0x2, // 0x00ffff00 contains bci | |
68 TypeQuery = 0x3, // Meta-types used for category testing | |
69 | |
70 // Utility flags | |
71 ReferenceFlag = 0x00, // For reference query types | |
72 Category1Flag = 0x01, // One-word values | |
73 Category2Flag = 0x02, // First word of a two-word value | |
74 Category2_2ndFlag = 0x04, // Second word of a two-word value | |
75 | |
76 // special reference values | |
77 Null = 0x00000000, // A reference with a 0 handle is null | |
78 | |
79 // Primitives categories (the second byte determines the category) | |
80 Category1 = (Category1Flag << 1 * BitsPerByte) | Primitive, | |
81 Category2 = (Category2Flag << 1 * BitsPerByte) | Primitive, | |
82 Category2_2nd = (Category2_2ndFlag << 1 * BitsPerByte) | Primitive, | |
83 | |
84 // Primitive values (type descriminator stored in most-signifcant bytes) | |
85 Bogus = (ITEM_Bogus << 2 * BitsPerByte) | Category1, | |
86 Boolean = (ITEM_Boolean << 2 * BitsPerByte) | Category1, | |
87 Byte = (ITEM_Byte << 2 * BitsPerByte) | Category1, | |
88 Short = (ITEM_Short << 2 * BitsPerByte) | Category1, | |
89 Char = (ITEM_Char << 2 * BitsPerByte) | Category1, | |
90 Integer = (ITEM_Integer << 2 * BitsPerByte) | Category1, | |
91 Float = (ITEM_Float << 2 * BitsPerByte) | Category1, | |
92 Long = (ITEM_Long << 2 * BitsPerByte) | Category2, | |
93 Double = (ITEM_Double << 2 * BitsPerByte) | Category2, | |
94 Long_2nd = (ITEM_Long_2nd << 2 * BitsPerByte) | Category2_2nd, | |
95 Double_2nd = (ITEM_Double_2nd << 2 * BitsPerByte) | Category2_2nd, | |
96 | |
97 // Used by Uninitialized (second and third bytes hold the bci) | |
98 BciMask = 0xffff << 1 * BitsPerByte, | |
99 BciForThis = ((u2)-1), // A bci of -1 is an Unintialized-This | |
100 | |
101 // Query values | |
102 ReferenceQuery = (ReferenceFlag << 1 * BitsPerByte) | TypeQuery, | |
103 Category1Query = (Category1Flag << 1 * BitsPerByte) | TypeQuery, | |
104 Category2Query = (Category2Flag << 1 * BitsPerByte) | TypeQuery, | |
105 Category2_2ndQuery = (Category2_2ndFlag << 1 * BitsPerByte) | TypeQuery | |
106 }; | |
107 | |
108 VerificationType(uintptr_t raw_data) { | |
109 _u._data = raw_data; | |
110 } | |
111 | |
112 public: | |
113 | |
114 VerificationType() { *this = bogus_type(); } | |
115 | |
116 // Create verification types | |
117 static VerificationType bogus_type() { return VerificationType(Bogus); } | |
118 static VerificationType null_type() { return VerificationType(Null); } | |
119 static VerificationType integer_type() { return VerificationType(Integer); } | |
120 static VerificationType float_type() { return VerificationType(Float); } | |
121 static VerificationType long_type() { return VerificationType(Long); } | |
122 static VerificationType long2_type() { return VerificationType(Long_2nd); } | |
123 static VerificationType double_type() { return VerificationType(Double); } | |
124 static VerificationType boolean_type() { return VerificationType(Boolean); } | |
125 static VerificationType byte_type() { return VerificationType(Byte); } | |
126 static VerificationType char_type() { return VerificationType(Char); } | |
127 static VerificationType short_type() { return VerificationType(Short); } | |
128 static VerificationType double2_type() | |
129 { return VerificationType(Double_2nd); } | |
130 | |
131 // "check" types are used for queries. A "check" type is not assignable | |
132 // to anything, but the specified types are assignable to a "check". For | |
133 // example, any category1 primitive is assignable to category1_check and | |
134 // any reference is assignable to reference_check. | |
135 static VerificationType reference_check() | |
136 { return VerificationType(ReferenceQuery); } | |
137 static VerificationType category1_check() | |
138 { return VerificationType(Category1Query); } | |
139 static VerificationType category2_check() | |
140 { return VerificationType(Category2Query); } | |
141 static VerificationType category2_2nd_check() | |
142 { return VerificationType(Category2_2ndQuery); } | |
143 | |
144 // For reference types, store the actual oop* handle | |
145 static VerificationType reference_type(symbolHandle sh) { | |
146 assert(((uintptr_t)sh.raw_value() & 0x3) == 0, "Oops must be aligned"); | |
147 // If the above assert fails in the future because oop* isn't aligned, | |
148 // then this type encoding system will have to change to have a tag value | |
149 // to descriminate between oops and primitives. | |
150 return VerificationType((uintptr_t)((symbolOop*)sh.raw_value())); | |
151 } | |
152 static VerificationType reference_type(symbolOop s, TRAPS) | |
153 { return reference_type(symbolHandle(THREAD, s)); } | |
154 | |
155 static VerificationType uninitialized_type(u2 bci) | |
156 { return VerificationType(bci << 1 * BitsPerByte | Uninitialized); } | |
157 static VerificationType uninitialized_this_type() | |
158 { return uninitialized_type(BciForThis); } | |
159 | |
160 // Create based on u1 read from classfile | |
161 static VerificationType from_tag(u1 tag); | |
162 | |
163 bool is_bogus() const { return (_u._data == Bogus); } | |
164 bool is_null() const { return (_u._data == Null); } | |
165 bool is_boolean() const { return (_u._data == Boolean); } | |
166 bool is_byte() const { return (_u._data == Byte); } | |
167 bool is_char() const { return (_u._data == Char); } | |
168 bool is_short() const { return (_u._data == Short); } | |
169 bool is_integer() const { return (_u._data == Integer); } | |
170 bool is_long() const { return (_u._data == Long); } | |
171 bool is_float() const { return (_u._data == Float); } | |
172 bool is_double() const { return (_u._data == Double); } | |
173 bool is_long2() const { return (_u._data == Long_2nd); } | |
174 bool is_double2() const { return (_u._data == Double_2nd); } | |
175 bool is_reference() const { return ((_u._data & TypeMask) == Reference); } | |
176 bool is_category1() const { | |
177 // This should return true for all one-word types, which are category1 | |
178 // primitives, and references (including uninitialized refs). Though | |
179 // the 'query' types should technically return 'false' here, if we | |
180 // allow this to return true, we can perform the test using only | |
181 // 2 operations rather than 8 (3 masks, 3 compares and 2 logical 'ands'). | |
182 // Since noone should call this on a query type anyway, this is ok. | |
183 assert(!is_check(), "Must not be a check type (wrong value returned)"); | |
184 return ((_u._data & Category1) != Primitive); | |
185 // should only return false if it's a primitive, and the category1 flag | |
186 // is not set. | |
187 } | |
188 bool is_category2() const { return ((_u._data & Category2) == Category2); } | |
189 bool is_category2_2nd() const { | |
190 return ((_u._data & Category2_2nd) == Category2_2nd); | |
191 } | |
192 bool is_reference_check() const { return _u._data == ReferenceQuery; } | |
193 bool is_category1_check() const { return _u._data == Category1Query; } | |
194 bool is_category2_check() const { return _u._data == Category2Query; } | |
195 bool is_category2_2nd_check() const { return _u._data == Category2_2ndQuery; } | |
196 bool is_check() const { return (_u._data & TypeQuery) == TypeQuery; } | |
197 | |
198 bool is_x_array(char sig) const { | |
199 return is_null() || (is_array() && (name()->byte_at(1) == sig)); | |
200 } | |
201 bool is_int_array() const { return is_x_array('I'); } | |
202 bool is_byte_array() const { return is_x_array('B'); } | |
203 bool is_bool_array() const { return is_x_array('Z'); } | |
204 bool is_char_array() const { return is_x_array('C'); } | |
205 bool is_short_array() const { return is_x_array('S'); } | |
206 bool is_long_array() const { return is_x_array('J'); } | |
207 bool is_float_array() const { return is_x_array('F'); } | |
208 bool is_double_array() const { return is_x_array('D'); } | |
209 bool is_object_array() const { return is_x_array('L'); } | |
210 bool is_array_array() const { return is_x_array('['); } | |
211 bool is_reference_array() const | |
212 { return is_object_array() || is_array_array(); } | |
213 bool is_object() const | |
214 { return (is_reference() && !is_null() && name()->utf8_length() >= 1 && | |
215 name()->byte_at(0) != '['); } | |
216 bool is_array() const | |
217 { return (is_reference() && !is_null() && name()->utf8_length() >= 2 && | |
218 name()->byte_at(0) == '['); } | |
219 bool is_uninitialized() const | |
220 { return ((_u._data & Uninitialized) == Uninitialized); } | |
221 bool is_uninitialized_this() const | |
222 { return is_uninitialized() && bci() == BciForThis; } | |
223 | |
224 VerificationType to_category2_2nd() const { | |
225 assert(is_category2(), "Must be a double word"); | |
226 return VerificationType(is_long() ? Long_2nd : Double_2nd); | |
227 } | |
228 | |
229 u2 bci() const { | |
230 assert(is_uninitialized(), "Must be uninitialized type"); | |
231 return ((_u._data & BciMask) >> 1 * BitsPerByte); | |
232 } | |
233 | |
234 symbolHandle name_handle() const { | |
235 assert(is_reference() && !is_null(), "Must be a non-null reference"); | |
236 return symbolHandle(_u._handle, true); | |
237 } | |
238 symbolOop name() const { | |
239 assert(is_reference() && !is_null(), "Must be a non-null reference"); | |
240 return *(_u._handle); | |
241 } | |
242 | |
243 bool equals(const VerificationType& t) const { | |
244 return (_u._data == t._u._data || | |
245 (is_reference() && t.is_reference() && !is_null() && !t.is_null() && | |
246 name() == t.name())); | |
247 } | |
248 | |
249 bool operator ==(const VerificationType& t) const { | |
250 return equals(t); | |
251 } | |
252 | |
253 bool operator !=(const VerificationType& t) const { | |
254 return !equals(t); | |
255 } | |
256 | |
257 // The whole point of this type system - check to see if one type | |
258 // is assignable to another. Returns true if one can assign 'from' to | |
259 // this. | |
260 bool is_assignable_from( | |
261 const VerificationType& from, instanceKlassHandle context, TRAPS) const { | |
262 if (equals(from) || is_bogus()) { | |
263 return true; | |
264 } else { | |
265 switch(_u._data) { | |
266 case Category1Query: | |
267 return from.is_category1(); | |
268 case Category2Query: | |
269 return from.is_category2(); | |
270 case Category2_2ndQuery: | |
271 return from.is_category2_2nd(); | |
272 case ReferenceQuery: | |
273 return from.is_reference() || from.is_uninitialized(); | |
274 case Boolean: | |
275 case Byte: | |
276 case Char: | |
277 case Short: | |
278 // An int can be assigned to boolean, byte, char or short values. | |
279 return from.is_integer(); | |
280 default: | |
281 if (is_reference() && from.is_reference()) { | |
282 return is_reference_assignable_from(from, context, CHECK_false); | |
283 } else { | |
284 return false; | |
285 } | |
286 } | |
287 } | |
288 } | |
289 | |
290 VerificationType get_component(TRAPS) const; | |
291 | |
292 int dimensions() const { | |
293 assert(is_array(), "Must be an array"); | |
294 int index = 0; | |
295 while (name()->byte_at(index++) == '['); | |
296 return index; | |
297 } | |
298 | |
299 void print_on(outputStream* st) const PRODUCT_RETURN; | |
300 | |
301 private: | |
302 | |
303 bool is_reference_assignable_from( | |
304 const VerificationType&, instanceKlassHandle, TRAPS) const; | |
305 }; |