1 /* 2 * Copyright (c) 2003, 2023, 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 #ifndef SHARE_CLASSFILE_VERIFICATIONTYPE_HPP 26 #define SHARE_CLASSFILE_VERIFICATIONTYPE_HPP 27 28 #include "oops/instanceKlass.hpp" 29 #include "oops/oop.hpp" 30 #include "oops/symbol.hpp" 31 #include "runtime/handles.hpp" 32 #include "runtime/signature.hpp" 33 34 enum : uint { 35 // As specified in the JVM spec 36 ITEM_Top = 0, 37 ITEM_Integer = 1, 38 ITEM_Float = 2, 39 ITEM_Double = 3, 40 ITEM_Long = 4, 41 ITEM_Null = 5, 42 ITEM_UninitializedThis = 6, 43 ITEM_Object = 7, 44 ITEM_Uninitialized = 8, 45 ITEM_Bogus = (uint)-1 46 }; 47 48 class ClassVerifier; 49 50 class VerificationType { 51 private: 52 // Least significant bits of _handle are always 0, so we use these as 53 // the indicator that the _handle is valid. Otherwise, the _data field 54 // contains encoded data (as specified below). Should the VM change 55 // and the lower bits on oops aren't 0, the assert in the constructor 56 // will catch this and we'll have to add a descriminator tag to this 57 // structure. 58 union { 59 Symbol* _sym; 60 uintptr_t _data; 61 } _u; 62 63 enum { 64 // These rest are not found in classfiles, but used by the verifier 65 ITEM_Boolean = 9, ITEM_Byte, ITEM_Short, ITEM_Char, 66 ITEM_Long_2nd, ITEM_Double_2nd 67 }; 68 69 // Enum for the _data field 70 enum : uint { 71 // Bottom three bits determine if the type is a reference, inline type, 72 // primitive, uninitialized or a query-type. 73 TypeMask = 0x00000007, 74 75 // Topmost types encoding 76 Reference = 0x0, // _sym contains the name of an object 77 Primitive = 0x1, // see below for primitive list 78 Uninitialized = 0x2, // 0x00ffff00 contains bci 79 TypeQuery = 0x3, // Meta-types used for category testing 80 InlineType = 0x4, // _sym contains the name of an inline type 81 82 // Utility flags 83 ReferenceFlag = 0x00, // For reference query types 84 Category1Flag = 0x01, // One-word values 85 Category2Flag = 0x02, // First word of a two-word value 86 Category2_2ndFlag = 0x04, // Second word of a two-word value 87 InlineTypeFlag = 0x08, // For inline type query types 88 NonScalarFlag = 0x10, // For either inline type or reference queries 89 90 // special reference values 91 Null = 0x00000000, // A reference with a 0 sym is null 92 93 // Primitives categories (the second byte determines the category) 94 Category1 = (Category1Flag << 1 * BitsPerByte) | Primitive, 95 Category2 = (Category2Flag << 1 * BitsPerByte) | Primitive, 96 Category2_2nd = (Category2_2ndFlag << 1 * BitsPerByte) | Primitive, 97 98 // Primitive values (type descriminator stored in most-signifcant bytes) 99 // Bogus needs the " | Primitive". Else, is_reference(Bogus) returns TRUE. 100 Bogus = (ITEM_Bogus << 2 * BitsPerByte) | Primitive, 101 Boolean = (ITEM_Boolean << 2 * BitsPerByte) | Category1, 102 Byte = (ITEM_Byte << 2 * BitsPerByte) | Category1, 103 Short = (ITEM_Short << 2 * BitsPerByte) | Category1, 104 Char = (ITEM_Char << 2 * BitsPerByte) | Category1, 105 Integer = (ITEM_Integer << 2 * BitsPerByte) | Category1, 106 Float = (ITEM_Float << 2 * BitsPerByte) | Category1, 107 Long = (ITEM_Long << 2 * BitsPerByte) | Category2, 108 Double = (ITEM_Double << 2 * BitsPerByte) | Category2, 109 Long_2nd = (ITEM_Long_2nd << 2 * BitsPerByte) | Category2_2nd, 110 Double_2nd = (ITEM_Double_2nd << 2 * BitsPerByte) | Category2_2nd, 111 112 // Used by Uninitialized (second and third bytes hold the bci) 113 BciMask = 0xffff << 1 * BitsPerByte, 114 BciForThis = ((u2)-1), // A bci of -1 is an Unintialized-This 115 116 // Query values 117 ReferenceQuery = (ReferenceFlag << 1 * BitsPerByte) | TypeQuery, 118 Category1Query = (Category1Flag << 1 * BitsPerByte) | TypeQuery, 119 Category2Query = (Category2Flag << 1 * BitsPerByte) | TypeQuery, 120 Category2_2ndQuery = (Category2_2ndFlag << 1 * BitsPerByte) | TypeQuery, 121 InlineTypeQuery = (InlineTypeFlag << 1 * BitsPerByte) | TypeQuery, 122 NonScalarQuery = (NonScalarFlag << 1 * BitsPerByte) | TypeQuery 123 }; 124 125 VerificationType(uintptr_t raw_data) { 126 _u._data = raw_data; 127 } 128 129 public: 130 131 VerificationType() { *this = bogus_type(); } 132 133 // Create verification types 134 static VerificationType bogus_type() { return VerificationType(Bogus); } 135 static VerificationType top_type() { return bogus_type(); } // alias 136 static VerificationType null_type() { return VerificationType(Null); } 137 static VerificationType integer_type() { return VerificationType(Integer); } 138 static VerificationType float_type() { return VerificationType(Float); } 139 static VerificationType long_type() { return VerificationType(Long); } 140 static VerificationType long2_type() { return VerificationType(Long_2nd); } 141 static VerificationType double_type() { return VerificationType(Double); } 142 static VerificationType boolean_type() { return VerificationType(Boolean); } 143 static VerificationType byte_type() { return VerificationType(Byte); } 144 static VerificationType char_type() { return VerificationType(Char); } 145 static VerificationType short_type() { return VerificationType(Short); } 146 static VerificationType double2_type() 147 { return VerificationType(Double_2nd); } 148 149 // "check" types are used for queries. A "check" type is not assignable 150 // to anything, but the specified types are assignable to a "check". For 151 // example, any category1 primitive is assignable to category1_check and 152 // any reference is assignable to reference_check. 153 static VerificationType reference_check() 154 { return VerificationType(ReferenceQuery); } 155 static VerificationType inline_type_check() 156 { return VerificationType(InlineTypeQuery); } 157 static VerificationType category1_check() 158 { return VerificationType(Category1Query); } 159 static VerificationType category2_check() 160 { return VerificationType(Category2Query); } 161 static VerificationType category2_2nd_check() 162 { return VerificationType(Category2_2ndQuery); } 163 static VerificationType nonscalar_check() 164 { return VerificationType(NonScalarQuery); } 165 166 // For reference types, store the actual Symbol 167 static VerificationType reference_type(Symbol* sh) { 168 assert(((uintptr_t)sh & TypeMask) == 0, "Symbols must be aligned"); 169 // If the above assert fails in the future because oop* isn't aligned, 170 // then this type encoding system will have to change to have a tag value 171 // to discriminate between oops and primitives. 172 return VerificationType((uintptr_t)sh); 173 } 174 static VerificationType uninitialized_type(u2 bci) 175 { return VerificationType(bci << 1 * BitsPerByte | Uninitialized); } 176 static VerificationType uninitialized_this_type() 177 { return uninitialized_type(BciForThis); } 178 179 // For inline types, store the actual Symbol* and set the 3rd bit. 180 // Provides a way for an inline type to be distinguished from a reference type. 181 static VerificationType inline_type(Symbol* sh) { 182 assert(((uintptr_t)sh & TypeMask) == 0, "Symbols must be aligned"); 183 assert((uintptr_t)sh != 0, "Null is not a valid inline type"); 184 // If the above assert fails in the future because oop* isn't aligned, 185 // then this type encoding system will have to change to have a tag value 186 // to discriminate between oops and primitives. 187 return VerificationType((uintptr_t)sh | InlineType); 188 } 189 190 // Create based on u1 read from classfile 191 static VerificationType from_tag(u1 tag); 192 193 bool is_bogus() const { return (_u._data == Bogus); } 194 bool is_null() const { return (_u._data == Null); } 195 bool is_boolean() const { return (_u._data == Boolean); } 196 bool is_byte() const { return (_u._data == Byte); } 197 bool is_char() const { return (_u._data == Char); } 198 bool is_short() const { return (_u._data == Short); } 199 bool is_integer() const { return (_u._data == Integer); } 200 bool is_long() const { return (_u._data == Long); } 201 bool is_float() const { return (_u._data == Float); } 202 bool is_double() const { return (_u._data == Double); } 203 bool is_long2() const { return (_u._data == Long_2nd); } 204 bool is_double2() const { return (_u._data == Double_2nd); } 205 bool is_reference() const { return (((_u._data & TypeMask) == Reference) && !is_inline_type_check()); } 206 bool is_inline_type() const { return ((_u._data & TypeMask) == InlineType); } 207 bool is_category1() const { 208 // This should return true for all one-word types, which are category1 209 // primitives, references (including uninitialized refs) and inline types. 210 // Though the 'query' types should technically return 'false' here, if we 211 // allow this to return true, we can perform the test using only 212 // 2 operations rather than 8 (3 masks, 3 compares and 2 logical 'ands'). 213 // Since no one should call this on a query type anyway, this is ok. 214 assert(!is_check(), "Must not be a check type (wrong value returned)"); 215 return ((_u._data & Category1) != Primitive); 216 // should only return false if it's a primitive, and the category1 flag 217 // is not set. 218 } 219 bool is_category2() const { return ((_u._data & Category2) == Category2); } 220 bool is_category2_2nd() const { 221 return ((_u._data & Category2_2nd) == Category2_2nd); 222 } 223 bool is_reference_check() const { return _u._data == ReferenceQuery; } 224 bool is_inline_type_check() const { return _u._data == InlineTypeQuery; } 225 bool is_nonscalar_check() const { return _u._data == NonScalarQuery; } 226 bool is_category1_check() const { return _u._data == Category1Query; } 227 bool is_category2_check() const { return _u._data == Category2Query; } 228 bool is_category2_2nd_check() const { return _u._data == Category2_2ndQuery; } 229 bool is_check() const { return (_u._data & TypeQuery) == TypeQuery; } 230 231 bool is_x_array(char sig) const { 232 return is_null() || (is_array() && (name()->char_at(1) == sig)); 233 } 234 bool is_int_array() const { return is_x_array(JVM_SIGNATURE_INT); } 235 bool is_byte_array() const { return is_x_array(JVM_SIGNATURE_BYTE); } 236 bool is_bool_array() const { return is_x_array(JVM_SIGNATURE_BOOLEAN); } 237 bool is_char_array() const { return is_x_array(JVM_SIGNATURE_CHAR); } 238 bool is_short_array() const { return is_x_array(JVM_SIGNATURE_SHORT); } 239 bool is_long_array() const { return is_x_array(JVM_SIGNATURE_LONG); } 240 bool is_float_array() const { return is_x_array(JVM_SIGNATURE_FLOAT); } 241 bool is_double_array() const { return is_x_array(JVM_SIGNATURE_DOUBLE); } 242 bool is_object_array() const { return is_x_array(JVM_SIGNATURE_CLASS); } 243 bool is_array_array() const { return is_x_array(JVM_SIGNATURE_ARRAY); } 244 bool is_inline_type_array() const { return is_x_array(JVM_SIGNATURE_PRIMITIVE_OBJECT); } 245 bool is_reference_array() const 246 { return is_object_array() || is_array_array(); } 247 bool is_nonscalar_array() const 248 { return is_object_array() || is_array_array() || is_inline_type_array(); } 249 bool is_object() const 250 { return (is_reference() && !is_null() && name()->utf8_length() >= 1 && 251 name()->char_at(0) != JVM_SIGNATURE_ARRAY); } 252 bool is_array() const 253 { return (is_reference() && !is_null() && name()->utf8_length() >= 2 && 254 name()->char_at(0) == JVM_SIGNATURE_ARRAY); } 255 bool is_uninitialized() const 256 { return ((_u._data & Uninitialized) == Uninitialized); } 257 bool is_uninitialized_this() const 258 { return is_uninitialized() && bci() == BciForThis; } 259 260 VerificationType to_category2_2nd() const { 261 assert(is_category2(), "Must be a double word"); 262 return VerificationType(is_long() ? Long_2nd : Double_2nd); 263 } 264 265 static VerificationType change_ref_to_inline_type(VerificationType ref) { 266 assert(ref.is_reference(), "Bad arg"); 267 assert(!ref.is_null(), "Unexpected nullptr"); 268 return inline_type(ref.name()); 269 } 270 271 u2 bci() const { 272 assert(is_uninitialized(), "Must be uninitialized type"); 273 return ((_u._data & BciMask) >> 1 * BitsPerByte); 274 } 275 276 Symbol* name() const { 277 assert(!is_null() && (is_reference() || is_inline_type()), "Must be a non-null reference or an inline type"); 278 return (is_reference() ? _u._sym : ((Symbol*)(_u._data & ~(uintptr_t)InlineType))); 279 } 280 281 bool equals(const VerificationType& t) const { 282 return (_u._data == t._u._data || 283 (((is_reference() && t.is_reference()) || 284 (is_inline_type() && t.is_inline_type())) && 285 !is_null() && !t.is_null() && name() == t.name())); 286 287 } 288 289 bool operator ==(const VerificationType& t) const { 290 return equals(t); 291 } 292 293 bool operator !=(const VerificationType& t) const { 294 return !equals(t); 295 } 296 297 // The whole point of this type system - check to see if one type 298 // is assignable to another. Returns true if one can assign 'from' to 299 // this. 300 bool is_assignable_from( 301 const VerificationType& from, ClassVerifier* context, 302 bool from_field_is_protected, TRAPS) const { 303 if (equals(from) || is_bogus()) { 304 return true; 305 } else { 306 switch(_u._data) { 307 case Category1Query: 308 return from.is_category1(); 309 case Category2Query: 310 return from.is_category2(); 311 case Category2_2ndQuery: 312 return from.is_category2_2nd(); 313 case ReferenceQuery: 314 return from.is_reference() || from.is_uninitialized(); 315 case NonScalarQuery: 316 return from.is_reference() || from.is_uninitialized() || 317 from.is_inline_type(); 318 case InlineTypeQuery: 319 return from.is_inline_type(); 320 case Boolean: 321 case Byte: 322 case Char: 323 case Short: 324 // An int can be assigned to boolean, byte, char or short values. 325 return from.is_integer(); 326 default: 327 if (is_inline_type()) { 328 return is_inline_type_assignable_from(from); 329 } else if (is_reference() && from.is_inline_type()) { 330 return is_ref_assignable_from_inline_type(from, context, THREAD); 331 } else if (is_reference() && from.is_reference()) { 332 return is_reference_assignable_from(from, context, 333 from_field_is_protected, 334 THREAD); 335 } else { 336 return false; 337 } 338 } 339 } 340 } 341 342 // Check to see if one array component type is assignable to another. 343 // Same as is_assignable_from() except int primitives must be identical. 344 bool is_component_assignable_from( 345 const VerificationType& from, ClassVerifier* context, 346 bool from_field_is_protected, TRAPS) const { 347 if (equals(from) || is_bogus()) { 348 return true; 349 } else { 350 switch(_u._data) { 351 case Boolean: 352 case Byte: 353 case Char: 354 case Short: 355 return false; 356 default: 357 return is_assignable_from(from, context, from_field_is_protected, THREAD); 358 } 359 } 360 } 361 362 VerificationType get_component(ClassVerifier* context) const; 363 364 int dimensions() const { 365 assert(is_array(), "Must be an array"); 366 int index = 0; 367 while (name()->char_at(index) == JVM_SIGNATURE_ARRAY) index++; 368 return index; 369 } 370 371 void print_on(outputStream* st) const; 372 373 private: 374 375 bool is_reference_assignable_from( 376 const VerificationType&, ClassVerifier*, bool from_field_is_protected, 377 TRAPS) const; 378 379 bool is_inline_type_assignable_from(const VerificationType& from) const; 380 381 bool is_ref_assignable_from_inline_type(const VerificationType& from, ClassVerifier* context, TRAPS) const; 382 383 384 public: 385 static bool resolve_and_check_assignability(InstanceKlass* klass, Symbol* name, 386 Symbol* from_name, bool from_field_is_protected, 387 bool from_is_array, bool from_is_object, 388 TRAPS); 389 }; 390 391 #endif // SHARE_CLASSFILE_VERIFICATIONTYPE_HPP