1 /* 2 * Copyright (c) 1997, 2014, 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_VM_CLASSFILE_CLASSFILEPARSER_HPP 26 #define SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP 27 28 #include "classfile/classFileStream.hpp" 29 #include "memory/resourceArea.hpp" 30 #include "oops/typeArrayOop.hpp" 31 #include "utilities/accessFlags.hpp" 32 #include "classfile/symbolTable.hpp" 33 34 class FieldAllocationCount; 35 class FieldLayoutInfo; 36 37 38 // Parser for for .class files 39 // 40 // The bytes describing the class file structure is read from a Stream object 41 42 class ClassFileParser VALUE_OBJ_CLASS_SPEC { 43 private: 44 bool _need_verify; 45 bool _relax_verify; 46 u2 _major_version; 47 u2 _minor_version; 48 Symbol* _class_name; 49 ClassLoaderData* _loader_data; 50 KlassHandle _host_klass; 51 GrowableArray<Handle>* _cp_patches; // overrides for CP entries 52 53 // precomputed flags 54 bool _has_finalizer; 55 bool _has_empty_finalizer; 56 bool _has_vanilla_constructor; 57 int _max_bootstrap_specifier_index; // detects BSS values 58 59 // class attributes parsed before the instance klass is created: 60 bool _synthetic_flag; 61 int _sde_length; 62 char* _sde_buffer; 63 u2 _sourcefile_index; 64 u2 _generic_signature_index; 65 66 // Metadata created before the instance klass is created. Must be deallocated 67 // if not transferred to the InstanceKlass upon successful class loading 68 // in which case these pointers have been set to NULL. 69 instanceKlassHandle _super_klass; 70 ConstantPool* _cp; 71 Array<u2>* _fields; 72 Array<Method*>* _methods; 73 Array<u2>* _inner_classes; 74 Array<Klass*>* _local_interfaces; 75 Array<Klass*>* _transitive_interfaces; 76 Annotations* _combined_annotations; 77 AnnotationArray* _annotations; 78 AnnotationArray* _type_annotations; 79 Array<AnnotationArray*>* _fields_annotations; 80 Array<AnnotationArray*>* _fields_type_annotations; 81 InstanceKlass* _klass; // InstanceKlass once created. 82 83 void set_class_synthetic_flag(bool x) { _synthetic_flag = x; } 84 void set_class_sourcefile_index(u2 x) { _sourcefile_index = x; } 85 void set_class_generic_signature_index(u2 x) { _generic_signature_index = x; } 86 void set_class_sde_buffer(char* x, int len) { _sde_buffer = x; _sde_length = len; } 87 88 void create_combined_annotations(TRAPS); 89 90 void init_parsed_class_attributes(ClassLoaderData* loader_data) { 91 _loader_data = loader_data; 92 _synthetic_flag = false; 93 _sourcefile_index = 0; 94 _generic_signature_index = 0; 95 _sde_buffer = NULL; 96 _sde_length = 0; 97 // initialize the other flags too: 98 _has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false; 99 _max_bootstrap_specifier_index = -1; 100 clear_class_metadata(); 101 _klass = NULL; 102 } 103 void apply_parsed_class_attributes(instanceKlassHandle k); // update k 104 void apply_parsed_class_metadata(instanceKlassHandle k, int fields_count, TRAPS); 105 void clear_class_metadata() { 106 // metadata created before the instance klass is created. Must be 107 // deallocated if classfile parsing returns an error. 108 _cp = NULL; 109 _fields = NULL; 110 _methods = NULL; 111 _inner_classes = NULL; 112 _local_interfaces = NULL; 113 _transitive_interfaces = NULL; 114 _combined_annotations = NULL; 115 _annotations = _type_annotations = NULL; 116 _fields_annotations = _fields_type_annotations = NULL; 117 } 118 119 class AnnotationCollector { 120 public: 121 enum Location { _in_field, _in_method, _in_class }; 122 enum ID { 123 _unknown = 0, 124 _method_CallerSensitive, 125 _method_ForceInline, 126 _method_DontInline, 127 _method_LambdaForm_Compiled, 128 _method_LambdaForm_Hidden, 129 _sun_misc_Contended, 130 _field_Stable, 131 _annotation_LIMIT 132 }; 133 const Location _location; 134 int _annotations_present; 135 u2 _contended_group; 136 137 AnnotationCollector(Location location) 138 : _location(location), _annotations_present(0) 139 { 140 assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, ""); 141 } 142 // If this annotation name has an ID, report it (or _none). 143 ID annotation_index(ClassLoaderData* loader_data, Symbol* name); 144 // Set the annotation name: 145 void set_annotation(ID id) { 146 assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob"); 147 _annotations_present |= nth_bit((int)id); 148 } 149 150 void remove_annotation(ID id) { 151 assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob"); 152 _annotations_present &= ~nth_bit((int)id); 153 } 154 155 // Report if the annotation is present. 156 bool has_any_annotations() const { return _annotations_present != 0; } 157 bool has_annotation(ID id) const { return (nth_bit((int)id) & _annotations_present) != 0; } 158 159 void set_contended_group(u2 group) { _contended_group = group; } 160 u2 contended_group() const { return _contended_group; } 161 162 bool is_contended() const { return has_annotation(_sun_misc_Contended); } 163 164 void set_stable(bool stable) { set_annotation(_field_Stable); } 165 bool is_stable() const { return has_annotation(_field_Stable); } 166 }; 167 168 // This class also doubles as a holder for metadata cleanup. 169 class FieldAnnotationCollector: public AnnotationCollector { 170 ClassLoaderData* _loader_data; 171 AnnotationArray* _field_annotations; 172 AnnotationArray* _field_type_annotations; 173 public: 174 FieldAnnotationCollector(ClassLoaderData* loader_data) : 175 AnnotationCollector(_in_field), 176 _loader_data(loader_data), 177 _field_annotations(NULL), 178 _field_type_annotations(NULL) {} 179 void apply_to(FieldInfo* f); 180 ~FieldAnnotationCollector(); 181 AnnotationArray* field_annotations() { return _field_annotations; } 182 AnnotationArray* field_type_annotations() { return _field_type_annotations; } 183 184 void set_field_annotations(AnnotationArray* a) { _field_annotations = a; } 185 void set_field_type_annotations(AnnotationArray* a) { _field_type_annotations = a; } 186 }; 187 188 class MethodAnnotationCollector: public AnnotationCollector { 189 public: 190 MethodAnnotationCollector() : AnnotationCollector(_in_method) { } 191 void apply_to(methodHandle m); 192 }; 193 class ClassAnnotationCollector: public AnnotationCollector { 194 public: 195 ClassAnnotationCollector() : AnnotationCollector(_in_class) { } 196 void apply_to(instanceKlassHandle k); 197 }; 198 199 enum { fixed_buffer_size = 128 }; 200 u_char linenumbertable_buffer[fixed_buffer_size]; 201 202 ClassFileStream* _stream; // Actual input stream 203 204 enum { LegalClass, LegalField, LegalMethod }; // used to verify unqualified names 205 206 // Accessors 207 ClassFileStream* stream() { return _stream; } 208 void set_stream(ClassFileStream* st) { _stream = st; } 209 210 // Constant pool parsing 211 void parse_constant_pool_entries(int length, TRAPS); 212 213 constantPoolHandle parse_constant_pool(TRAPS); 214 215 // Interface parsing 216 Array<Klass*>* parse_interfaces(int length, 217 Handle protection_domain, 218 Symbol* class_name, 219 bool* has_default_methods, 220 TRAPS); 221 void record_defined_class_dependencies(instanceKlassHandle defined_klass, TRAPS); 222 223 instanceKlassHandle parse_super_class(int super_class_index, TRAPS); 224 // Field parsing 225 void parse_field_attributes(u2 attributes_count, 226 bool is_static, u2 signature_index, 227 u2* constantvalue_index_addr, 228 bool* is_synthetic_addr, 229 u2* generic_signature_index_addr, 230 FieldAnnotationCollector* parsed_annotations, 231 TRAPS); 232 Array<u2>* parse_fields(Symbol* class_name, 233 bool is_interface, 234 FieldAllocationCount *fac, 235 u2* java_fields_count_ptr, TRAPS); 236 237 void print_field_layout(Symbol* name, 238 Array<u2>* fields, 239 constantPoolHandle cp, 240 int instance_size, 241 int instance_fields_start, 242 int instance_fields_end, 243 int static_fields_end); 244 245 // Method parsing 246 methodHandle parse_method(bool is_interface, 247 AccessFlags* promoted_flags, 248 TRAPS); 249 Array<Method*>* parse_methods(bool is_interface, 250 AccessFlags* promoted_flags, 251 bool* has_final_method, 252 bool* declares_default_methods, 253 TRAPS); 254 intArray* sort_methods(Array<Method*>* methods); 255 256 u2* parse_exception_table(u4 code_length, u4 exception_table_length, 257 TRAPS); 258 void parse_linenumber_table( 259 u4 code_attribute_length, u4 code_length, 260 CompressedLineNumberWriteStream** write_stream, TRAPS); 261 u2* parse_localvariable_table(u4 code_length, u2 max_locals, u4 code_attribute_length, 262 u2* localvariable_table_length, 263 bool isLVTT, TRAPS); 264 u2* parse_checked_exceptions(u2* checked_exceptions_length, u4 method_attribute_length, 265 TRAPS); 266 void parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index, 267 u1* u1_array, u2* u2_array, TRAPS); 268 u1* parse_stackmap_table(u4 code_attribute_length, TRAPS); 269 270 // Classfile attribute parsing 271 u2 parse_generic_signature_attribute(TRAPS); 272 void parse_classfile_sourcefile_attribute(TRAPS); 273 void parse_classfile_source_debug_extension_attribute(int length, TRAPS); 274 u2 parse_classfile_inner_classes_attribute(u1* inner_classes_attribute_start, 275 bool parsed_enclosingmethod_attribute, 276 u2 enclosing_method_class_index, 277 u2 enclosing_method_method_index, 278 TRAPS); 279 void parse_classfile_attributes(ClassAnnotationCollector* parsed_annotations, 280 TRAPS); 281 void parse_classfile_synthetic_attribute(TRAPS); 282 void parse_classfile_signature_attribute(TRAPS); 283 void parse_classfile_bootstrap_methods_attribute(u4 attribute_length, TRAPS); 284 285 // Annotations handling 286 AnnotationArray* assemble_annotations(u1* runtime_visible_annotations, 287 int runtime_visible_annotations_length, 288 u1* runtime_invisible_annotations, 289 int runtime_invisible_annotations_length, TRAPS); 290 int skip_annotation(u1* buffer, int limit, int index); 291 int skip_annotation_value(u1* buffer, int limit, int index); 292 void parse_annotations(u1* buffer, int limit, 293 /* Results (currently, only one result is supported): */ 294 AnnotationCollector* result, 295 TRAPS); 296 297 // Final setup 298 unsigned int compute_oop_map_count(instanceKlassHandle super, 299 unsigned int nonstatic_oop_count, 300 int first_nonstatic_oop_offset); 301 void fill_oop_maps(instanceKlassHandle k, 302 unsigned int nonstatic_oop_map_count, 303 int* nonstatic_oop_offsets, 304 unsigned int* nonstatic_oop_counts); 305 void set_precomputed_flags(instanceKlassHandle k); 306 Array<Klass*>* compute_transitive_interfaces(instanceKlassHandle super, 307 Array<Klass*>* local_ifs, TRAPS); 308 309 // Format checker methods 310 void classfile_parse_error(const char* msg, TRAPS); 311 void classfile_parse_error(const char* msg, int index, TRAPS); 312 void classfile_parse_error(const char* msg, const char *name, TRAPS); 313 void classfile_parse_error(const char* msg, int index, const char *name, TRAPS); 314 inline void guarantee_property(bool b, const char* msg, TRAPS) { 315 if (!b) { classfile_parse_error(msg, CHECK); } 316 } 317 318 PRAGMA_DIAG_PUSH 319 PRAGMA_FORMAT_NONLITERAL_IGNORED 320 inline void assert_property(bool b, const char* msg, TRAPS) { 321 #ifdef ASSERT 322 if (!b) { 323 ResourceMark rm(THREAD); 324 fatal(err_msg(msg, _class_name->as_C_string())); 325 } 326 #endif 327 } 328 329 inline void assert_property(bool b, const char* msg, int index, TRAPS) { 330 #ifdef ASSERT 331 if (!b) { 332 ResourceMark rm(THREAD); 333 fatal(err_msg(msg, index, _class_name->as_C_string())); 334 } 335 #endif 336 } 337 PRAGMA_DIAG_POP 338 339 inline void check_property(bool property, const char* msg, int index, TRAPS) { 340 if (_need_verify) { 341 guarantee_property(property, msg, index, CHECK); 342 } else { 343 assert_property(property, msg, index, CHECK); 344 } 345 } 346 347 inline void check_property(bool property, const char* msg, TRAPS) { 348 if (_need_verify) { 349 guarantee_property(property, msg, CHECK); 350 } else { 351 assert_property(property, msg, CHECK); 352 } 353 } 354 355 inline void guarantee_property(bool b, const char* msg, int index, TRAPS) { 356 if (!b) { classfile_parse_error(msg, index, CHECK); } 357 } 358 inline void guarantee_property(bool b, const char* msg, const char *name, TRAPS) { 359 if (!b) { classfile_parse_error(msg, name, CHECK); } 360 } 361 inline void guarantee_property(bool b, const char* msg, int index, const char *name, TRAPS) { 362 if (!b) { classfile_parse_error(msg, index, name, CHECK); } 363 } 364 365 void throwIllegalSignature( 366 const char* type, Symbol* name, Symbol* sig, TRAPS); 367 368 bool is_supported_version(u2 major, u2 minor); 369 bool has_illegal_visibility(jint flags); 370 371 void verify_constantvalue(int constantvalue_index, int signature_index, TRAPS); 372 void verify_legal_utf8(const unsigned char* buffer, int length, TRAPS); 373 void verify_legal_class_name(Symbol* name, TRAPS); 374 void verify_legal_field_name(Symbol* name, TRAPS); 375 void verify_legal_method_name(Symbol* name, TRAPS); 376 void verify_legal_field_signature(Symbol* fieldname, Symbol* signature, TRAPS); 377 int verify_legal_method_signature(Symbol* methodname, Symbol* signature, TRAPS); 378 void verify_legal_class_modifiers(jint flags, TRAPS); 379 void verify_legal_field_modifiers(jint flags, bool is_interface, TRAPS); 380 void verify_legal_method_modifiers(jint flags, bool is_interface, Symbol* name, TRAPS); 381 bool verify_unqualified_name(char* name, unsigned int length, int type); 382 char* skip_over_field_name(char* name, bool slash_ok, unsigned int length); 383 char* skip_over_field_signature(char* signature, bool void_ok, unsigned int length, TRAPS); 384 385 bool is_anonymous() { 386 return _host_klass.not_null(); 387 } 388 bool has_cp_patch_at(int index) { 389 assert(index >= 0, "oob"); 390 return (_cp_patches != NULL 391 && index < _cp_patches->length() 392 && _cp_patches->adr_at(index)->not_null()); 393 } 394 Handle cp_patch_at(int index) { 395 assert(has_cp_patch_at(index), "oob"); 396 return _cp_patches->at(index); 397 } 398 Handle clear_cp_patch_at(int index) { 399 Handle patch = cp_patch_at(index); 400 _cp_patches->at_put(index, Handle()); 401 assert(!has_cp_patch_at(index), ""); 402 return patch; 403 } 404 void patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS); 405 406 // Wrapper for constantTag.is_klass_[or_]reference. 407 // In older versions of the VM, Klass*s cannot sneak into early phases of 408 // constant pool construction, but in later versions they can. 409 // %%% Let's phase out the old is_klass_reference. 410 bool valid_klass_reference_at(int index) { 411 return _cp->is_within_bounds(index) && _cp->tag_at(index).is_klass_or_reference(); 412 } 413 414 // Checks that the cpool index is in range and is a utf8 415 bool valid_symbol_at(int cpool_index) { 416 return (_cp->is_within_bounds(cpool_index) && 417 _cp->tag_at(cpool_index).is_utf8()); 418 } 419 420 void copy_localvariable_table(ConstMethod* cm, int lvt_cnt, 421 u2* localvariable_table_length, 422 u2** localvariable_table_start, 423 int lvtt_cnt, 424 u2* localvariable_type_table_length, 425 u2** localvariable_type_table_start, 426 TRAPS); 427 428 void copy_method_annotations(ConstMethod* cm, 429 u1* runtime_visible_annotations, 430 int runtime_visible_annotations_length, 431 u1* runtime_invisible_annotations, 432 int runtime_invisible_annotations_length, 433 u1* runtime_visible_parameter_annotations, 434 int runtime_visible_parameter_annotations_length, 435 u1* runtime_invisible_parameter_annotations, 436 int runtime_invisible_parameter_annotations_length, 437 u1* runtime_visible_type_annotations, 438 int runtime_visible_type_annotations_length, 439 u1* runtime_invisible_type_annotations, 440 int runtime_invisible_type_annotations_length, 441 u1* annotation_default, 442 int annotation_default_length, 443 TRAPS); 444 445 // lays out fields in class and returns the total oopmap count 446 void layout_fields(Handle class_loader, FieldAllocationCount* fac, 447 ClassAnnotationCollector* parsed_annotations, 448 FieldLayoutInfo* info, TRAPS); 449 450 public: 451 // Constructor 452 ClassFileParser(ClassFileStream* st) { set_stream(st); } 453 ~ClassFileParser(); 454 455 // Parse .class file and return new Klass*. The Klass* is not hooked up 456 // to the system dictionary or any other structures, so a .class file can 457 // be loaded several times if desired. 458 // The system dictionary hookup is done by the caller. 459 // 460 // "parsed_name" is updated by this method, and is the name found 461 // while parsing the stream. 462 instanceKlassHandle parseClassFile(Symbol* name, 463 ClassLoaderData* loader_data, 464 Handle protection_domain, 465 TempNewSymbol& parsed_name, 466 bool verify, 467 TRAPS) { 468 KlassHandle no_host_klass; 469 return parseClassFile(name, loader_data, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD); 470 } 471 instanceKlassHandle parseClassFile(Symbol* name, 472 ClassLoaderData* loader_data, 473 Handle protection_domain, 474 KlassHandle host_klass, 475 GrowableArray<Handle>* cp_patches, 476 TempNewSymbol& parsed_name, 477 bool verify, 478 TRAPS); 479 480 // Verifier checks 481 static void check_super_class_access(instanceKlassHandle this_klass, TRAPS); 482 static void check_super_interface_access(instanceKlassHandle this_klass, TRAPS); 483 static void check_final_method_override(instanceKlassHandle this_klass, TRAPS); 484 static void check_illegal_static_method(instanceKlassHandle this_klass, TRAPS); 485 }; 486 487 #endif // SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP