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