Mercurial > hg > truffle
annotate src/share/vm/classfile/classFileParser.hpp @ 4181:319860ae697a
Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.
| author | Christian Wimmer <Christian.Wimmer@Oracle.com> |
|---|---|
| date | Mon, 02 Jan 2012 14:16:08 -0800 |
| parents | e6b1331a51d2 |
| children | cd5d8cafcc84 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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:
974
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
974
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:
974
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 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/oop.inline.hpp" | |
| 31 #include "oops/typeArrayOop.hpp" | |
| 32 #include "runtime/handles.inline.hpp" | |
| 33 #include "utilities/accessFlags.hpp" | |
| 34 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
35 class TempNewSymbol; |
| 3938 | 36 class FieldAllocationCount; |
| 37 | |
| 38 | |
| 0 | 39 // Parser for for .class files |
| 40 // | |
| 41 // The bytes describing the class file structure is read from a Stream object | |
| 42 | |
| 43 class ClassFileParser VALUE_OBJ_CLASS_SPEC { | |
| 44 private: | |
| 45 bool _need_verify; | |
| 46 bool _relax_verify; | |
| 47 u2 _major_version; | |
| 48 u2 _minor_version; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
49 Symbol* _class_name; |
| 710 | 50 KlassHandle _host_klass; |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
51 GrowableArray<Handle>* _cp_patches; // overrides for CP entries |
| 0 | 52 |
| 53 bool _has_finalizer; | |
| 54 bool _has_empty_finalizer; | |
| 55 bool _has_vanilla_constructor; | |
| 56 | |
|
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
57 int _max_bootstrap_specifier_index; |
|
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
58 |
| 0 | 59 enum { fixed_buffer_size = 128 }; |
| 60 u_char linenumbertable_buffer[fixed_buffer_size]; | |
| 61 | |
| 62 ClassFileStream* _stream; // Actual input stream | |
| 63 | |
| 64 enum { LegalClass, LegalField, LegalMethod }; // used to verify unqualified names | |
| 65 | |
| 66 // Accessors | |
| 67 ClassFileStream* stream() { return _stream; } | |
| 68 void set_stream(ClassFileStream* st) { _stream = st; } | |
| 69 | |
| 70 // Constant pool parsing | |
| 71 void parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS); | |
| 72 | |
| 73 constantPoolHandle parse_constant_pool(TRAPS); | |
| 74 | |
| 75 // Interface parsing | |
| 76 objArrayHandle parse_interfaces(constantPoolHandle cp, | |
| 77 int length, | |
| 78 Handle class_loader, | |
| 79 Handle protection_domain, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
80 Symbol* class_name, |
| 0 | 81 TRAPS); |
| 82 | |
| 83 // Field parsing | |
| 84 void parse_field_attributes(constantPoolHandle cp, u2 attributes_count, | |
| 85 bool is_static, u2 signature_index, | |
| 86 u2* constantvalue_index_addr, | |
| 87 bool* is_synthetic_addr, | |
| 88 u2* generic_signature_index_addr, | |
| 89 typeArrayHandle* field_annotations, TRAPS); | |
| 3938 | 90 typeArrayHandle parse_fields(Symbol* class_name, |
| 91 constantPoolHandle cp, bool is_interface, | |
| 92 FieldAllocationCount *fac, | |
| 93 objArrayHandle* fields_annotations, | |
| 94 int* java_fields_count_ptr, TRAPS); | |
| 0 | 95 |
| 96 // Method parsing | |
| 97 methodHandle parse_method(constantPoolHandle cp, bool is_interface, | |
| 98 AccessFlags* promoted_flags, | |
| 99 typeArrayHandle* method_annotations, | |
| 100 typeArrayHandle* method_parameter_annotations, | |
| 101 typeArrayHandle* method_default_annotations, | |
| 102 TRAPS); | |
| 103 objArrayHandle parse_methods (constantPoolHandle cp, bool is_interface, | |
| 104 AccessFlags* promoted_flags, | |
| 105 bool* has_final_method, | |
| 106 objArrayOop* methods_annotations_oop, | |
| 107 objArrayOop* methods_parameter_annotations_oop, | |
| 108 objArrayOop* methods_default_annotations_oop, | |
| 109 TRAPS); | |
| 110 typeArrayHandle sort_methods (objArrayHandle methods, | |
| 111 objArrayHandle methods_annotations, | |
| 112 objArrayHandle methods_parameter_annotations, | |
| 113 objArrayHandle methods_default_annotations, | |
| 114 TRAPS); | |
| 115 typeArrayHandle parse_exception_table(u4 code_length, u4 exception_table_length, | |
| 116 constantPoolHandle cp, TRAPS); | |
| 117 void parse_linenumber_table( | |
| 118 u4 code_attribute_length, u4 code_length, | |
| 119 CompressedLineNumberWriteStream** write_stream, TRAPS); | |
| 120 u2* parse_localvariable_table(u4 code_length, u2 max_locals, u4 code_attribute_length, | |
| 121 constantPoolHandle cp, u2* localvariable_table_length, | |
| 122 bool isLVTT, TRAPS); | |
| 123 u2* parse_checked_exceptions(u2* checked_exceptions_length, u4 method_attribute_length, | |
| 124 constantPoolHandle cp, TRAPS); | |
| 125 void parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index, | |
| 126 u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS); | |
| 127 typeArrayOop parse_stackmap_table(u4 code_attribute_length, TRAPS); | |
| 128 | |
| 129 // Classfile attribute parsing | |
| 130 void parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS); | |
| 131 void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp, | |
| 132 instanceKlassHandle k, int length, TRAPS); | |
| 133 u2 parse_classfile_inner_classes_attribute(constantPoolHandle cp, | |
| 134 instanceKlassHandle k, TRAPS); | |
| 135 void parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS); | |
| 136 void parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS); | |
| 137 void parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS); | |
|
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
138 void parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, instanceKlassHandle k, u4 attribute_length, TRAPS); |
| 0 | 139 |
| 140 // Annotations handling | |
| 141 typeArrayHandle assemble_annotations(u1* runtime_visible_annotations, | |
| 142 int runtime_visible_annotations_length, | |
| 143 u1* runtime_invisible_annotations, | |
| 144 int runtime_invisible_annotations_length, TRAPS); | |
| 145 | |
| 146 // Final setup | |
|
939
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
147 unsigned int compute_oop_map_count(instanceKlassHandle super, |
|
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
148 unsigned int nonstatic_oop_count, |
|
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
149 int first_nonstatic_oop_offset); |
|
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
150 void fill_oop_maps(instanceKlassHandle k, |
|
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
151 unsigned int nonstatic_oop_map_count, |
|
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
152 int* nonstatic_oop_offsets, |
|
9eebd3ac74cf
6845368: large objects cause a crash or unexpected exception
jcoomes
parents:
938
diff
changeset
|
153 unsigned int* nonstatic_oop_counts); |
| 0 | 154 void set_precomputed_flags(instanceKlassHandle k); |
| 155 objArrayHandle compute_transitive_interfaces(instanceKlassHandle super, | |
| 156 objArrayHandle local_ifs, TRAPS); | |
| 157 | |
| 158 // Format checker methods | |
| 159 void classfile_parse_error(const char* msg, TRAPS); | |
| 160 void classfile_parse_error(const char* msg, int index, TRAPS); | |
| 161 void classfile_parse_error(const char* msg, const char *name, TRAPS); | |
| 162 void classfile_parse_error(const char* msg, int index, const char *name, TRAPS); | |
| 163 inline void guarantee_property(bool b, const char* msg, TRAPS) { | |
| 164 if (!b) { classfile_parse_error(msg, CHECK); } | |
| 165 } | |
| 166 | |
| 167 inline void assert_property(bool b, const char* msg, TRAPS) { | |
| 168 #ifdef ASSERT | |
| 169 if (!b) { fatal(msg); } | |
| 170 #endif | |
| 171 } | |
| 172 | |
| 173 inline void check_property(bool property, const char* msg, int index, TRAPS) { | |
| 174 if (_need_verify) { | |
| 175 guarantee_property(property, msg, index, CHECK); | |
| 176 } else { | |
| 177 assert_property(property, msg, CHECK); | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 inline void check_property(bool property, const char* msg, TRAPS) { | |
| 182 if (_need_verify) { | |
| 183 guarantee_property(property, msg, CHECK); | |
| 184 } else { | |
| 185 assert_property(property, msg, CHECK); | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 inline void guarantee_property(bool b, const char* msg, int index, TRAPS) { | |
| 190 if (!b) { classfile_parse_error(msg, index, CHECK); } | |
| 191 } | |
| 192 inline void guarantee_property(bool b, const char* msg, const char *name, TRAPS) { | |
| 193 if (!b) { classfile_parse_error(msg, name, CHECK); } | |
| 194 } | |
| 195 inline void guarantee_property(bool b, const char* msg, int index, const char *name, TRAPS) { | |
| 196 if (!b) { classfile_parse_error(msg, index, name, CHECK); } | |
| 197 } | |
| 198 | |
|
1586
086d73ccd6c0
6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents:
974
diff
changeset
|
199 void throwIllegalSignature( |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
200 const char* type, Symbol* name, Symbol* sig, TRAPS); |
|
1586
086d73ccd6c0
6930553: classfile format checker allows invalid method descriptor in CONSTANT_NameAndType_info in some cases
kamg
parents:
974
diff
changeset
|
201 |
| 0 | 202 bool is_supported_version(u2 major, u2 minor); |
| 203 bool has_illegal_visibility(jint flags); | |
| 204 | |
| 205 void verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS); | |
| 206 void verify_legal_utf8(const unsigned char* buffer, int length, TRAPS); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
207 void verify_legal_class_name(Symbol* name, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
208 void verify_legal_field_name(Symbol* name, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
209 void verify_legal_method_name(Symbol* name, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
210 void verify_legal_field_signature(Symbol* fieldname, Symbol* signature, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
211 int verify_legal_method_signature(Symbol* methodname, Symbol* signature, TRAPS); |
| 0 | 212 void verify_legal_class_modifiers(jint flags, TRAPS); |
| 213 void verify_legal_field_modifiers(jint flags, bool is_interface, TRAPS); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
214 void verify_legal_method_modifiers(jint flags, bool is_interface, Symbol* name, TRAPS); |
| 0 | 215 bool verify_unqualified_name(char* name, unsigned int length, int type); |
| 216 char* skip_over_field_name(char* name, bool slash_ok, unsigned int length); | |
| 217 char* skip_over_field_signature(char* signature, bool void_ok, unsigned int length, TRAPS); | |
| 218 | |
| 710 | 219 bool is_anonymous() { |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2376
diff
changeset
|
220 assert(EnableInvokeDynamic || _host_klass.is_null(), ""); |
| 710 | 221 return _host_klass.not_null(); |
| 222 } | |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
223 bool has_cp_patch_at(int index) { |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2376
diff
changeset
|
224 assert(EnableInvokeDynamic, ""); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
225 assert(index >= 0, "oob"); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
226 return (_cp_patches != NULL |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
227 && index < _cp_patches->length() |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
228 && _cp_patches->adr_at(index)->not_null()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
229 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
230 Handle cp_patch_at(int index) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
231 assert(has_cp_patch_at(index), "oob"); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
232 return _cp_patches->at(index); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
233 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
234 Handle clear_cp_patch_at(int index) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
235 Handle patch = cp_patch_at(index); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
236 _cp_patches->at_put(index, Handle()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
237 assert(!has_cp_patch_at(index), ""); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
238 return patch; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
239 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
240 void patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
241 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
242 // Wrapper for constantTag.is_klass_[or_]reference. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
243 // In older versions of the VM, klassOops cannot sneak into early phases of |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
244 // constant pool construction, but in later versions they can. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
245 // %%% Let's phase out the old is_klass_reference. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
246 bool is_klass_reference(constantPoolHandle cp, int index) { |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2376
diff
changeset
|
247 return ((LinkWellKnownClasses || EnableInvokeDynamic) |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
248 ? cp->tag_at(index).is_klass_or_reference() |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
249 : cp->tag_at(index).is_klass_reference()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
250 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
251 |
| 0 | 252 public: |
| 253 // Constructor | |
| 254 ClassFileParser(ClassFileStream* st) { set_stream(st); } | |
| 255 | |
| 256 // Parse .class file and return new klassOop. The klassOop is not hooked up | |
| 257 // to the system dictionary or any other structures, so a .class file can | |
| 258 // be loaded several times if desired. | |
| 259 // The system dictionary hookup is done by the caller. | |
| 260 // | |
| 261 // "parsed_name" is updated by this method, and is the name found | |
| 262 // while parsing the stream. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
263 instanceKlassHandle parseClassFile(Symbol* name, |
| 0 | 264 Handle class_loader, |
| 265 Handle protection_domain, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
266 TempNewSymbol& parsed_name, |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
875
diff
changeset
|
267 bool verify, |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
268 TRAPS) { |
| 710 | 269 KlassHandle no_host_klass; |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
875
diff
changeset
|
270 return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
271 } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
272 instanceKlassHandle parseClassFile(Symbol* name, |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
273 Handle class_loader, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
274 Handle protection_domain, |
| 710 | 275 KlassHandle host_klass, |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
276 GrowableArray<Handle>* cp_patches, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
277 TempNewSymbol& parsed_name, |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
875
diff
changeset
|
278 bool verify, |
| 0 | 279 TRAPS); |
| 280 | |
| 281 // Verifier checks | |
| 282 static void check_super_class_access(instanceKlassHandle this_klass, TRAPS); | |
| 283 static void check_super_interface_access(instanceKlassHandle this_klass, TRAPS); | |
| 284 static void check_final_method_override(instanceKlassHandle this_klass, TRAPS); | |
| 285 static void check_illegal_static_method(instanceKlassHandle this_klass, TRAPS); | |
| 286 }; | |
| 1972 | 287 |
| 288 #endif // SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP |