• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/classfile/classFileParser.hpp@0ede345ec7c9 (annotated)

src/share/vm/classfile/classFileParser.hpp

Wed, 13 Mar 2013 15:15:56 -0400

author

coleenp

date

Wed, 13 Mar 2013 15:15:56 -0400

changeset 4718

0ede345ec7c9

parent 4572

927a311d00f9

child 4719

c8b31b461e1a

permissions

-rw-r--r--

8009829: CDS: JDK JPRT test fails crash in Symbol::equals()
Summary: -Xshare:dump was creating a Symbol in C_heap. There's an assert there that jdk jprt wasn't hitting because it was only done in product
Reviewed-by: dholmes, hseigel, iklam

duke@435	1	/*
coleenp@4572	2	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#ifndef SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP
stefank@2314	26	#define SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP
stefank@2314	27
stefank@2314	28	#include "classfile/classFileStream.hpp"
stefank@2314	29	#include "memory/resourceArea.hpp"
stefank@2314	30	#include "oops/oop.inline.hpp"
stefank@2314	31	#include "oops/typeArrayOop.hpp"
stefank@2314	32	#include "runtime/handles.inline.hpp"
stefank@2314	33	#include "utilities/accessFlags.hpp"
jrose@3926	34	#include "classfile/symbolTable.hpp"
stefank@2314	35
never@3137	36	class FieldAllocationCount;
never@3137	37
never@3137	38
duke@435	39	// Parser for for .class files
duke@435	40	//
duke@435	41	// The bytes describing the class file structure is read from a Stream object
duke@435	42
duke@435	43	class ClassFileParser VALUE_OBJ_CLASS_SPEC {
duke@435	44	private:
duke@435	45	bool _need_verify;
duke@435	46	bool _relax_verify;
duke@435	47	u2 _major_version;
duke@435	48	u2 _minor_version;
coleenp@2497	49	Symbol* _class_name;
jrose@1145	50	KlassHandle _host_klass;
jrose@866	51	GrowableArray<Handle>* _cp_patches; // overrides for CP entries
duke@435	52
jrose@3926	53	// precomputed flags
duke@435	54	bool _has_finalizer;
duke@435	55	bool _has_empty_finalizer;
duke@435	56	bool _has_vanilla_constructor;
jrose@3926	57	int _max_bootstrap_specifier_index; // detects BSS values
duke@435	58
jrose@3926	59	// class attributes parsed before the instance klass is created:
jrose@3926	60	bool _synthetic_flag;
jrose@3926	61	Symbol* _sourcefile;
jrose@3926	62	Symbol* _generic_signature;
kvn@3930	63	char* _sde_buffer;
kvn@3930	64	int _sde_length;
coleenp@4037	65	Array<u2>* _inner_classes;
coleenp@4037	66	AnnotationArray* _annotations;
stefank@4393	67	AnnotationArray* _type_annotations;
jrose@3926	68
jrose@3926	69	void set_class_synthetic_flag(bool x) { _synthetic_flag = x; }
jrose@3926	70	void set_class_sourcefile(Symbol* x) { _sourcefile = x; }
jrose@3926	71	void set_class_generic_signature(Symbol* x) { _generic_signature = x; }
kvn@3930	72	void set_class_sde_buffer(char* x, int len) { _sde_buffer = x; _sde_length = len; }
coleenp@4037	73	void set_class_inner_classes(Array<u2>* x) { _inner_classes = x; }
coleenp@4037	74	void set_class_annotations(AnnotationArray* x) { _annotations = x; }
stefank@4393	75	void set_class_type_annotations(AnnotationArray* x) { _type_annotations = x; }
jrose@3926	76	void init_parsed_class_attributes() {
jrose@3926	77	_synthetic_flag = false;
jrose@3926	78	_sourcefile = NULL;
jrose@3926	79	_generic_signature = NULL;
kvn@3930	80	_sde_buffer = NULL;
kvn@3930	81	_sde_length = 0;
stefank@4393	82	_annotations = _type_annotations = NULL;
jrose@3926	83	// initialize the other flags too:
jrose@3926	84	_has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
jrose@3926	85	_max_bootstrap_specifier_index = -1;
jrose@3926	86	}
jrose@3926	87	void apply_parsed_class_attributes(instanceKlassHandle k); // update k
jrose@3926	88
jrose@3926	89	class AnnotationCollector {
jrose@3926	90	public:
jrose@3926	91	enum Location { _in_field, _in_method, _in_class };
jrose@3926	92	enum ID {
jrose@3926	93	_unknown = 0,
jrose@3926	94	_method_ForceInline,
twisti@3969	95	_method_DontInline,
twisti@3969	96	_method_LambdaForm_Compiled,
twisti@3969	97	_method_LambdaForm_Hidden,
jwilhelm@4430	98	_sun_misc_Contended,
jrose@3926	99	_annotation_LIMIT
jrose@3926	100	};
jrose@3926	101	const Location _location;
jrose@3926	102	int _annotations_present;
jwilhelm@4430	103	u2 _contended_group;
jwilhelm@4430	104
jrose@3926	105	AnnotationCollector(Location location)
jrose@3926	106	: _location(location), _annotations_present(0)
jrose@3926	107	{
jrose@3926	108	assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, "");
jrose@3926	109	}
jrose@3926	110	// If this annotation name has an ID, report it (or _none).
jwilhelm@4430	111	ID annotation_index(ClassLoaderData* loader_data, Symbol* name);
jrose@3926	112	// Set the annotation name:
jrose@3926	113	void set_annotation(ID id) {
jrose@3926	114	assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");
jrose@3926	115	_annotations_present |= nth_bit((int)id);
jrose@3926	116	}
jrose@3926	117	// Report if the annotation is present.
jrose@3926	118	bool has_any_annotations() { return _annotations_present != 0; }
jrose@3926	119	bool has_annotation(ID id) { return (nth_bit((int)id) & _annotations_present) != 0; }
jwilhelm@4430	120
jwilhelm@4430	121	void set_contended_group(u2 group) { _contended_group = group; }
jwilhelm@4430	122	u2 contended_group() { return _contended_group; }
jwilhelm@4430	123
jwilhelm@4430	124	void set_contended(bool contended) { set_annotation(_sun_misc_Contended); }
jwilhelm@4430	125	bool is_contended() { return has_annotation(_sun_misc_Contended); }
jrose@3926	126	};
jrose@3926	127	class FieldAnnotationCollector: public AnnotationCollector {
jrose@3926	128	public:
jrose@3926	129	FieldAnnotationCollector() : AnnotationCollector(_in_field) { }
jrose@3926	130	void apply_to(FieldInfo* f);
jrose@3926	131	};
jrose@3926	132	class MethodAnnotationCollector: public AnnotationCollector {
jrose@3926	133	public:
jrose@3926	134	MethodAnnotationCollector() : AnnotationCollector(_in_method) { }
jrose@3926	135	void apply_to(methodHandle m);
jrose@3926	136	};
jrose@3926	137	class ClassAnnotationCollector: public AnnotationCollector {
jrose@3926	138	public:
jrose@3926	139	ClassAnnotationCollector() : AnnotationCollector(_in_class) { }
jrose@3926	140	void apply_to(instanceKlassHandle k);
jrose@3926	141	};
jrose@2353	142
duke@435	143	enum { fixed_buffer_size = 128 };
duke@435	144	u_char linenumbertable_buffer[fixed_buffer_size];
duke@435	145
duke@435	146	ClassFileStream* _stream; // Actual input stream
duke@435	147
duke@435	148	enum { LegalClass, LegalField, LegalMethod }; // used to verify unqualified names
duke@435	149
duke@435	150	// Accessors
duke@435	151	ClassFileStream* stream() { return _stream; }
duke@435	152	void set_stream(ClassFileStream* st) { _stream = st; }
duke@435	153
duke@435	154	// Constant pool parsing
coleenp@4037	155	void parse_constant_pool_entries(ClassLoaderData* loader_data,
coleenp@3682	156	constantPoolHandle cp, int length, TRAPS);
duke@435	157
coleenp@4037	158	constantPoolHandle parse_constant_pool(ClassLoaderData* loader_data, TRAPS);
duke@435	159
duke@435	160	// Interface parsing
coleenp@4037	161	Array<Klass*>* parse_interfaces(constantPoolHandle cp,
duke@435	162	int length,
coleenp@4142	163	ClassLoaderData* loader_data,
duke@435	164	Handle protection_domain,
coleenp@2497	165	Symbol* class_name,
kamg@4245	166	bool* has_default_methods,
duke@435	167	TRAPS);
coleenp@4037	168	void record_defined_class_dependencies(instanceKlassHandle defined_klass, TRAPS);
duke@435	169
duke@435	170	// Field parsing
coleenp@4037	171	void parse_field_attributes(ClassLoaderData* loader_data,
coleenp@4037	172	constantPoolHandle cp, u2 attributes_count,
duke@435	173	bool is_static, u2 signature_index,
duke@435	174	u2* constantvalue_index_addr,
duke@435	175	bool* is_synthetic_addr,
duke@435	176	u2* generic_signature_index_addr,
coleenp@4037	177	AnnotationArray** field_annotations,
stefank@4393	178	AnnotationArray** field_type_annotations,
jrose@3926	179	FieldAnnotationCollector* parsed_annotations,
jrose@3926	180	TRAPS);
coleenp@4037	181	Array<u2>* parse_fields(ClassLoaderData* loader_data,
coleenp@4037	182	Symbol* class_name,
coleenp@4142	183	constantPoolHandle cp, bool is_interface,
coleenp@4142	184	FieldAllocationCount *fac,
coleenp@4037	185	Array<AnnotationArray*>** fields_annotations,
stefank@4393	186	Array<AnnotationArray*>** fields_type_annotations,
coleenp@4142	187	u2* java_fields_count_ptr, TRAPS);
duke@435	188
jwilhelm@4430	189	void print_field_layout(Symbol* name,
jwilhelm@4430	190	Array<u2>* fields,
jwilhelm@4430	191	constantPoolHandle cp,
jwilhelm@4430	192	int instance_size,
jwilhelm@4430	193	int instance_fields_start,
jwilhelm@4430	194	int instance_fields_end,
jwilhelm@4430	195	int static_fields_end);
jwilhelm@4430	196
duke@435	197	// Method parsing
coleenp@4037	198	methodHandle parse_method(ClassLoaderData* loader_data,
coleenp@4037	199	constantPoolHandle cp,
coleenp@4037	200	bool is_interface,
duke@435	201	AccessFlags* promoted_flags,
duke@435	202	TRAPS);
coleenp@4037	203	Array<Method*>* parse_methods(ClassLoaderData* loader_data,
coleenp@4142	204	constantPoolHandle cp,
coleenp@4142	205	bool is_interface,
duke@435	206	AccessFlags* promoted_flags,
duke@435	207	bool* has_final_method,
kamg@4245	208	bool* has_default_method,
duke@435	209	TRAPS);
coleenp@4037	210	Array<int>* sort_methods(ClassLoaderData* loader_data,
coleenp@4037	211	Array<Method*>* methods,
coleenp@4572	212	TRAPS);
coleenp@4037	213	u2* parse_exception_table(ClassLoaderData* loader_data,
coleenp@4037	214	u4 code_length, u4 exception_table_length,
jiangli@3917	215	constantPoolHandle cp, TRAPS);
duke@435	216	void parse_linenumber_table(
duke@435	217	u4 code_attribute_length, u4 code_length,
duke@435	218	CompressedLineNumberWriteStream** write_stream, TRAPS);
duke@435	219	u2* parse_localvariable_table(u4 code_length, u2 max_locals, u4 code_attribute_length,
duke@435	220	constantPoolHandle cp, u2* localvariable_table_length,
duke@435	221	bool isLVTT, TRAPS);
duke@435	222	u2* parse_checked_exceptions(u2* checked_exceptions_length, u4 method_attribute_length,
duke@435	223	constantPoolHandle cp, TRAPS);
duke@435	224	void parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
duke@435	225	u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS);
coleenp@4037	226	Array<u1>* parse_stackmap_table(ClassLoaderData* loader_data, u4 code_attribute_length, TRAPS);
duke@435	227
duke@435	228	// Classfile attribute parsing
jrose@3926	229	void parse_classfile_sourcefile_attribute(constantPoolHandle cp, TRAPS);
coleenp@4037	230	void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
coleenp@4037	231	int length, TRAPS);
coleenp@4037	232	u2 parse_classfile_inner_classes_attribute(ClassLoaderData* loader_data,
coleenp@4037	233	u1* inner_classes_attribute_start,
jiangli@3670	234	bool parsed_enclosingmethod_attribute,
jiangli@3670	235	u2 enclosing_method_class_index,
jiangli@3670	236	u2 enclosing_method_method_index,
jiangli@3670	237	constantPoolHandle cp,
jrose@3926	238	TRAPS);
coleenp@4037	239	void parse_classfile_attributes(ClassLoaderData* loader_data,
coleenp@4037	240	constantPoolHandle cp,
jrose@3926	241	ClassAnnotationCollector* parsed_annotations,
jrose@3926	242	TRAPS);
jrose@3926	243	void parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS);
jrose@3926	244	void parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS);
coleenp@4037	245	void parse_classfile_bootstrap_methods_attribute(ClassLoaderData* loader_data, constantPoolHandle cp, u4 attribute_length, TRAPS);
duke@435	246
duke@435	247	// Annotations handling
coleenp@4037	248	AnnotationArray* assemble_annotations(ClassLoaderData* loader_data,
coleenp@4037	249	u1* runtime_visible_annotations,
coleenp@4142	250	int runtime_visible_annotations_length,
coleenp@4142	251	u1* runtime_invisible_annotations,
coleenp@4142	252	int runtime_invisible_annotations_length, TRAPS);
jrose@3926	253	int skip_annotation(u1* buffer, int limit, int index);
jrose@3926	254	int skip_annotation_value(u1* buffer, int limit, int index);
jwilhelm@4430	255	void parse_annotations(ClassLoaderData* loader_data,
jwilhelm@4430	256	u1* buffer, int limit, constantPoolHandle cp,
jrose@3926	257	/* Results (currently, only one result is supported): */
jrose@3926	258	AnnotationCollector* result,
jrose@3926	259	TRAPS);
duke@435	260
duke@435	261	// Final setup
jcoomes@1374	262	unsigned int compute_oop_map_count(instanceKlassHandle super,
jcoomes@1374	263	unsigned int nonstatic_oop_count,
jcoomes@1374	264	int first_nonstatic_oop_offset);
jcoomes@1374	265	void fill_oop_maps(instanceKlassHandle k,
jcoomes@1374	266	unsigned int nonstatic_oop_map_count,
jcoomes@1374	267	int* nonstatic_oop_offsets,
jcoomes@1374	268	unsigned int* nonstatic_oop_counts);
duke@435	269	void set_precomputed_flags(instanceKlassHandle k);
coleenp@4037	270	Array<Klass*>* compute_transitive_interfaces(ClassLoaderData* loader_data,
coleenp@4142	271	instanceKlassHandle super,
coleenp@4142	272	Array<Klass*>* local_ifs, TRAPS);
duke@435	273
duke@435	274	// Format checker methods
duke@435	275	void classfile_parse_error(const char* msg, TRAPS);
duke@435	276	void classfile_parse_error(const char* msg, int index, TRAPS);
duke@435	277	void classfile_parse_error(const char* msg, const char *name, TRAPS);
duke@435	278	void classfile_parse_error(const char* msg, int index, const char *name, TRAPS);
duke@435	279	inline void guarantee_property(bool b, const char* msg, TRAPS) {
duke@435	280	if (!b) { classfile_parse_error(msg, CHECK); }
duke@435	281	}
duke@435	282
duke@435	283	inline void assert_property(bool b, const char* msg, TRAPS) {
duke@435	284	#ifdef ASSERT
duke@435	285	if (!b) { fatal(msg); }
duke@435	286	#endif
duke@435	287	}
duke@435	288
duke@435	289	inline void check_property(bool property, const char* msg, int index, TRAPS) {
duke@435	290	if (_need_verify) {
duke@435	291	guarantee_property(property, msg, index, CHECK);
duke@435	292	} else {
duke@435	293	assert_property(property, msg, CHECK);
duke@435	294	}
duke@435	295	}
duke@435	296
duke@435	297	inline void check_property(bool property, const char* msg, TRAPS) {
duke@435	298	if (_need_verify) {
duke@435	299	guarantee_property(property, msg, CHECK);
duke@435	300	} else {
duke@435	301	assert_property(property, msg, CHECK);
duke@435	302	}
duke@435	303	}
duke@435	304
duke@435	305	inline void guarantee_property(bool b, const char* msg, int index, TRAPS) {
duke@435	306	if (!b) { classfile_parse_error(msg, index, CHECK); }
duke@435	307	}
duke@435	308	inline void guarantee_property(bool b, const char* msg, const char *name, TRAPS) {
duke@435	309	if (!b) { classfile_parse_error(msg, name, CHECK); }
duke@435	310	}
duke@435	311	inline void guarantee_property(bool b, const char* msg, int index, const char *name, TRAPS) {
duke@435	312	if (!b) { classfile_parse_error(msg, index, name, CHECK); }
duke@435	313	}
duke@435	314
kamg@1941	315	void throwIllegalSignature(
coleenp@2497	316	const char* type, Symbol* name, Symbol* sig, TRAPS);
kamg@1941	317
duke@435	318	bool is_supported_version(u2 major, u2 minor);
duke@435	319	bool has_illegal_visibility(jint flags);
duke@435	320
duke@435	321	void verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS);
duke@435	322	void verify_legal_utf8(const unsigned char* buffer, int length, TRAPS);
coleenp@2497	323	void verify_legal_class_name(Symbol* name, TRAPS);
coleenp@2497	324	void verify_legal_field_name(Symbol* name, TRAPS);
coleenp@2497	325	void verify_legal_method_name(Symbol* name, TRAPS);
coleenp@2497	326	void verify_legal_field_signature(Symbol* fieldname, Symbol* signature, TRAPS);
coleenp@2497	327	int verify_legal_method_signature(Symbol* methodname, Symbol* signature, TRAPS);
duke@435	328	void verify_legal_class_modifiers(jint flags, TRAPS);
duke@435	329	void verify_legal_field_modifiers(jint flags, bool is_interface, TRAPS);
coleenp@2497	330	void verify_legal_method_modifiers(jint flags, bool is_interface, Symbol* name, TRAPS);
duke@435	331	bool verify_unqualified_name(char* name, unsigned int length, int type);
duke@435	332	char* skip_over_field_name(char* name, bool slash_ok, unsigned int length);
duke@435	333	char* skip_over_field_signature(char* signature, bool void_ok, unsigned int length, TRAPS);
duke@435	334
jrose@1145	335	bool is_anonymous() {
twisti@2698	336	assert(EnableInvokeDynamic || _host_klass.is_null(), "");
jrose@1145	337	return _host_klass.not_null();
jrose@1145	338	}
jrose@866	339	bool has_cp_patch_at(int index) {
twisti@2698	340	assert(EnableInvokeDynamic, "");
jrose@866	341	assert(index >= 0, "oob");
jrose@866	342	return (_cp_patches != NULL
jrose@866	343	&& index < _cp_patches->length()
jrose@866	344	&& _cp_patches->adr_at(index)->not_null());
jrose@866	345	}
jrose@866	346	Handle cp_patch_at(int index) {
jrose@866	347	assert(has_cp_patch_at(index), "oob");
jrose@866	348	return _cp_patches->at(index);
jrose@866	349	}
jrose@866	350	Handle clear_cp_patch_at(int index) {
jrose@866	351	Handle patch = cp_patch_at(index);
jrose@866	352	_cp_patches->at_put(index, Handle());
jrose@866	353	assert(!has_cp_patch_at(index), "");
jrose@866	354	return patch;
jrose@866	355	}
jrose@866	356	void patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS);
jrose@866	357
jrose@866	358	// Wrapper for constantTag.is_klass_[or_]reference.
coleenp@4037	359	// In older versions of the VM, Klass*s cannot sneak into early phases of
jrose@866	360	// constant pool construction, but in later versions they can.
jrose@866	361	// %%% Let's phase out the old is_klass_reference.
jrose@866	362	bool is_klass_reference(constantPoolHandle cp, int index) {
twisti@4163	363	return (EnableInvokeDynamic
jrose@866	364	? cp->tag_at(index).is_klass_or_reference()
jrose@866	365	: cp->tag_at(index).is_klass_reference());
jrose@866	366	}
jrose@866	367
coleenp@4572	368	void copy_localvariable_table(ConstMethod* cm, int lvt_cnt,
coleenp@4572	369	u2* localvariable_table_length,
coleenp@4572	370	u2** localvariable_table_start,
coleenp@4572	371	int lvtt_cnt,
coleenp@4572	372	u2* localvariable_type_table_length,
coleenp@4572	373	u2** localvariable_type_table_start,
coleenp@4572	374	TRAPS);
coleenp@4572	375
coleenp@4572	376	void copy_method_annotations(ClassLoaderData* loader_data,
coleenp@4572	377	ConstMethod* cm,
coleenp@4572	378	u1* runtime_visible_annotations,
coleenp@4572	379	int runtime_visible_annotations_length,
coleenp@4572	380	u1* runtime_invisible_annotations,
coleenp@4572	381	int runtime_invisible_annotations_length,
coleenp@4572	382	u1* runtime_visible_parameter_annotations,
coleenp@4572	383	int runtime_visible_parameter_annotations_length,
coleenp@4572	384	u1* runtime_invisible_parameter_annotations,
coleenp@4572	385	int runtime_invisible_parameter_annotations_length,
coleenp@4572	386	u1* runtime_visible_type_annotations,
coleenp@4572	387	int runtime_visible_type_annotations_length,
coleenp@4572	388	u1* runtime_invisible_type_annotations,
coleenp@4572	389	int runtime_invisible_type_annotations_length,
coleenp@4572	390	u1* annotation_default,
coleenp@4572	391	int annotation_default_length,
coleenp@4572	392	TRAPS);
coleenp@4572	393
duke@435	394	public:
duke@435	395	// Constructor
duke@435	396	ClassFileParser(ClassFileStream* st) { set_stream(st); }
duke@435	397
coleenp@4037	398	// Parse .class file and return new Klass*. The Klass* is not hooked up
duke@435	399	// to the system dictionary or any other structures, so a .class file can
duke@435	400	// be loaded several times if desired.
duke@435	401	// The system dictionary hookup is done by the caller.
duke@435	402	//
duke@435	403	// "parsed_name" is updated by this method, and is the name found
duke@435	404	// while parsing the stream.
coleenp@2497	405	instanceKlassHandle parseClassFile(Symbol* name,
coleenp@4304	406	ClassLoaderData* loader_data,
duke@435	407	Handle protection_domain,
coleenp@2497	408	TempNewSymbol& parsed_name,
acorn@1408	409	bool verify,
jrose@866	410	TRAPS) {
jrose@1145	411	KlassHandle no_host_klass;
coleenp@4304	412	return parseClassFile(name, loader_data, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD);
jrose@866	413	}
coleenp@2497	414	instanceKlassHandle parseClassFile(Symbol* name,
coleenp@4304	415	ClassLoaderData* loader_data,
jrose@866	416	Handle protection_domain,
jrose@1145	417	KlassHandle host_klass,
jrose@866	418	GrowableArray<Handle>* cp_patches,
coleenp@2497	419	TempNewSymbol& parsed_name,
acorn@1408	420	bool verify,
duke@435	421	TRAPS);
duke@435	422
duke@435	423	// Verifier checks
duke@435	424	static void check_super_class_access(instanceKlassHandle this_klass, TRAPS);
duke@435	425	static void check_super_interface_access(instanceKlassHandle this_klass, TRAPS);
duke@435	426	static void check_final_method_override(instanceKlassHandle this_klass, TRAPS);
duke@435	427	static void check_illegal_static_method(instanceKlassHandle this_klass, TRAPS);
duke@435	428	};
stefank@2314	429
stefank@2314	430	#endif // SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP