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

src/share/vm/classfile/classFileParser.hpp@9c9fb30d2b3b (annotated)

src/share/vm/classfile/classFileParser.hpp

Mon, 16 Jul 2012 19:50:52 -0700

author

kvn

date

Mon, 16 Jul 2012 19:50:52 -0700

changeset 3930

9c9fb30d2b3b

parent 3926

6d8f36bcef55

child 3931

dd785aabe02b

permissions

-rw-r--r--

Merge

duke@435	1	/*
coleenp@3682	2	* Copyright (c) 1997, 2012, 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;
jrose@3926	65	typeArrayHandle _inner_classes;
jrose@3926	66	typeArrayHandle _annotations;
jrose@3926	67
jrose@3926	68	void set_class_synthetic_flag(bool x) { _synthetic_flag = x; }
jrose@3926	69	void set_class_sourcefile(Symbol* x) { _sourcefile = x; }
jrose@3926	70	void set_class_generic_signature(Symbol* x) { _generic_signature = x; }
kvn@3930	71	void set_class_sde_buffer(char* x, int len) { _sde_buffer = x; _sde_length = len; }
jrose@3926	72	void set_class_inner_classes(typeArrayHandle x) { _inner_classes = x; }
jrose@3926	73	void set_class_annotations(typeArrayHandle x) { _annotations = x; }
jrose@3926	74	void init_parsed_class_attributes() {
jrose@3926	75	_synthetic_flag = false;
jrose@3926	76	_sourcefile = NULL;
jrose@3926	77	_generic_signature = NULL;
kvn@3930	78	_sde_buffer = NULL;
kvn@3930	79	_sde_length = 0;
jrose@3926	80	// initialize the other flags too:
jrose@3926	81	_has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
jrose@3926	82	_max_bootstrap_specifier_index = -1;
jrose@3926	83	}
jrose@3926	84	void apply_parsed_class_attributes(instanceKlassHandle k); // update k
jrose@3926	85
jrose@3926	86	class AnnotationCollector {
jrose@3926	87	public:
jrose@3926	88	enum Location { _in_field, _in_method, _in_class };
jrose@3926	89	enum ID {
jrose@3926	90	_unknown = 0,
jrose@3926	91	_method_ForceInline,
jrose@3926	92	_annotation_LIMIT
jrose@3926	93	};
jrose@3926	94	const Location _location;
jrose@3926	95	int _annotations_present;
jrose@3926	96	AnnotationCollector(Location location)
jrose@3926	97	: _location(location), _annotations_present(0)
jrose@3926	98	{
jrose@3926	99	assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, "");
jrose@3926	100	}
jrose@3926	101	// If this annotation name has an ID, report it (or _none).
jrose@3926	102	ID annotation_index(Symbol* name);
jrose@3926	103	// Set the annotation name:
jrose@3926	104	void set_annotation(ID id) {
jrose@3926	105	assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");
jrose@3926	106	_annotations_present |= nth_bit((int)id);
jrose@3926	107	}
jrose@3926	108	// Report if the annotation is present.
jrose@3926	109	bool has_any_annotations() { return _annotations_present != 0; }
jrose@3926	110	bool has_annotation(ID id) { return (nth_bit((int)id) & _annotations_present) != 0; }
jrose@3926	111	};
jrose@3926	112	class FieldAnnotationCollector: public AnnotationCollector {
jrose@3926	113	public:
jrose@3926	114	FieldAnnotationCollector() : AnnotationCollector(_in_field) { }
jrose@3926	115	void apply_to(FieldInfo* f);
jrose@3926	116	};
jrose@3926	117	class MethodAnnotationCollector: public AnnotationCollector {
jrose@3926	118	public:
jrose@3926	119	MethodAnnotationCollector() : AnnotationCollector(_in_method) { }
jrose@3926	120	void apply_to(methodHandle m);
jrose@3926	121	};
jrose@3926	122	class ClassAnnotationCollector: public AnnotationCollector {
jrose@3926	123	public:
jrose@3926	124	ClassAnnotationCollector() : AnnotationCollector(_in_class) { }
jrose@3926	125	void apply_to(instanceKlassHandle k);
jrose@3926	126	};
jrose@2353	127
duke@435	128	enum { fixed_buffer_size = 128 };
duke@435	129	u_char linenumbertable_buffer[fixed_buffer_size];
duke@435	130
duke@435	131	ClassFileStream* _stream; // Actual input stream
duke@435	132
duke@435	133	enum { LegalClass, LegalField, LegalMethod }; // used to verify unqualified names
duke@435	134
duke@435	135	// Accessors
duke@435	136	ClassFileStream* stream() { return _stream; }
duke@435	137	void set_stream(ClassFileStream* st) { _stream = st; }
duke@435	138
duke@435	139	// Constant pool parsing
coleenp@3682	140	void parse_constant_pool_entries(Handle class_loader,
coleenp@3682	141	constantPoolHandle cp, int length, TRAPS);
duke@435	142
coleenp@3682	143	constantPoolHandle parse_constant_pool(Handle class_loader, TRAPS);
duke@435	144
duke@435	145	// Interface parsing
duke@435	146	objArrayHandle parse_interfaces(constantPoolHandle cp,
duke@435	147	int length,
duke@435	148	Handle class_loader,
duke@435	149	Handle protection_domain,
coleenp@2497	150	Symbol* class_name,
duke@435	151	TRAPS);
duke@435	152
duke@435	153	// Field parsing
duke@435	154	void parse_field_attributes(constantPoolHandle cp, u2 attributes_count,
duke@435	155	bool is_static, u2 signature_index,
duke@435	156	u2* constantvalue_index_addr,
duke@435	157	bool* is_synthetic_addr,
duke@435	158	u2* generic_signature_index_addr,
jrose@3926	159	typeArrayHandle* field_annotations,
jrose@3926	160	FieldAnnotationCollector* parsed_annotations,
jrose@3926	161	TRAPS);
never@3137	162	typeArrayHandle parse_fields(Symbol* class_name,
never@3137	163	constantPoolHandle cp, bool is_interface,
never@3137	164	FieldAllocationCount *fac,
never@3137	165	objArrayHandle* fields_annotations,
jiangli@3373	166	u2* java_fields_count_ptr, TRAPS);
duke@435	167
duke@435	168	// Method parsing
duke@435	169	methodHandle parse_method(constantPoolHandle cp, bool is_interface,
duke@435	170	AccessFlags* promoted_flags,
duke@435	171	typeArrayHandle* method_annotations,
duke@435	172	typeArrayHandle* method_parameter_annotations,
duke@435	173	typeArrayHandle* method_default_annotations,
duke@435	174	TRAPS);
duke@435	175	objArrayHandle parse_methods (constantPoolHandle cp, bool is_interface,
duke@435	176	AccessFlags* promoted_flags,
duke@435	177	bool* has_final_method,
duke@435	178	objArrayOop* methods_annotations_oop,
duke@435	179	objArrayOop* methods_parameter_annotations_oop,
duke@435	180	objArrayOop* methods_default_annotations_oop,
duke@435	181	TRAPS);
duke@435	182	typeArrayHandle sort_methods (objArrayHandle methods,
duke@435	183	objArrayHandle methods_annotations,
duke@435	184	objArrayHandle methods_parameter_annotations,
duke@435	185	objArrayHandle methods_default_annotations,
duke@435	186	TRAPS);
duke@435	187	typeArrayHandle parse_exception_table(u4 code_length, u4 exception_table_length,
duke@435	188	constantPoolHandle cp, TRAPS);
duke@435	189	void parse_linenumber_table(
duke@435	190	u4 code_attribute_length, u4 code_length,
duke@435	191	CompressedLineNumberWriteStream** write_stream, TRAPS);
duke@435	192	u2* parse_localvariable_table(u4 code_length, u2 max_locals, u4 code_attribute_length,
duke@435	193	constantPoolHandle cp, u2* localvariable_table_length,
duke@435	194	bool isLVTT, TRAPS);
duke@435	195	u2* parse_checked_exceptions(u2* checked_exceptions_length, u4 method_attribute_length,
duke@435	196	constantPoolHandle cp, TRAPS);
duke@435	197	void parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
duke@435	198	u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS);
duke@435	199	typeArrayOop parse_stackmap_table(u4 code_attribute_length, TRAPS);
duke@435	200
duke@435	201	// Classfile attribute parsing
jrose@3926	202	void parse_classfile_sourcefile_attribute(constantPoolHandle cp, TRAPS);
jrose@3926	203	void parse_classfile_source_debug_extension_attribute(constantPoolHandle cp, int length, TRAPS);
jiangli@3670	204	u2 parse_classfile_inner_classes_attribute(u1* inner_classes_attribute_start,
jiangli@3670	205	bool parsed_enclosingmethod_attribute,
jiangli@3670	206	u2 enclosing_method_class_index,
jiangli@3670	207	u2 enclosing_method_method_index,
jiangli@3670	208	constantPoolHandle cp,
jrose@3926	209	TRAPS);
jrose@3926	210	void parse_classfile_attributes(constantPoolHandle cp,
jrose@3926	211	ClassAnnotationCollector* parsed_annotations,
jrose@3926	212	TRAPS);
jrose@3926	213	void parse_classfile_synthetic_attribute(constantPoolHandle cp, TRAPS);
jrose@3926	214	void parse_classfile_signature_attribute(constantPoolHandle cp, TRAPS);
jrose@3926	215	void parse_classfile_bootstrap_methods_attribute(constantPoolHandle cp, u4 attribute_length, TRAPS);
duke@435	216
duke@435	217	// Annotations handling
duke@435	218	typeArrayHandle assemble_annotations(u1* runtime_visible_annotations,
duke@435	219	int runtime_visible_annotations_length,
duke@435	220	u1* runtime_invisible_annotations,
duke@435	221	int runtime_invisible_annotations_length, TRAPS);
jrose@3926	222	int skip_annotation(u1* buffer, int limit, int index);
jrose@3926	223	int skip_annotation_value(u1* buffer, int limit, int index);
jrose@3926	224	void parse_annotations(u1* buffer, int limit, constantPoolHandle cp,
jrose@3926	225	/* Results (currently, only one result is supported): */
jrose@3926	226	AnnotationCollector* result,
jrose@3926	227	TRAPS);
duke@435	228
duke@435	229	// Final setup
jcoomes@1374	230	unsigned int compute_oop_map_count(instanceKlassHandle super,
jcoomes@1374	231	unsigned int nonstatic_oop_count,
jcoomes@1374	232	int first_nonstatic_oop_offset);
jcoomes@1374	233	void fill_oop_maps(instanceKlassHandle k,
jcoomes@1374	234	unsigned int nonstatic_oop_map_count,
jcoomes@1374	235	int* nonstatic_oop_offsets,
jcoomes@1374	236	unsigned int* nonstatic_oop_counts);
duke@435	237	void set_precomputed_flags(instanceKlassHandle k);
duke@435	238	objArrayHandle compute_transitive_interfaces(instanceKlassHandle super,
duke@435	239	objArrayHandle local_ifs, TRAPS);
duke@435	240
duke@435	241	// Format checker methods
duke@435	242	void classfile_parse_error(const char* msg, TRAPS);
duke@435	243	void classfile_parse_error(const char* msg, int index, TRAPS);
duke@435	244	void classfile_parse_error(const char* msg, const char *name, TRAPS);
duke@435	245	void classfile_parse_error(const char* msg, int index, const char *name, TRAPS);
duke@435	246	inline void guarantee_property(bool b, const char* msg, TRAPS) {
duke@435	247	if (!b) { classfile_parse_error(msg, CHECK); }
duke@435	248	}
duke@435	249
duke@435	250	inline void assert_property(bool b, const char* msg, TRAPS) {
duke@435	251	#ifdef ASSERT
duke@435	252	if (!b) { fatal(msg); }
duke@435	253	#endif
duke@435	254	}
duke@435	255
duke@435	256	inline void check_property(bool property, const char* msg, int index, TRAPS) {
duke@435	257	if (_need_verify) {
duke@435	258	guarantee_property(property, msg, index, CHECK);
duke@435	259	} else {
duke@435	260	assert_property(property, msg, CHECK);
duke@435	261	}
duke@435	262	}
duke@435	263
duke@435	264	inline void check_property(bool property, const char* msg, TRAPS) {
duke@435	265	if (_need_verify) {
duke@435	266	guarantee_property(property, msg, CHECK);
duke@435	267	} else {
duke@435	268	assert_property(property, msg, CHECK);
duke@435	269	}
duke@435	270	}
duke@435	271
duke@435	272	inline void guarantee_property(bool b, const char* msg, int index, TRAPS) {
duke@435	273	if (!b) { classfile_parse_error(msg, index, CHECK); }
duke@435	274	}
duke@435	275	inline void guarantee_property(bool b, const char* msg, const char *name, TRAPS) {
duke@435	276	if (!b) { classfile_parse_error(msg, name, CHECK); }
duke@435	277	}
duke@435	278	inline void guarantee_property(bool b, const char* msg, int index, const char *name, TRAPS) {
duke@435	279	if (!b) { classfile_parse_error(msg, index, name, CHECK); }
duke@435	280	}
duke@435	281
kamg@1941	282	void throwIllegalSignature(
coleenp@2497	283	const char* type, Symbol* name, Symbol* sig, TRAPS);
kamg@1941	284
duke@435	285	bool is_supported_version(u2 major, u2 minor);
duke@435	286	bool has_illegal_visibility(jint flags);
duke@435	287
duke@435	288	void verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS);
duke@435	289	void verify_legal_utf8(const unsigned char* buffer, int length, TRAPS);
coleenp@2497	290	void verify_legal_class_name(Symbol* name, TRAPS);
coleenp@2497	291	void verify_legal_field_name(Symbol* name, TRAPS);
coleenp@2497	292	void verify_legal_method_name(Symbol* name, TRAPS);
coleenp@2497	293	void verify_legal_field_signature(Symbol* fieldname, Symbol* signature, TRAPS);
coleenp@2497	294	int verify_legal_method_signature(Symbol* methodname, Symbol* signature, TRAPS);
duke@435	295	void verify_legal_class_modifiers(jint flags, TRAPS);
duke@435	296	void verify_legal_field_modifiers(jint flags, bool is_interface, TRAPS);
coleenp@2497	297	void verify_legal_method_modifiers(jint flags, bool is_interface, Symbol* name, TRAPS);
duke@435	298	bool verify_unqualified_name(char* name, unsigned int length, int type);
duke@435	299	char* skip_over_field_name(char* name, bool slash_ok, unsigned int length);
duke@435	300	char* skip_over_field_signature(char* signature, bool void_ok, unsigned int length, TRAPS);
duke@435	301
jrose@1145	302	bool is_anonymous() {
twisti@2698	303	assert(EnableInvokeDynamic || _host_klass.is_null(), "");
jrose@1145	304	return _host_klass.not_null();
jrose@1145	305	}
jrose@866	306	bool has_cp_patch_at(int index) {
twisti@2698	307	assert(EnableInvokeDynamic, "");
jrose@866	308	assert(index >= 0, "oob");
jrose@866	309	return (_cp_patches != NULL
jrose@866	310	&& index < _cp_patches->length()
jrose@866	311	&& _cp_patches->adr_at(index)->not_null());
jrose@866	312	}
jrose@866	313	Handle cp_patch_at(int index) {
jrose@866	314	assert(has_cp_patch_at(index), "oob");
jrose@866	315	return _cp_patches->at(index);
jrose@866	316	}
jrose@866	317	Handle clear_cp_patch_at(int index) {
jrose@866	318	Handle patch = cp_patch_at(index);
jrose@866	319	_cp_patches->at_put(index, Handle());
jrose@866	320	assert(!has_cp_patch_at(index), "");
jrose@866	321	return patch;
jrose@866	322	}
jrose@866	323	void patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS);
jrose@866	324
jrose@866	325	// Wrapper for constantTag.is_klass_[or_]reference.
jrose@866	326	// In older versions of the VM, klassOops cannot sneak into early phases of
jrose@866	327	// constant pool construction, but in later versions they can.
jrose@866	328	// %%% Let's phase out the old is_klass_reference.
jrose@866	329	bool is_klass_reference(constantPoolHandle cp, int index) {
twisti@2698	330	return ((LinkWellKnownClasses || EnableInvokeDynamic)
jrose@866	331	? cp->tag_at(index).is_klass_or_reference()
jrose@866	332	: cp->tag_at(index).is_klass_reference());
jrose@866	333	}
jrose@866	334
duke@435	335	public:
duke@435	336	// Constructor
duke@435	337	ClassFileParser(ClassFileStream* st) { set_stream(st); }
duke@435	338
duke@435	339	// Parse .class file and return new klassOop. The klassOop is not hooked up
duke@435	340	// to the system dictionary or any other structures, so a .class file can
duke@435	341	// be loaded several times if desired.
duke@435	342	// The system dictionary hookup is done by the caller.
duke@435	343	//
duke@435	344	// "parsed_name" is updated by this method, and is the name found
duke@435	345	// while parsing the stream.
coleenp@2497	346	instanceKlassHandle parseClassFile(Symbol* name,
duke@435	347	Handle class_loader,
duke@435	348	Handle protection_domain,
coleenp@2497	349	TempNewSymbol& parsed_name,
acorn@1408	350	bool verify,
jrose@866	351	TRAPS) {
jrose@1145	352	KlassHandle no_host_klass;
acorn@1408	353	return parseClassFile(name, class_loader, protection_domain, no_host_klass, NULL, parsed_name, verify, THREAD);
jrose@866	354	}
coleenp@2497	355	instanceKlassHandle parseClassFile(Symbol* name,
jrose@866	356	Handle class_loader,
jrose@866	357	Handle protection_domain,
jrose@1145	358	KlassHandle host_klass,
jrose@866	359	GrowableArray<Handle>* cp_patches,
coleenp@2497	360	TempNewSymbol& parsed_name,
acorn@1408	361	bool verify,
duke@435	362	TRAPS);
duke@435	363
duke@435	364	// Verifier checks
duke@435	365	static void check_super_class_access(instanceKlassHandle this_klass, TRAPS);
duke@435	366	static void check_super_interface_access(instanceKlassHandle this_klass, TRAPS);
duke@435	367	static void check_final_method_override(instanceKlassHandle this_klass, TRAPS);
duke@435	368	static void check_illegal_static_method(instanceKlassHandle this_klass, TRAPS);
duke@435	369	};
stefank@2314	370
stefank@2314	371	#endif // SHARE_VM_CLASSFILE_CLASSFILEPARSER_HPP