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

src/share/vm/classfile/classFileParser.cpp@7a018855d2f0 (annotated)

src/share/vm/classfile/classFileParser.cpp

Mon, 08 Dec 2008 17:15:02 -0800

author

jrose

date

Mon, 08 Dec 2008 17:15:02 -0800

changeset 909

7a018855d2f0

parent 866

a45484ea312d

child 953

0af8b0718fc9

permissions

-rw-r--r--

6779339: turn off LinkWellKnownClasses by default pending further testing
Summary: temporarily turn off LinkWellKnownClasses optimization
Reviewed-by: never, kvn

duke@435	1	/*
xdono@631	2	* Copyright 1997-2008 Sun Microsystems, Inc. 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	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	#include "incls/_precompiled.incl"
duke@435	26	#include "incls/_classFileParser.cpp.incl"
duke@435	27
duke@435	28	// We generally try to create the oops directly when parsing, rather than allocating
duke@435	29	// temporary data structures and copying the bytes twice. A temporary area is only
duke@435	30	// needed when parsing utf8 entries in the constant pool and when parsing line number
duke@435	31	// tables.
duke@435	32
duke@435	33	// We add assert in debug mode when class format is not checked.
duke@435	34
duke@435	35	#define JAVA_CLASSFILE_MAGIC 0xCAFEBABE
duke@435	36	#define JAVA_MIN_SUPPORTED_VERSION 45
kamg@571	37	#define JAVA_MAX_SUPPORTED_VERSION 51
duke@435	38	#define JAVA_MAX_SUPPORTED_MINOR_VERSION 0
duke@435	39
duke@435	40	// Used for two backward compatibility reasons:
duke@435	41	// - to check for new additions to the class file format in JDK1.5
duke@435	42	// - to check for bug fixes in the format checker in JDK1.5
duke@435	43	#define JAVA_1_5_VERSION 49
duke@435	44
duke@435	45	// Used for backward compatibility reasons:
duke@435	46	// - to check for javac bug fixes that happened after 1.5
kamg@611	47	// - also used as the max version when running in jdk6
duke@435	48	#define JAVA_6_VERSION 50
duke@435	49
duke@435	50
duke@435	51	void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS) {
duke@435	52	// Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
duke@435	53	// this function (_current can be allocated in a register, with scalar
duke@435	54	// replacement of aggregates). The _current pointer is copied back to
duke@435	55	// stream() when this function returns. DON'T call another method within
duke@435	56	// this method that uses stream().
duke@435	57	ClassFileStream* cfs0 = stream();
duke@435	58	ClassFileStream cfs1 = *cfs0;
duke@435	59	ClassFileStream* cfs = &cfs1;
duke@435	60	#ifdef ASSERT
duke@435	61	u1* old_current = cfs0->current();
duke@435	62	#endif
duke@435	63
duke@435	64	// Used for batching symbol allocations.
duke@435	65	const char* names[SymbolTable::symbol_alloc_batch_size];
duke@435	66	int lengths[SymbolTable::symbol_alloc_batch_size];
duke@435	67	int indices[SymbolTable::symbol_alloc_batch_size];
duke@435	68	unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];
duke@435	69	int names_count = 0;
duke@435	70
duke@435	71	// parsing Index 0 is unused
duke@435	72	for (int index = 1; index < length; index++) {
duke@435	73	// Each of the following case guarantees one more byte in the stream
duke@435	74	// for the following tag or the access_flags following constant pool,
duke@435	75	// so we don't need bounds-check for reading tag.
duke@435	76	u1 tag = cfs->get_u1_fast();
duke@435	77	switch (tag) {
duke@435	78	case JVM_CONSTANT_Class :
duke@435	79	{
duke@435	80	cfs->guarantee_more(3, CHECK); // name_index, tag/access_flags
duke@435	81	u2 name_index = cfs->get_u2_fast();
duke@435	82	cp->klass_index_at_put(index, name_index);
duke@435	83	}
duke@435	84	break;
duke@435	85	case JVM_CONSTANT_Fieldref :
duke@435	86	{
duke@435	87	cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags
duke@435	88	u2 class_index = cfs->get_u2_fast();
duke@435	89	u2 name_and_type_index = cfs->get_u2_fast();
duke@435	90	cp->field_at_put(index, class_index, name_and_type_index);
duke@435	91	}
duke@435	92	break;
duke@435	93	case JVM_CONSTANT_Methodref :
duke@435	94	{
duke@435	95	cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags
duke@435	96	u2 class_index = cfs->get_u2_fast();
duke@435	97	u2 name_and_type_index = cfs->get_u2_fast();
duke@435	98	cp->method_at_put(index, class_index, name_and_type_index);
duke@435	99	}
duke@435	100	break;
duke@435	101	case JVM_CONSTANT_InterfaceMethodref :
duke@435	102	{
duke@435	103	cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags
duke@435	104	u2 class_index = cfs->get_u2_fast();
duke@435	105	u2 name_and_type_index = cfs->get_u2_fast();
duke@435	106	cp->interface_method_at_put(index, class_index, name_and_type_index);
duke@435	107	}
duke@435	108	break;
duke@435	109	case JVM_CONSTANT_String :
duke@435	110	{
duke@435	111	cfs->guarantee_more(3, CHECK); // string_index, tag/access_flags
duke@435	112	u2 string_index = cfs->get_u2_fast();
duke@435	113	cp->string_index_at_put(index, string_index);
duke@435	114	}
duke@435	115	break;
duke@435	116	case JVM_CONSTANT_Integer :
duke@435	117	{
duke@435	118	cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags
duke@435	119	u4 bytes = cfs->get_u4_fast();
duke@435	120	cp->int_at_put(index, (jint) bytes);
duke@435	121	}
duke@435	122	break;
duke@435	123	case JVM_CONSTANT_Float :
duke@435	124	{
duke@435	125	cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags
duke@435	126	u4 bytes = cfs->get_u4_fast();
duke@435	127	cp->float_at_put(index, *(jfloat*)&bytes);
duke@435	128	}
duke@435	129	break;
duke@435	130	case JVM_CONSTANT_Long :
duke@435	131	// A mangled type might cause you to overrun allocated memory
duke@435	132	guarantee_property(index+1 < length,
duke@435	133	"Invalid constant pool entry %u in class file %s",
duke@435	134	index, CHECK);
duke@435	135	{
duke@435	136	cfs->guarantee_more(9, CHECK); // bytes, tag/access_flags
duke@435	137	u8 bytes = cfs->get_u8_fast();
duke@435	138	cp->long_at_put(index, bytes);
duke@435	139	}
duke@435	140	index++; // Skip entry following eigth-byte constant, see JVM book p. 98
duke@435	141	break;
duke@435	142	case JVM_CONSTANT_Double :
duke@435	143	// A mangled type might cause you to overrun allocated memory
duke@435	144	guarantee_property(index+1 < length,
duke@435	145	"Invalid constant pool entry %u in class file %s",
duke@435	146	index, CHECK);
duke@435	147	{
duke@435	148	cfs->guarantee_more(9, CHECK); // bytes, tag/access_flags
duke@435	149	u8 bytes = cfs->get_u8_fast();
duke@435	150	cp->double_at_put(index, *(jdouble*)&bytes);
duke@435	151	}
duke@435	152	index++; // Skip entry following eigth-byte constant, see JVM book p. 98
duke@435	153	break;
duke@435	154	case JVM_CONSTANT_NameAndType :
duke@435	155	{
duke@435	156	cfs->guarantee_more(5, CHECK); // name_index, signature_index, tag/access_flags
duke@435	157	u2 name_index = cfs->get_u2_fast();
duke@435	158	u2 signature_index = cfs->get_u2_fast();
duke@435	159	cp->name_and_type_at_put(index, name_index, signature_index);
duke@435	160	}
duke@435	161	break;
duke@435	162	case JVM_CONSTANT_Utf8 :
duke@435	163	{
duke@435	164	cfs->guarantee_more(2, CHECK); // utf8_length
duke@435	165	u2 utf8_length = cfs->get_u2_fast();
duke@435	166	u1* utf8_buffer = cfs->get_u1_buffer();
duke@435	167	assert(utf8_buffer != NULL, "null utf8 buffer");
duke@435	168	// Got utf8 string, guarantee utf8_length+1 bytes, set stream position forward.
duke@435	169	cfs->guarantee_more(utf8_length+1, CHECK); // utf8 string, tag/access_flags
duke@435	170	cfs->skip_u1_fast(utf8_length);
jrose@866	171
duke@435	172	// Before storing the symbol, make sure it's legal
duke@435	173	if (_need_verify) {
duke@435	174	verify_legal_utf8((unsigned char*)utf8_buffer, utf8_length, CHECK);
duke@435	175	}
duke@435	176
jrose@866	177	if (AnonymousClasses && has_cp_patch_at(index)) {
jrose@866	178	Handle patch = clear_cp_patch_at(index);
jrose@866	179	guarantee_property(java_lang_String::is_instance(patch()),
jrose@866	180	"Illegal utf8 patch at %d in class file %s",
jrose@866	181	index, CHECK);
jrose@866	182	char* str = java_lang_String::as_utf8_string(patch());
jrose@866	183	// (could use java_lang_String::as_symbol instead, but might as well batch them)
jrose@866	184	utf8_buffer = (u1*) str;
jrose@866	185	utf8_length = (int) strlen(str);
jrose@866	186	}
jrose@866	187
duke@435	188	unsigned int hash;
duke@435	189	symbolOop result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);
duke@435	190	if (result == NULL) {
duke@435	191	names[names_count] = (char*)utf8_buffer;
duke@435	192	lengths[names_count] = utf8_length;
duke@435	193	indices[names_count] = index;
duke@435	194	hashValues[names_count++] = hash;
duke@435	195	if (names_count == SymbolTable::symbol_alloc_batch_size) {
duke@435	196	oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
duke@435	197	names_count = 0;
duke@435	198	}
duke@435	199	} else {
duke@435	200	cp->symbol_at_put(index, result);
duke@435	201	}
duke@435	202	}
duke@435	203	break;
duke@435	204	default:
duke@435	205	classfile_parse_error(
duke@435	206	"Unknown constant tag %u in class file %s", tag, CHECK);
duke@435	207	break;
duke@435	208	}
duke@435	209	}
duke@435	210
duke@435	211	// Allocate the remaining symbols
duke@435	212	if (names_count > 0) {
duke@435	213	oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);
duke@435	214	}
duke@435	215
duke@435	216	// Copy _current pointer of local copy back to stream().
duke@435	217	#ifdef ASSERT
duke@435	218	assert(cfs0->current() == old_current, "non-exclusive use of stream()");
duke@435	219	#endif
duke@435	220	cfs0->set_current(cfs1.current());
duke@435	221	}
duke@435	222
duke@435	223	bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); }
duke@435	224
duke@435	225	constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
duke@435	226	ClassFileStream* cfs = stream();
duke@435	227	constantPoolHandle nullHandle;
duke@435	228
duke@435	229	cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag
duke@435	230	u2 length = cfs->get_u2_fast();
duke@435	231	guarantee_property(
duke@435	232	length >= 1, "Illegal constant pool size %u in class file %s",
duke@435	233	length, CHECK_(nullHandle));
duke@435	234	constantPoolOop constant_pool =
duke@435	235	oopFactory::new_constantPool(length, CHECK_(nullHandle));
duke@435	236	constantPoolHandle cp (THREAD, constant_pool);
duke@435	237
duke@435	238	cp->set_partially_loaded(); // Enables heap verify to work on partial constantPoolOops
duke@435	239
duke@435	240	// parsing constant pool entries
duke@435	241	parse_constant_pool_entries(cp, length, CHECK_(nullHandle));
duke@435	242
duke@435	243	int index = 1; // declared outside of loops for portability
duke@435	244
duke@435	245	// first verification pass - validate cross references and fixup class and string constants
duke@435	246	for (index = 1; index < length; index++) { // Index 0 is unused
duke@435	247	switch (cp->tag_at(index).value()) {
duke@435	248	case JVM_CONSTANT_Class :
duke@435	249	ShouldNotReachHere(); // Only JVM_CONSTANT_ClassIndex should be present
duke@435	250	break;
duke@435	251	case JVM_CONSTANT_Fieldref :
duke@435	252	// fall through
duke@435	253	case JVM_CONSTANT_Methodref :
duke@435	254	// fall through
duke@435	255	case JVM_CONSTANT_InterfaceMethodref : {
duke@435	256	if (!_need_verify) break;
duke@435	257	int klass_ref_index = cp->klass_ref_index_at(index);
duke@435	258	int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
duke@435	259	check_property(valid_cp_range(klass_ref_index, length) &&
jrose@866	260	is_klass_reference(cp, klass_ref_index),
duke@435	261	"Invalid constant pool index %u in class file %s",
duke@435	262	klass_ref_index,
duke@435	263	CHECK_(nullHandle));
duke@435	264	check_property(valid_cp_range(name_and_type_ref_index, length) &&
duke@435	265	cp->tag_at(name_and_type_ref_index).is_name_and_type(),
duke@435	266	"Invalid constant pool index %u in class file %s",
duke@435	267	name_and_type_ref_index,
duke@435	268	CHECK_(nullHandle));
duke@435	269	break;
duke@435	270	}
duke@435	271	case JVM_CONSTANT_String :
duke@435	272	ShouldNotReachHere(); // Only JVM_CONSTANT_StringIndex should be present
duke@435	273	break;
duke@435	274	case JVM_CONSTANT_Integer :
duke@435	275	break;
duke@435	276	case JVM_CONSTANT_Float :
duke@435	277	break;
duke@435	278	case JVM_CONSTANT_Long :
duke@435	279	case JVM_CONSTANT_Double :
duke@435	280	index++;
duke@435	281	check_property(
duke@435	282	(index < length && cp->tag_at(index).is_invalid()),
duke@435	283	"Improper constant pool long/double index %u in class file %s",
duke@435	284	index, CHECK_(nullHandle));
duke@435	285	break;
duke@435	286	case JVM_CONSTANT_NameAndType : {
duke@435	287	if (!_need_verify) break;
duke@435	288	int name_ref_index = cp->name_ref_index_at(index);
duke@435	289	int signature_ref_index = cp->signature_ref_index_at(index);
duke@435	290	check_property(
duke@435	291	valid_cp_range(name_ref_index, length) &&
duke@435	292	cp->tag_at(name_ref_index).is_utf8(),
duke@435	293	"Invalid constant pool index %u in class file %s",
duke@435	294	name_ref_index, CHECK_(nullHandle));
duke@435	295	check_property(
duke@435	296	valid_cp_range(signature_ref_index, length) &&
duke@435	297	cp->tag_at(signature_ref_index).is_utf8(),
duke@435	298	"Invalid constant pool index %u in class file %s",
duke@435	299	signature_ref_index, CHECK_(nullHandle));
duke@435	300	break;
duke@435	301	}
duke@435	302	case JVM_CONSTANT_Utf8 :
duke@435	303	break;
duke@435	304	case JVM_CONSTANT_UnresolvedClass : // fall-through
duke@435	305	case JVM_CONSTANT_UnresolvedClassInError:
duke@435	306	ShouldNotReachHere(); // Only JVM_CONSTANT_ClassIndex should be present
duke@435	307	break;
duke@435	308	case JVM_CONSTANT_ClassIndex :
duke@435	309	{
duke@435	310	int class_index = cp->klass_index_at(index);
duke@435	311	check_property(
duke@435	312	valid_cp_range(class_index, length) &&
duke@435	313	cp->tag_at(class_index).is_utf8(),
duke@435	314	"Invalid constant pool index %u in class file %s",
duke@435	315	class_index, CHECK_(nullHandle));
duke@435	316	cp->unresolved_klass_at_put(index, cp->symbol_at(class_index));
duke@435	317	}
duke@435	318	break;
duke@435	319	case JVM_CONSTANT_UnresolvedString :
duke@435	320	ShouldNotReachHere(); // Only JVM_CONSTANT_StringIndex should be present
duke@435	321	break;
duke@435	322	case JVM_CONSTANT_StringIndex :
duke@435	323	{
duke@435	324	int string_index = cp->string_index_at(index);
duke@435	325	check_property(
duke@435	326	valid_cp_range(string_index, length) &&
duke@435	327	cp->tag_at(string_index).is_utf8(),
duke@435	328	"Invalid constant pool index %u in class file %s",
duke@435	329	string_index, CHECK_(nullHandle));
duke@435	330	symbolOop sym = cp->symbol_at(string_index);
duke@435	331	cp->unresolved_string_at_put(index, sym);
duke@435	332	}
duke@435	333	break;
duke@435	334	default:
duke@435	335	fatal1("bad constant pool tag value %u", cp->tag_at(index).value());
duke@435	336	ShouldNotReachHere();
duke@435	337	break;
duke@435	338	} // end of switch
duke@435	339	} // end of for
duke@435	340
jrose@866	341	if (_cp_patches != NULL) {
jrose@866	342	// need to treat this_class specially...
jrose@866	343	assert(AnonymousClasses, "");
jrose@866	344	int this_class_index;
jrose@866	345	{
jrose@866	346	cfs->guarantee_more(8, CHECK_(nullHandle)); // flags, this_class, super_class, infs_len
jrose@866	347	u1* mark = cfs->current();
jrose@866	348	u2 flags = cfs->get_u2_fast();
jrose@866	349	this_class_index = cfs->get_u2_fast();
jrose@866	350	cfs->set_current(mark); // revert to mark
jrose@866	351	}
jrose@866	352
jrose@866	353	for (index = 1; index < length; index++) { // Index 0 is unused
jrose@866	354	if (has_cp_patch_at(index)) {
jrose@866	355	guarantee_property(index != this_class_index,
jrose@866	356	"Illegal constant pool patch to self at %d in class file %s",
jrose@866	357	index, CHECK_(nullHandle));
jrose@866	358	patch_constant_pool(cp, index, cp_patch_at(index), CHECK_(nullHandle));
jrose@866	359	}
jrose@866	360	}
jrose@866	361	// Ensure that all the patches have been used.
jrose@866	362	for (index = 0; index < _cp_patches->length(); index++) {
jrose@866	363	guarantee_property(!has_cp_patch_at(index),
jrose@866	364	"Unused constant pool patch at %d in class file %s",
jrose@866	365	index, CHECK_(nullHandle));
jrose@866	366	}
jrose@866	367	}
jrose@866	368
duke@435	369	if (!_need_verify) {
duke@435	370	return cp;
duke@435	371	}
duke@435	372
duke@435	373	// second verification pass - checks the strings are of the right format.
jrose@866	374	// but not yet to the other entries
duke@435	375	for (index = 1; index < length; index++) {
duke@435	376	jbyte tag = cp->tag_at(index).value();
duke@435	377	switch (tag) {
duke@435	378	case JVM_CONSTANT_UnresolvedClass: {
duke@435	379	symbolHandle class_name(THREAD, cp->unresolved_klass_at(index));
jrose@866	380	// check the name, even if _cp_patches will overwrite it
duke@435	381	verify_legal_class_name(class_name, CHECK_(nullHandle));
duke@435	382	break;
duke@435	383	}
duke@435	384	case JVM_CONSTANT_Fieldref:
duke@435	385	case JVM_CONSTANT_Methodref:
duke@435	386	case JVM_CONSTANT_InterfaceMethodref: {
duke@435	387	int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
duke@435	388	// already verified to be utf8
duke@435	389	int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
duke@435	390	// already verified to be utf8
duke@435	391	int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);
duke@435	392	symbolHandle name(THREAD, cp->symbol_at(name_ref_index));
duke@435	393	symbolHandle signature(THREAD, cp->symbol_at(signature_ref_index));
duke@435	394	if (tag == JVM_CONSTANT_Fieldref) {
duke@435	395	verify_legal_field_name(name, CHECK_(nullHandle));
duke@435	396	verify_legal_field_signature(name, signature, CHECK_(nullHandle));
duke@435	397	} else {
duke@435	398	verify_legal_method_name(name, CHECK_(nullHandle));
duke@435	399	verify_legal_method_signature(name, signature, CHECK_(nullHandle));
duke@435	400	if (tag == JVM_CONSTANT_Methodref) {
duke@435	401	// 4509014: If a class method name begins with '<', it must be "<init>".
duke@435	402	assert(!name.is_null(), "method name in constant pool is null");
duke@435	403	unsigned int name_len = name->utf8_length();
duke@435	404	assert(name_len > 0, "bad method name"); // already verified as legal name
duke@435	405	if (name->byte_at(0) == '<') {
duke@435	406	if (name() != vmSymbols::object_initializer_name()) {
duke@435	407	classfile_parse_error(
duke@435	408	"Bad method name at constant pool index %u in class file %s",
duke@435	409	name_ref_index, CHECK_(nullHandle));
duke@435	410	}
duke@435	411	}
duke@435	412	}
duke@435	413	}
duke@435	414	break;
duke@435	415	}
duke@435	416	} // end of switch
duke@435	417	} // end of for
duke@435	418
duke@435	419	return cp;
duke@435	420	}
duke@435	421
duke@435	422
jrose@866	423	void ClassFileParser::patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS) {
jrose@866	424	assert(AnonymousClasses, "");
jrose@866	425	BasicType patch_type = T_VOID;
jrose@866	426	switch (cp->tag_at(index).value()) {
jrose@866	427
jrose@866	428	case JVM_CONSTANT_UnresolvedClass :
jrose@866	429	// Patching a class means pre-resolving it.
jrose@866	430	// The name in the constant pool is ignored.
jrose@866	431	if (patch->klass() == SystemDictionary::class_klass()) { // %%% java_lang_Class::is_instance
jrose@866	432	guarantee_property(!java_lang_Class::is_primitive(patch()),
jrose@866	433	"Illegal class patch at %d in class file %s",
jrose@866	434	index, CHECK);
jrose@866	435	cp->klass_at_put(index, java_lang_Class::as_klassOop(patch()));
jrose@866	436	} else {
jrose@866	437	guarantee_property(java_lang_String::is_instance(patch()),
jrose@866	438	"Illegal class patch at %d in class file %s",
jrose@866	439	index, CHECK);
jrose@866	440	symbolHandle name = java_lang_String::as_symbol(patch(), CHECK);
jrose@866	441	cp->unresolved_klass_at_put(index, name());
jrose@866	442	}
jrose@866	443	break;
jrose@866	444
jrose@866	445	case JVM_CONSTANT_UnresolvedString :
jrose@866	446	// Patching a string means pre-resolving it.
jrose@866	447	// The spelling in the constant pool is ignored.
jrose@866	448	// The constant reference may be any object whatever.
jrose@866	449	// If it is not a real interned string, the constant is referred
jrose@866	450	// to as a "pseudo-string", and must be presented to the CP
jrose@866	451	// explicitly, because it may require scavenging.
jrose@866	452	cp->pseudo_string_at_put(index, patch());
jrose@866	453	break;
jrose@866	454
jrose@866	455	case JVM_CONSTANT_Integer : patch_type = T_INT; goto patch_prim;
jrose@866	456	case JVM_CONSTANT_Float : patch_type = T_FLOAT; goto patch_prim;
jrose@866	457	case JVM_CONSTANT_Long : patch_type = T_LONG; goto patch_prim;
jrose@866	458	case JVM_CONSTANT_Double : patch_type = T_DOUBLE; goto patch_prim;
jrose@866	459	patch_prim:
jrose@866	460	{
jrose@866	461	jvalue value;
jrose@866	462	BasicType value_type = java_lang_boxing_object::get_value(patch(), &value);
jrose@866	463	guarantee_property(value_type == patch_type,
jrose@866	464	"Illegal primitive patch at %d in class file %s",
jrose@866	465	index, CHECK);
jrose@866	466	switch (value_type) {
jrose@866	467	case T_INT: cp->int_at_put(index, value.i); break;
jrose@866	468	case T_FLOAT: cp->float_at_put(index, value.f); break;
jrose@866	469	case T_LONG: cp->long_at_put(index, value.j); break;
jrose@866	470	case T_DOUBLE: cp->double_at_put(index, value.d); break;
jrose@866	471	default: assert(false, "");
jrose@866	472	}
jrose@866	473	}
jrose@866	474	break;
jrose@866	475
jrose@866	476	default:
jrose@866	477	// %%% TODO: put method handles into CONSTANT_InterfaceMethodref, etc.
jrose@866	478	guarantee_property(!has_cp_patch_at(index),
jrose@866	479	"Illegal unexpected patch at %d in class file %s",
jrose@866	480	index, CHECK);
jrose@866	481	return;
jrose@866	482	}
jrose@866	483
jrose@866	484	// On fall-through, mark the patch as used.
jrose@866	485	clear_cp_patch_at(index);
jrose@866	486	}
jrose@866	487
jrose@866	488
jrose@866	489
duke@435	490	class NameSigHash: public ResourceObj {
duke@435	491	public:
duke@435	492	symbolOop _name; // name
duke@435	493	symbolOop _sig; // signature
duke@435	494	NameSigHash* _next; // Next entry in hash table
duke@435	495	};
duke@435	496
duke@435	497
duke@435	498	#define HASH_ROW_SIZE 256
duke@435	499
duke@435	500	unsigned int hash(symbolOop name, symbolOop sig) {
duke@435	501	unsigned int raw_hash = 0;
duke@435	502	raw_hash += ((unsigned int)(uintptr_t)name) >> (LogHeapWordSize + 2);
duke@435	503	raw_hash += ((unsigned int)(uintptr_t)sig) >> LogHeapWordSize;
duke@435	504
duke@435	505	return (raw_hash + (unsigned int)(uintptr_t)name) % HASH_ROW_SIZE;
duke@435	506	}
duke@435	507
duke@435	508
duke@435	509	void initialize_hashtable(NameSigHash** table) {
duke@435	510	memset((void*)table, 0, sizeof(NameSigHash*) * HASH_ROW_SIZE);
duke@435	511	}
duke@435	512
duke@435	513	// Return false if the name/sig combination is found in table.
duke@435	514	// Return true if no duplicate is found. And name/sig is added as a new entry in table.
duke@435	515	// The old format checker uses heap sort to find duplicates.
duke@435	516	// NOTE: caller should guarantee that GC doesn't happen during the life cycle
duke@435	517	// of table since we don't expect symbolOop's to move.
duke@435	518	bool put_after_lookup(symbolOop name, symbolOop sig, NameSigHash** table) {
duke@435	519	assert(name != NULL, "name in constant pool is NULL");
duke@435	520
duke@435	521	// First lookup for duplicates
duke@435	522	int index = hash(name, sig);
duke@435	523	NameSigHash* entry = table[index];
duke@435	524	while (entry != NULL) {
duke@435	525	if (entry->_name == name && entry->_sig == sig) {
duke@435	526	return false;
duke@435	527	}
duke@435	528	entry = entry->_next;
duke@435	529	}
duke@435	530
duke@435	531	// No duplicate is found, allocate a new entry and fill it.
duke@435	532	entry = new NameSigHash();
duke@435	533	entry->_name = name;
duke@435	534	entry->_sig = sig;
duke@435	535
duke@435	536	// Insert into hash table
duke@435	537	entry->_next = table[index];
duke@435	538	table[index] = entry;
duke@435	539
duke@435	540	return true;
duke@435	541	}
duke@435	542
duke@435	543
duke@435	544	objArrayHandle ClassFileParser::parse_interfaces(constantPoolHandle cp,
duke@435	545	int length,
duke@435	546	Handle class_loader,
duke@435	547	Handle protection_domain,
duke@435	548	PerfTraceTime* vmtimer,
duke@435	549	symbolHandle class_name,
duke@435	550	TRAPS) {
duke@435	551	ClassFileStream* cfs = stream();
duke@435	552	assert(length > 0, "only called for length>0");
duke@435	553	objArrayHandle nullHandle;
duke@435	554	objArrayOop interface_oop = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
duke@435	555	objArrayHandle interfaces (THREAD, interface_oop);
duke@435	556
duke@435	557	int index;
duke@435	558	for (index = 0; index < length; index++) {
duke@435	559	u2 interface_index = cfs->get_u2(CHECK_(nullHandle));
jrose@866	560	KlassHandle interf;
duke@435	561	check_property(
duke@435	562	valid_cp_range(interface_index, cp->length()) &&
jrose@866	563	is_klass_reference(cp, interface_index),
duke@435	564	"Interface name has bad constant pool index %u in class file %s",
duke@435	565	interface_index, CHECK_(nullHandle));
jrose@866	566	if (cp->tag_at(interface_index).is_klass()) {
jrose@866	567	interf = KlassHandle(THREAD, cp->resolved_klass_at(interface_index));
jrose@866	568	} else {
jrose@866	569	symbolHandle unresolved_klass (THREAD, cp->klass_name_at(interface_index));
jrose@866	570
jrose@866	571	// Don't need to check legal name because it's checked when parsing constant pool.
jrose@866	572	// But need to make sure it's not an array type.
jrose@866	573	guarantee_property(unresolved_klass->byte_at(0) != JVM_SIGNATURE_ARRAY,
jrose@866	574	"Bad interface name in class file %s", CHECK_(nullHandle));
jrose@866	575
jrose@866	576	vmtimer->suspend(); // do not count recursive loading twice
jrose@866	577	// Call resolve_super so classcircularity is checked
jrose@866	578	klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
jrose@866	579	unresolved_klass, class_loader, protection_domain,
jrose@866	580	false, CHECK_(nullHandle));
jrose@866	581	interf = KlassHandle(THREAD, k);
jrose@866	582	vmtimer->resume();
jrose@866	583
jrose@909	584	if (LinkWellKnownClasses) // my super type is well known to me
jrose@909	585	cp->klass_at_put(interface_index, interf()); // eagerly resolve
jrose@866	586	}
duke@435	587
duke@435	588	if (!Klass::cast(interf())->is_interface()) {
duke@435	589	THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", nullHandle);
duke@435	590	}
duke@435	591	interfaces->obj_at_put(index, interf());
duke@435	592	}
duke@435	593
duke@435	594	if (!_need_verify || length <= 1) {
duke@435	595	return interfaces;
duke@435	596	}
duke@435	597
duke@435	598	// Check if there's any duplicates in interfaces
duke@435	599	ResourceMark rm(THREAD);
duke@435	600	NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	601	THREAD, NameSigHash*, HASH_ROW_SIZE);
duke@435	602	initialize_hashtable(interface_names);
duke@435	603	bool dup = false;
duke@435	604	{
duke@435	605	debug_only(No_Safepoint_Verifier nsv;)
duke@435	606	for (index = 0; index < length; index++) {
duke@435	607	klassOop k = (klassOop)interfaces->obj_at(index);
duke@435	608	symbolOop name = instanceKlass::cast(k)->name();
duke@435	609	// If no duplicates, add (name, NULL) in hashtable interface_names.
duke@435	610	if (!put_after_lookup(name, NULL, interface_names)) {
duke@435	611	dup = true;
duke@435	612	break;
duke@435	613	}
duke@435	614	}
duke@435	615	}
duke@435	616	if (dup) {
duke@435	617	classfile_parse_error("Duplicate interface name in class file %s",
duke@435	618	CHECK_(nullHandle));
duke@435	619	}
duke@435	620
duke@435	621	return interfaces;
duke@435	622	}
duke@435	623
duke@435	624
duke@435	625	void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, TRAPS) {
duke@435	626	// Make sure the constant pool entry is of a type appropriate to this field
duke@435	627	guarantee_property(
duke@435	628	(constantvalue_index > 0 &&
duke@435	629	constantvalue_index < cp->length()),
duke@435	630	"Bad initial value index %u in ConstantValue attribute in class file %s",
duke@435	631	constantvalue_index, CHECK);
duke@435	632	constantTag value_type = cp->tag_at(constantvalue_index);
duke@435	633	switch ( cp->basic_type_for_signature_at(signature_index) ) {
duke@435	634	case T_LONG:
duke@435	635	guarantee_property(value_type.is_long(), "Inconsistent constant value type in class file %s", CHECK);
duke@435	636	break;
duke@435	637	case T_FLOAT:
duke@435	638	guarantee_property(value_type.is_float(), "Inconsistent constant value type in class file %s", CHECK);
duke@435	639	break;
duke@435	640	case T_DOUBLE:
duke@435	641	guarantee_property(value_type.is_double(), "Inconsistent constant value type in class file %s", CHECK);
duke@435	642	break;
duke@435	643	case T_BYTE: case T_CHAR: case T_SHORT: case T_BOOLEAN: case T_INT:
duke@435	644	guarantee_property(value_type.is_int(), "Inconsistent constant value type in class file %s", CHECK);
duke@435	645	break;
duke@435	646	case T_OBJECT:
duke@435	647	guarantee_property((cp->symbol_at(signature_index)->equals("Ljava/lang/String;", 18)
duke@435	648	&& (value_type.is_string() || value_type.is_unresolved_string())),
duke@435	649	"Bad string initial value in class file %s", CHECK);
duke@435	650	break;
duke@435	651	default:
duke@435	652	classfile_parse_error(
duke@435	653	"Unable to set initial value %u in class file %s",
duke@435	654	constantvalue_index, CHECK);
duke@435	655	}
duke@435	656	}
duke@435	657
duke@435	658
duke@435	659	// Parse attributes for a field.
duke@435	660	void ClassFileParser::parse_field_attributes(constantPoolHandle cp,
duke@435	661	u2 attributes_count,
duke@435	662	bool is_static, u2 signature_index,
duke@435	663	u2* constantvalue_index_addr,
duke@435	664	bool* is_synthetic_addr,
duke@435	665	u2* generic_signature_index_addr,
duke@435	666	typeArrayHandle* field_annotations,
duke@435	667	TRAPS) {
duke@435	668	ClassFileStream* cfs = stream();
duke@435	669	assert(attributes_count > 0, "length should be greater than 0");
duke@435	670	u2 constantvalue_index = 0;
duke@435	671	u2 generic_signature_index = 0;
duke@435	672	bool is_synthetic = false;
duke@435	673	u1* runtime_visible_annotations = NULL;
duke@435	674	int runtime_visible_annotations_length = 0;
duke@435	675	u1* runtime_invisible_annotations = NULL;
duke@435	676	int runtime_invisible_annotations_length = 0;
duke@435	677	while (attributes_count--) {
duke@435	678	cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length
duke@435	679	u2 attribute_name_index = cfs->get_u2_fast();
duke@435	680	u4 attribute_length = cfs->get_u4_fast();
duke@435	681	check_property(valid_cp_range(attribute_name_index, cp->length()) &&
duke@435	682	cp->tag_at(attribute_name_index).is_utf8(),
duke@435	683	"Invalid field attribute index %u in class file %s",
duke@435	684	attribute_name_index,
duke@435	685	CHECK);
duke@435	686	symbolOop attribute_name = cp->symbol_at(attribute_name_index);
duke@435	687	if (is_static && attribute_name == vmSymbols::tag_constant_value()) {
duke@435	688	// ignore if non-static
duke@435	689	if (constantvalue_index != 0) {
duke@435	690	classfile_parse_error("Duplicate ConstantValue attribute in class file %s", CHECK);
duke@435	691	}
duke@435	692	check_property(
duke@435	693	attribute_length == 2,
duke@435	694	"Invalid ConstantValue field attribute length %u in class file %s",
duke@435	695	attribute_length, CHECK);
duke@435	696	constantvalue_index = cfs->get_u2(CHECK);
duke@435	697	if (_need_verify) {
duke@435	698	verify_constantvalue(constantvalue_index, signature_index, cp, CHECK);
duke@435	699	}
duke@435	700	} else if (attribute_name == vmSymbols::tag_synthetic()) {
duke@435	701	if (attribute_length != 0) {
duke@435	702	classfile_parse_error(
duke@435	703	"Invalid Synthetic field attribute length %u in class file %s",
duke@435	704	attribute_length, CHECK);
duke@435	705	}
duke@435	706	is_synthetic = true;
duke@435	707	} else if (attribute_name == vmSymbols::tag_deprecated()) { // 4276120
duke@435	708	if (attribute_length != 0) {
duke@435	709	classfile_parse_error(
duke@435	710	"Invalid Deprecated field attribute length %u in class file %s",
duke@435	711	attribute_length, CHECK);
duke@435	712	}
duke@435	713	} else if (_major_version >= JAVA_1_5_VERSION) {
duke@435	714	if (attribute_name == vmSymbols::tag_signature()) {
duke@435	715	if (attribute_length != 2) {
duke@435	716	classfile_parse_error(
duke@435	717	"Wrong size %u for field's Signature attribute in class file %s",
duke@435	718	attribute_length, CHECK);
duke@435	719	}
duke@435	720	generic_signature_index = cfs->get_u2(CHECK);
duke@435	721	} else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
duke@435	722	runtime_visible_annotations_length = attribute_length;
duke@435	723	runtime_visible_annotations = cfs->get_u1_buffer();
duke@435	724	assert(runtime_visible_annotations != NULL, "null visible annotations");
duke@435	725	cfs->skip_u1(runtime_visible_annotations_length, CHECK);
duke@435	726	} else if (PreserveAllAnnotations && attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
duke@435	727	runtime_invisible_annotations_length = attribute_length;
duke@435	728	runtime_invisible_annotations = cfs->get_u1_buffer();
duke@435	729	assert(runtime_invisible_annotations != NULL, "null invisible annotations");
duke@435	730	cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
duke@435	731	} else {
duke@435	732	cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes
duke@435	733	}
duke@435	734	} else {
duke@435	735	cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes
duke@435	736	}
duke@435	737	}
duke@435	738
duke@435	739	*constantvalue_index_addr = constantvalue_index;
duke@435	740	*is_synthetic_addr = is_synthetic;
duke@435	741	*generic_signature_index_addr = generic_signature_index;
duke@435	742	*field_annotations = assemble_annotations(runtime_visible_annotations,
duke@435	743	runtime_visible_annotations_length,
duke@435	744	runtime_invisible_annotations,
duke@435	745	runtime_invisible_annotations_length,
duke@435	746	CHECK);
duke@435	747	return;
duke@435	748	}
duke@435	749
duke@435	750
duke@435	751	// Field allocation types. Used for computing field offsets.
duke@435	752
duke@435	753	enum FieldAllocationType {
duke@435	754	STATIC_OOP, // Oops
duke@435	755	STATIC_BYTE, // Boolean, Byte, char
duke@435	756	STATIC_SHORT, // shorts
duke@435	757	STATIC_WORD, // ints
duke@435	758	STATIC_DOUBLE, // long or double
duke@435	759	STATIC_ALIGNED_DOUBLE,// aligned long or double
duke@435	760	NONSTATIC_OOP,
duke@435	761	NONSTATIC_BYTE,
duke@435	762	NONSTATIC_SHORT,
duke@435	763	NONSTATIC_WORD,
duke@435	764	NONSTATIC_DOUBLE,
duke@435	765	NONSTATIC_ALIGNED_DOUBLE
duke@435	766	};
duke@435	767
duke@435	768
duke@435	769	struct FieldAllocationCount {
duke@435	770	int static_oop_count;
duke@435	771	int static_byte_count;
duke@435	772	int static_short_count;
duke@435	773	int static_word_count;
duke@435	774	int static_double_count;
duke@435	775	int nonstatic_oop_count;
duke@435	776	int nonstatic_byte_count;
duke@435	777	int nonstatic_short_count;
duke@435	778	int nonstatic_word_count;
duke@435	779	int nonstatic_double_count;
duke@435	780	};
duke@435	781
duke@435	782	typeArrayHandle ClassFileParser::parse_fields(constantPoolHandle cp, bool is_interface,
duke@435	783	struct FieldAllocationCount *fac,
duke@435	784	objArrayHandle* fields_annotations, TRAPS) {
duke@435	785	ClassFileStream* cfs = stream();
duke@435	786	typeArrayHandle nullHandle;
duke@435	787	cfs->guarantee_more(2, CHECK_(nullHandle)); // length
duke@435	788	u2 length = cfs->get_u2_fast();
duke@435	789	// Tuples of shorts [access, name index, sig index, initial value index, byte offset, generic signature index]
duke@435	790	typeArrayOop new_fields = oopFactory::new_permanent_shortArray(length*instanceKlass::next_offset, CHECK_(nullHandle));
duke@435	791	typeArrayHandle fields(THREAD, new_fields);
duke@435	792
duke@435	793	int index = 0;
duke@435	794	typeArrayHandle field_annotations;
duke@435	795	for (int n = 0; n < length; n++) {
duke@435	796	cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count
duke@435	797
duke@435	798	AccessFlags access_flags;
duke@435	799	jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;
duke@435	800	verify_legal_field_modifiers(flags, is_interface, CHECK_(nullHandle));
duke@435	801	access_flags.set_flags(flags);
duke@435	802
duke@435	803	u2 name_index = cfs->get_u2_fast();
duke@435	804	int cp_size = cp->length();
duke@435	805	check_property(
duke@435	806	valid_cp_range(name_index, cp_size) && cp->tag_at(name_index).is_utf8(),
duke@435	807	"Invalid constant pool index %u for field name in class file %s",
duke@435	808	name_index, CHECK_(nullHandle));
duke@435	809	symbolHandle name(THREAD, cp->symbol_at(name_index));
duke@435	810	verify_legal_field_name(name, CHECK_(nullHandle));
duke@435	811
duke@435	812	u2 signature_index = cfs->get_u2_fast();
duke@435	813	check_property(
duke@435	814	valid_cp_range(signature_index, cp_size) &&
duke@435	815	cp->tag_at(signature_index).is_utf8(),
duke@435	816	"Invalid constant pool index %u for field signature in class file %s",
duke@435	817	signature_index, CHECK_(nullHandle));
duke@435	818	symbolHandle sig(THREAD, cp->symbol_at(signature_index));
duke@435	819	verify_legal_field_signature(name, sig, CHECK_(nullHandle));
duke@435	820
duke@435	821	u2 constantvalue_index = 0;
duke@435	822	bool is_synthetic = false;
duke@435	823	u2 generic_signature_index = 0;
duke@435	824	bool is_static = access_flags.is_static();
duke@435	825
duke@435	826	u2 attributes_count = cfs->get_u2_fast();
duke@435	827	if (attributes_count > 0) {
duke@435	828	parse_field_attributes(cp, attributes_count, is_static, signature_index,
duke@435	829	&constantvalue_index, &is_synthetic,
duke@435	830	&generic_signature_index, &field_annotations,
duke@435	831	CHECK_(nullHandle));
duke@435	832	if (field_annotations.not_null()) {
duke@435	833	if (fields_annotations->is_null()) {
duke@435	834	objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
duke@435	835	*fields_annotations = objArrayHandle(THREAD, md);
duke@435	836	}
duke@435	837	(*fields_annotations)->obj_at_put(n, field_annotations());
duke@435	838	}
duke@435	839	if (is_synthetic) {
duke@435	840	access_flags.set_is_synthetic();
duke@435	841	}
duke@435	842	}
duke@435	843
duke@435	844	fields->short_at_put(index++, access_flags.as_short());
duke@435	845	fields->short_at_put(index++, name_index);
duke@435	846	fields->short_at_put(index++, signature_index);
duke@435	847	fields->short_at_put(index++, constantvalue_index);
duke@435	848
duke@435	849	// Remember how many oops we encountered and compute allocation type
duke@435	850	BasicType type = cp->basic_type_for_signature_at(signature_index);
duke@435	851	FieldAllocationType atype;
duke@435	852	if ( is_static ) {
duke@435	853	switch ( type ) {
duke@435	854	case T_BOOLEAN:
duke@435	855	case T_BYTE:
duke@435	856	fac->static_byte_count++;
duke@435	857	atype = STATIC_BYTE;
duke@435	858	break;
duke@435	859	case T_LONG:
duke@435	860	case T_DOUBLE:
duke@435	861	if (Universe::field_type_should_be_aligned(type)) {
duke@435	862	atype = STATIC_ALIGNED_DOUBLE;
duke@435	863	} else {
duke@435	864	atype = STATIC_DOUBLE;
duke@435	865	}
duke@435	866	fac->static_double_count++;
duke@435	867	break;
duke@435	868	case T_CHAR:
duke@435	869	case T_SHORT:
duke@435	870	fac->static_short_count++;
duke@435	871	atype = STATIC_SHORT;
duke@435	872	break;
duke@435	873	case T_FLOAT:
duke@435	874	case T_INT:
duke@435	875	fac->static_word_count++;
duke@435	876	atype = STATIC_WORD;
duke@435	877	break;
duke@435	878	case T_ARRAY:
duke@435	879	case T_OBJECT:
duke@435	880	fac->static_oop_count++;
duke@435	881	atype = STATIC_OOP;
duke@435	882	break;
duke@435	883	case T_ADDRESS:
duke@435	884	case T_VOID:
duke@435	885	default:
duke@435	886	assert(0, "bad field type");
duke@435	887	}
duke@435	888	} else {
duke@435	889	switch ( type ) {
duke@435	890	case T_BOOLEAN:
duke@435	891	case T_BYTE:
duke@435	892	fac->nonstatic_byte_count++;
duke@435	893	atype = NONSTATIC_BYTE;
duke@435	894	break;
duke@435	895	case T_LONG:
duke@435	896	case T_DOUBLE:
duke@435	897	if (Universe::field_type_should_be_aligned(type)) {
duke@435	898	atype = NONSTATIC_ALIGNED_DOUBLE;
duke@435	899	} else {
duke@435	900	atype = NONSTATIC_DOUBLE;
duke@435	901	}
duke@435	902	fac->nonstatic_double_count++;
duke@435	903	break;
duke@435	904	case T_CHAR:
duke@435	905	case T_SHORT:
duke@435	906	fac->nonstatic_short_count++;
duke@435	907	atype = NONSTATIC_SHORT;
duke@435	908	break;
duke@435	909	case T_FLOAT:
duke@435	910	case T_INT:
duke@435	911	fac->nonstatic_word_count++;
duke@435	912	atype = NONSTATIC_WORD;
duke@435	913	break;
duke@435	914	case T_ARRAY:
duke@435	915	case T_OBJECT:
duke@435	916	fac->nonstatic_oop_count++;
duke@435	917	atype = NONSTATIC_OOP;
duke@435	918	break;
duke@435	919	case T_ADDRESS:
duke@435	920	case T_VOID:
duke@435	921	default:
duke@435	922	assert(0, "bad field type");
duke@435	923	}
duke@435	924	}
duke@435	925
duke@435	926	// The correct offset is computed later (all oop fields will be located together)
duke@435	927	// We temporarily store the allocation type in the offset field
duke@435	928	fields->short_at_put(index++, atype);
duke@435	929	fields->short_at_put(index++, 0); // Clear out high word of byte offset
duke@435	930	fields->short_at_put(index++, generic_signature_index);
duke@435	931	}
duke@435	932
duke@435	933	if (_need_verify && length > 1) {
duke@435	934	// Check duplicated fields
duke@435	935	ResourceMark rm(THREAD);
duke@435	936	NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	937	THREAD, NameSigHash*, HASH_ROW_SIZE);
duke@435	938	initialize_hashtable(names_and_sigs);
duke@435	939	bool dup = false;
duke@435	940	{
duke@435	941	debug_only(No_Safepoint_Verifier nsv;)
duke@435	942	for (int i = 0; i < length*instanceKlass::next_offset; i += instanceKlass::next_offset) {
duke@435	943	int name_index = fields->ushort_at(i + instanceKlass::name_index_offset);
duke@435	944	symbolOop name = cp->symbol_at(name_index);
duke@435	945	int sig_index = fields->ushort_at(i + instanceKlass::signature_index_offset);
duke@435	946	symbolOop sig = cp->symbol_at(sig_index);
duke@435	947	// If no duplicates, add name/signature in hashtable names_and_sigs.
duke@435	948	if (!put_after_lookup(name, sig, names_and_sigs)) {
duke@435	949	dup = true;
duke@435	950	break;
duke@435	951	}
duke@435	952	}
duke@435	953	}
duke@435	954	if (dup) {
duke@435	955	classfile_parse_error("Duplicate field name&signature in class file %s",
duke@435	956	CHECK_(nullHandle));
duke@435	957	}
duke@435	958	}
duke@435	959
duke@435	960	return fields;
duke@435	961	}
duke@435	962
duke@435	963
duke@435	964	static void copy_u2_with_conversion(u2* dest, u2* src, int length) {
duke@435	965	while (length-- > 0) {
duke@435	966	*dest++ = Bytes::get_Java_u2((u1*) (src++));
duke@435	967	}
duke@435	968	}
duke@435	969
duke@435	970
duke@435	971	typeArrayHandle ClassFileParser::parse_exception_table(u4 code_length,
duke@435	972	u4 exception_table_length,
duke@435	973	constantPoolHandle cp,
duke@435	974	TRAPS) {
duke@435	975	ClassFileStream* cfs = stream();
duke@435	976	typeArrayHandle nullHandle;
duke@435	977
duke@435	978	// 4-tuples of ints [start_pc, end_pc, handler_pc, catch_type index]
duke@435	979	typeArrayOop eh = oopFactory::new_permanent_intArray(exception_table_length*4, CHECK_(nullHandle));
duke@435	980	typeArrayHandle exception_handlers = typeArrayHandle(THREAD, eh);
duke@435	981
duke@435	982	int index = 0;
duke@435	983	cfs->guarantee_more(8 * exception_table_length, CHECK_(nullHandle)); // start_pc, end_pc, handler_pc, catch_type_index
duke@435	984	for (unsigned int i = 0; i < exception_table_length; i++) {
duke@435	985	u2 start_pc = cfs->get_u2_fast();
duke@435	986	u2 end_pc = cfs->get_u2_fast();
duke@435	987	u2 handler_pc = cfs->get_u2_fast();
duke@435	988	u2 catch_type_index = cfs->get_u2_fast();
duke@435	989	// Will check legal target after parsing code array in verifier.
duke@435	990	if (_need_verify) {
duke@435	991	guarantee_property((start_pc < end_pc) && (end_pc <= code_length),
duke@435	992	"Illegal exception table range in class file %s", CHECK_(nullHandle));
duke@435	993	guarantee_property(handler_pc < code_length,
duke@435	994	"Illegal exception table handler in class file %s", CHECK_(nullHandle));
duke@435	995	if (catch_type_index != 0) {
duke@435	996	guarantee_property(valid_cp_range(catch_type_index, cp->length()) &&
jrose@866	997	is_klass_reference(cp, catch_type_index),
duke@435	998	"Catch type in exception table has bad constant type in class file %s", CHECK_(nullHandle));
duke@435	999	}
duke@435	1000	}
duke@435	1001	exception_handlers->int_at_put(index++, start_pc);
duke@435	1002	exception_handlers->int_at_put(index++, end_pc);
duke@435	1003	exception_handlers->int_at_put(index++, handler_pc);
duke@435	1004	exception_handlers->int_at_put(index++, catch_type_index);
duke@435	1005	}
duke@435	1006	return exception_handlers;
duke@435	1007	}
duke@435	1008
duke@435	1009	void ClassFileParser::parse_linenumber_table(
duke@435	1010	u4 code_attribute_length, u4 code_length,
duke@435	1011	CompressedLineNumberWriteStream** write_stream, TRAPS) {
duke@435	1012	ClassFileStream* cfs = stream();
duke@435	1013	unsigned int num_entries = cfs->get_u2(CHECK);
duke@435	1014
duke@435	1015	// Each entry is a u2 start_pc, and a u2 line_number
duke@435	1016	unsigned int length_in_bytes = num_entries * (sizeof(u2) + sizeof(u2));
duke@435	1017
duke@435	1018	// Verify line number attribute and table length
duke@435	1019	check_property(
duke@435	1020	code_attribute_length == sizeof(u2) + length_in_bytes,
duke@435	1021	"LineNumberTable attribute has wrong length in class file %s", CHECK);
duke@435	1022
duke@435	1023	cfs->guarantee_more(length_in_bytes, CHECK);
duke@435	1024
duke@435	1025	if ((*write_stream) == NULL) {
duke@435	1026	if (length_in_bytes > fixed_buffer_size) {
duke@435	1027	(*write_stream) = new CompressedLineNumberWriteStream(length_in_bytes);
duke@435	1028	} else {
duke@435	1029	(*write_stream) = new CompressedLineNumberWriteStream(
duke@435	1030	linenumbertable_buffer, fixed_buffer_size);
duke@435	1031	}
duke@435	1032	}
duke@435	1033
duke@435	1034	while (num_entries-- > 0) {
duke@435	1035	u2 bci = cfs->get_u2_fast(); // start_pc
duke@435	1036	u2 line = cfs->get_u2_fast(); // line_number
duke@435	1037	guarantee_property(bci < code_length,
duke@435	1038	"Invalid pc in LineNumberTable in class file %s", CHECK);
duke@435	1039	(*write_stream)->write_pair(bci, line);
duke@435	1040	}
duke@435	1041	}
duke@435	1042
duke@435	1043
duke@435	1044	// Class file LocalVariableTable elements.
duke@435	1045	class Classfile_LVT_Element VALUE_OBJ_CLASS_SPEC {
duke@435	1046	public:
duke@435	1047	u2 start_bci;
duke@435	1048	u2 length;
duke@435	1049	u2 name_cp_index;
duke@435	1050	u2 descriptor_cp_index;
duke@435	1051	u2 slot;
duke@435	1052	};
duke@435	1053
duke@435	1054
duke@435	1055	class LVT_Hash: public CHeapObj {
duke@435	1056	public:
duke@435	1057	LocalVariableTableElement *_elem; // element
duke@435	1058	LVT_Hash* _next; // Next entry in hash table
duke@435	1059	};
duke@435	1060
duke@435	1061	unsigned int hash(LocalVariableTableElement *elem) {
duke@435	1062	unsigned int raw_hash = elem->start_bci;
duke@435	1063
duke@435	1064	raw_hash = elem->length + raw_hash * 37;
duke@435	1065	raw_hash = elem->name_cp_index + raw_hash * 37;
duke@435	1066	raw_hash = elem->slot + raw_hash * 37;
duke@435	1067
duke@435	1068	return raw_hash % HASH_ROW_SIZE;
duke@435	1069	}
duke@435	1070
duke@435	1071	void initialize_hashtable(LVT_Hash** table) {
duke@435	1072	for (int i = 0; i < HASH_ROW_SIZE; i++) {
duke@435	1073	table[i] = NULL;
duke@435	1074	}
duke@435	1075	}
duke@435	1076
duke@435	1077	void clear_hashtable(LVT_Hash** table) {
duke@435	1078	for (int i = 0; i < HASH_ROW_SIZE; i++) {
duke@435	1079	LVT_Hash* current = table[i];
duke@435	1080	LVT_Hash* next;
duke@435	1081	while (current != NULL) {
duke@435	1082	next = current->_next;
duke@435	1083	current->_next = NULL;
duke@435	1084	delete(current);
duke@435	1085	current = next;
duke@435	1086	}
duke@435	1087	table[i] = NULL;
duke@435	1088	}
duke@435	1089	}
duke@435	1090
duke@435	1091	LVT_Hash* LVT_lookup(LocalVariableTableElement *elem, int index, LVT_Hash** table) {
duke@435	1092	LVT_Hash* entry = table[index];
duke@435	1093
duke@435	1094	/*
duke@435	1095	* 3-tuple start_bci/length/slot has to be unique key,
duke@435	1096	* so the following comparison seems to be redundant:
duke@435	1097	* && elem->name_cp_index == entry->_elem->name_cp_index
duke@435	1098	*/
duke@435	1099	while (entry != NULL) {
duke@435	1100	if (elem->start_bci == entry->_elem->start_bci
duke@435	1101	&& elem->length == entry->_elem->length
duke@435	1102	&& elem->name_cp_index == entry->_elem->name_cp_index
duke@435	1103	&& elem->slot == entry->_elem->slot
duke@435	1104	) {
duke@435	1105	return entry;
duke@435	1106	}
duke@435	1107	entry = entry->_next;
duke@435	1108	}
duke@435	1109	return NULL;
duke@435	1110	}
duke@435	1111
duke@435	1112	// Return false if the local variable is found in table.
duke@435	1113	// Return true if no duplicate is found.
duke@435	1114	// And local variable is added as a new entry in table.
duke@435	1115	bool LVT_put_after_lookup(LocalVariableTableElement *elem, LVT_Hash** table) {
duke@435	1116	// First lookup for duplicates
duke@435	1117	int index = hash(elem);
duke@435	1118	LVT_Hash* entry = LVT_lookup(elem, index, table);
duke@435	1119
duke@435	1120	if (entry != NULL) {
duke@435	1121	return false;
duke@435	1122	}
duke@435	1123	// No duplicate is found, allocate a new entry and fill it.
duke@435	1124	if ((entry = new LVT_Hash()) == NULL) {
duke@435	1125	return false;
duke@435	1126	}
duke@435	1127	entry->_elem = elem;
duke@435	1128
duke@435	1129	// Insert into hash table
duke@435	1130	entry->_next = table[index];
duke@435	1131	table[index] = entry;
duke@435	1132
duke@435	1133	return true;
duke@435	1134	}
duke@435	1135
duke@435	1136	void copy_lvt_element(Classfile_LVT_Element *src, LocalVariableTableElement *lvt) {
duke@435	1137	lvt->start_bci = Bytes::get_Java_u2((u1*) &src->start_bci);
duke@435	1138	lvt->length = Bytes::get_Java_u2((u1*) &src->length);
duke@435	1139	lvt->name_cp_index = Bytes::get_Java_u2((u1*) &src->name_cp_index);
duke@435	1140	lvt->descriptor_cp_index = Bytes::get_Java_u2((u1*) &src->descriptor_cp_index);
duke@435	1141	lvt->signature_cp_index = 0;
duke@435	1142	lvt->slot = Bytes::get_Java_u2((u1*) &src->slot);
duke@435	1143	}
duke@435	1144
duke@435	1145	// Function is used to parse both attributes:
duke@435	1146	// LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT)
duke@435	1147	u2* ClassFileParser::parse_localvariable_table(u4 code_length,
duke@435	1148	u2 max_locals,
duke@435	1149	u4 code_attribute_length,
duke@435	1150	constantPoolHandle cp,
duke@435	1151	u2* localvariable_table_length,
duke@435	1152	bool isLVTT,
duke@435	1153	TRAPS) {
duke@435	1154	ClassFileStream* cfs = stream();
duke@435	1155	const char * tbl_name = (isLVTT) ? "LocalVariableTypeTable" : "LocalVariableTable";
duke@435	1156	*localvariable_table_length = cfs->get_u2(CHECK_NULL);
duke@435	1157	unsigned int size = (*localvariable_table_length) * sizeof(Classfile_LVT_Element) / sizeof(u2);
duke@435	1158	// Verify local variable table attribute has right length
duke@435	1159	if (_need_verify) {
duke@435	1160	guarantee_property(code_attribute_length == (sizeof(*localvariable_table_length) + size * sizeof(u2)),
duke@435	1161	"%s has wrong length in class file %s", tbl_name, CHECK_NULL);
duke@435	1162	}
duke@435	1163	u2* localvariable_table_start = cfs->get_u2_buffer();
duke@435	1164	assert(localvariable_table_start != NULL, "null local variable table");
duke@435	1165	if (!_need_verify) {
duke@435	1166	cfs->skip_u2_fast(size);
duke@435	1167	} else {
duke@435	1168	cfs->guarantee_more(size * 2, CHECK_NULL);
duke@435	1169	for(int i = 0; i < (*localvariable_table_length); i++) {
duke@435	1170	u2 start_pc = cfs->get_u2_fast();
duke@435	1171	u2 length = cfs->get_u2_fast();
duke@435	1172	u2 name_index = cfs->get_u2_fast();
duke@435	1173	u2 descriptor_index = cfs->get_u2_fast();
duke@435	1174	u2 index = cfs->get_u2_fast();
duke@435	1175	// Assign to a u4 to avoid overflow
duke@435	1176	u4 end_pc = (u4)start_pc + (u4)length;
duke@435	1177
duke@435	1178	if (start_pc >= code_length) {
duke@435	1179	classfile_parse_error(
duke@435	1180	"Invalid start_pc %u in %s in class file %s",
duke@435	1181	start_pc, tbl_name, CHECK_NULL);
duke@435	1182	}
duke@435	1183	if (end_pc > code_length) {
duke@435	1184	classfile_parse_error(
duke@435	1185	"Invalid length %u in %s in class file %s",
duke@435	1186	length, tbl_name, CHECK_NULL);
duke@435	1187	}
duke@435	1188	int cp_size = cp->length();
duke@435	1189	guarantee_property(
duke@435	1190	valid_cp_range(name_index, cp_size) &&
duke@435	1191	cp->tag_at(name_index).is_utf8(),
duke@435	1192	"Name index %u in %s has bad constant type in class file %s",
duke@435	1193	name_index, tbl_name, CHECK_NULL);
duke@435	1194	guarantee_property(
duke@435	1195	valid_cp_range(descriptor_index, cp_size) &&
duke@435	1196	cp->tag_at(descriptor_index).is_utf8(),
duke@435	1197	"Signature index %u in %s has bad constant type in class file %s",
duke@435	1198	descriptor_index, tbl_name, CHECK_NULL);
duke@435	1199
duke@435	1200	symbolHandle name(THREAD, cp->symbol_at(name_index));
duke@435	1201	symbolHandle sig(THREAD, cp->symbol_at(descriptor_index));
duke@435	1202	verify_legal_field_name(name, CHECK_NULL);
duke@435	1203	u2 extra_slot = 0;
duke@435	1204	if (!isLVTT) {
duke@435	1205	verify_legal_field_signature(name, sig, CHECK_NULL);
duke@435	1206
duke@435	1207	// 4894874: check special cases for double and long local variables
duke@435	1208	if (sig() == vmSymbols::type_signature(T_DOUBLE) ||
duke@435	1209	sig() == vmSymbols::type_signature(T_LONG)) {
duke@435	1210	extra_slot = 1;
duke@435	1211	}
duke@435	1212	}
duke@435	1213	guarantee_property((index + extra_slot) < max_locals,
duke@435	1214	"Invalid index %u in %s in class file %s",
duke@435	1215	index, tbl_name, CHECK_NULL);
duke@435	1216	}
duke@435	1217	}
duke@435	1218	return localvariable_table_start;
duke@435	1219	}
duke@435	1220
duke@435	1221
duke@435	1222	void ClassFileParser::parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,
duke@435	1223	u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS) {
duke@435	1224	ClassFileStream* cfs = stream();
duke@435	1225	u2 index = 0; // index in the array with long/double occupying two slots
duke@435	1226	u4 i1 = *u1_index;
duke@435	1227	u4 i2 = *u2_index + 1;
duke@435	1228	for(int i = 0; i < array_length; i++) {
duke@435	1229	u1 tag = u1_array[i1++] = cfs->get_u1(CHECK);
duke@435	1230	index++;
duke@435	1231	if (tag == ITEM_Long || tag == ITEM_Double) {
duke@435	1232	index++;
duke@435	1233	} else if (tag == ITEM_Object) {
duke@435	1234	u2 class_index = u2_array[i2++] = cfs->get_u2(CHECK);
duke@435	1235	guarantee_property(valid_cp_range(class_index, cp->length()) &&
jrose@866	1236	is_klass_reference(cp, class_index),
duke@435	1237	"Bad class index %u in StackMap in class file %s",
duke@435	1238	class_index, CHECK);
duke@435	1239	} else if (tag == ITEM_Uninitialized) {
duke@435	1240	u2 offset = u2_array[i2++] = cfs->get_u2(CHECK);
duke@435	1241	guarantee_property(
duke@435	1242	offset < code_length,
duke@435	1243	"Bad uninitialized type offset %u in StackMap in class file %s",
duke@435	1244	offset, CHECK);
duke@435	1245	} else {
duke@435	1246	guarantee_property(
duke@435	1247	tag <= (u1)ITEM_Uninitialized,
duke@435	1248	"Unknown variable type %u in StackMap in class file %s",
duke@435	1249	tag, CHECK);
duke@435	1250	}
duke@435	1251	}
duke@435	1252	u2_array[*u2_index] = index;
duke@435	1253	*u1_index = i1;
duke@435	1254	*u2_index = i2;
duke@435	1255	}
duke@435	1256
duke@435	1257	typeArrayOop ClassFileParser::parse_stackmap_table(
duke@435	1258	u4 code_attribute_length, TRAPS) {
duke@435	1259	if (code_attribute_length == 0)
duke@435	1260	return NULL;
duke@435	1261
duke@435	1262	ClassFileStream* cfs = stream();
duke@435	1263	u1* stackmap_table_start = cfs->get_u1_buffer();
duke@435	1264	assert(stackmap_table_start != NULL, "null stackmap table");
duke@435	1265
duke@435	1266	// check code_attribute_length first
duke@435	1267	stream()->skip_u1(code_attribute_length, CHECK_NULL);
duke@435	1268
duke@435	1269	if (!_need_verify && !DumpSharedSpaces) {
duke@435	1270	return NULL;
duke@435	1271	}
duke@435	1272
duke@435	1273	typeArrayOop stackmap_data =
duke@435	1274	oopFactory::new_permanent_byteArray(code_attribute_length, CHECK_NULL);
duke@435	1275
duke@435	1276	stackmap_data->set_length(code_attribute_length);
duke@435	1277	memcpy((void*)stackmap_data->byte_at_addr(0),
duke@435	1278	(void*)stackmap_table_start, code_attribute_length);
duke@435	1279	return stackmap_data;
duke@435	1280	}
duke@435	1281
duke@435	1282	u2* ClassFileParser::parse_checked_exceptions(u2* checked_exceptions_length,
duke@435	1283	u4 method_attribute_length,
duke@435	1284	constantPoolHandle cp, TRAPS) {
duke@435	1285	ClassFileStream* cfs = stream();
duke@435	1286	cfs->guarantee_more(2, CHECK_NULL); // checked_exceptions_length
duke@435	1287	*checked_exceptions_length = cfs->get_u2_fast();
duke@435	1288	unsigned int size = (*checked_exceptions_length) * sizeof(CheckedExceptionElement) / sizeof(u2);
duke@435	1289	u2* checked_exceptions_start = cfs->get_u2_buffer();
duke@435	1290	assert(checked_exceptions_start != NULL, "null checked exceptions");
duke@435	1291	if (!_need_verify) {
duke@435	1292	cfs->skip_u2_fast(size);
duke@435	1293	} else {
duke@435	1294	// Verify each value in the checked exception table
duke@435	1295	u2 checked_exception;
duke@435	1296	u2 len = *checked_exceptions_length;
duke@435	1297	cfs->guarantee_more(2 * len, CHECK_NULL);
duke@435	1298	for (int i = 0; i < len; i++) {
duke@435	1299	checked_exception = cfs->get_u2_fast();
duke@435	1300	check_property(
duke@435	1301	valid_cp_range(checked_exception, cp->length()) &&
jrose@866	1302	is_klass_reference(cp, checked_exception),
duke@435	1303	"Exception name has bad type at constant pool %u in class file %s",
duke@435	1304	checked_exception, CHECK_NULL);
duke@435	1305	}
duke@435	1306	}
duke@435	1307	// check exceptions attribute length
duke@435	1308	if (_need_verify) {
duke@435	1309	guarantee_property(method_attribute_length == (sizeof(*checked_exceptions_length) +
duke@435	1310	sizeof(u2) * size),
duke@435	1311	"Exceptions attribute has wrong length in class file %s", CHECK_NULL);
duke@435	1312	}
duke@435	1313	return checked_exceptions_start;
duke@435	1314	}
duke@435	1315
duke@435	1316
duke@435	1317	#define MAX_ARGS_SIZE 255
duke@435	1318	#define MAX_CODE_SIZE 65535
duke@435	1319	#define INITIAL_MAX_LVT_NUMBER 256
duke@435	1320
duke@435	1321	// Note: the parse_method below is big and clunky because all parsing of the code and exceptions
duke@435	1322	// attribute is inlined. This is curbersome to avoid since we inline most of the parts in the
duke@435	1323	// methodOop to save footprint, so we only know the size of the resulting methodOop when the
duke@435	1324	// entire method attribute is parsed.
duke@435	1325	//
duke@435	1326	// The promoted_flags parameter is used to pass relevant access_flags
duke@435	1327	// from the method back up to the containing klass. These flag values
duke@435	1328	// are added to klass's access_flags.
duke@435	1329
duke@435	1330	methodHandle ClassFileParser::parse_method(constantPoolHandle cp, bool is_interface,
duke@435	1331	AccessFlags *promoted_flags,
duke@435	1332	typeArrayHandle* method_annotations,
duke@435	1333	typeArrayHandle* method_parameter_annotations,
duke@435	1334	typeArrayHandle* method_default_annotations,
duke@435	1335	TRAPS) {
duke@435	1336	ClassFileStream* cfs = stream();
duke@435	1337	methodHandle nullHandle;
duke@435	1338	ResourceMark rm(THREAD);
duke@435	1339	// Parse fixed parts
duke@435	1340	cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count
duke@435	1341
duke@435	1342	int flags = cfs->get_u2_fast();
duke@435	1343	u2 name_index = cfs->get_u2_fast();
duke@435	1344	int cp_size = cp->length();
duke@435	1345	check_property(
duke@435	1346	valid_cp_range(name_index, cp_size) &&
duke@435	1347	cp->tag_at(name_index).is_utf8(),
duke@435	1348	"Illegal constant pool index %u for method name in class file %s",
duke@435	1349	name_index, CHECK_(nullHandle));
duke@435	1350	symbolHandle name(THREAD, cp->symbol_at(name_index));
duke@435	1351	verify_legal_method_name(name, CHECK_(nullHandle));
duke@435	1352
duke@435	1353	u2 signature_index = cfs->get_u2_fast();
duke@435	1354	guarantee_property(
duke@435	1355	valid_cp_range(signature_index, cp_size) &&
duke@435	1356	cp->tag_at(signature_index).is_utf8(),
duke@435	1357	"Illegal constant pool index %u for method signature in class file %s",
duke@435	1358	signature_index, CHECK_(nullHandle));
duke@435	1359	symbolHandle signature(THREAD, cp->symbol_at(signature_index));
duke@435	1360
duke@435	1361	AccessFlags access_flags;
duke@435	1362	if (name == vmSymbols::class_initializer_name()) {
duke@435	1363	// We ignore the access flags for a class initializer. (JVM Spec. p. 116)
duke@435	1364	flags = JVM_ACC_STATIC;
duke@435	1365	} else {
duke@435	1366	verify_legal_method_modifiers(flags, is_interface, name, CHECK_(nullHandle));
duke@435	1367	}
duke@435	1368
duke@435	1369	int args_size = -1; // only used when _need_verify is true
duke@435	1370	if (_need_verify) {
duke@435	1371	args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) +
duke@435	1372	verify_legal_method_signature(name, signature, CHECK_(nullHandle));
duke@435	1373	if (args_size > MAX_ARGS_SIZE) {
duke@435	1374	classfile_parse_error("Too many arguments in method signature in class file %s", CHECK_(nullHandle));
duke@435	1375	}
duke@435	1376	}
duke@435	1377
duke@435	1378	access_flags.set_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS);
duke@435	1379
duke@435	1380	// Default values for code and exceptions attribute elements
duke@435	1381	u2 max_stack = 0;
duke@435	1382	u2 max_locals = 0;
duke@435	1383	u4 code_length = 0;
duke@435	1384	u1* code_start = 0;
duke@435	1385	u2 exception_table_length = 0;
duke@435	1386	typeArrayHandle exception_handlers(THREAD, Universe::the_empty_int_array());
duke@435	1387	u2 checked_exceptions_length = 0;
duke@435	1388	u2* checked_exceptions_start = NULL;
duke@435	1389	CompressedLineNumberWriteStream* linenumber_table = NULL;
duke@435	1390	int linenumber_table_length = 0;
duke@435	1391	int total_lvt_length = 0;
duke@435	1392	u2 lvt_cnt = 0;
duke@435	1393	u2 lvtt_cnt = 0;
duke@435	1394	bool lvt_allocated = false;
duke@435	1395	u2 max_lvt_cnt = INITIAL_MAX_LVT_NUMBER;
duke@435	1396	u2 max_lvtt_cnt = INITIAL_MAX_LVT_NUMBER;
duke@435	1397	u2* localvariable_table_length;
duke@435	1398	u2** localvariable_table_start;
duke@435	1399	u2* localvariable_type_table_length;
duke@435	1400	u2** localvariable_type_table_start;
duke@435	1401	bool parsed_code_attribute = false;
duke@435	1402	bool parsed_checked_exceptions_attribute = false;
duke@435	1403	bool parsed_stackmap_attribute = false;
duke@435	1404	// stackmap attribute - JDK1.5
duke@435	1405	typeArrayHandle stackmap_data;
duke@435	1406	u2 generic_signature_index = 0;
duke@435	1407	u1* runtime_visible_annotations = NULL;
duke@435	1408	int runtime_visible_annotations_length = 0;
duke@435	1409	u1* runtime_invisible_annotations = NULL;
duke@435	1410	int runtime_invisible_annotations_length = 0;
duke@435	1411	u1* runtime_visible_parameter_annotations = NULL;
duke@435	1412	int runtime_visible_parameter_annotations_length = 0;
duke@435	1413	u1* runtime_invisible_parameter_annotations = NULL;
duke@435	1414	int runtime_invisible_parameter_annotations_length = 0;
duke@435	1415	u1* annotation_default = NULL;
duke@435	1416	int annotation_default_length = 0;
duke@435	1417
duke@435	1418	// Parse code and exceptions attribute
duke@435	1419	u2 method_attributes_count = cfs->get_u2_fast();
duke@435	1420	while (method_attributes_count--) {
duke@435	1421	cfs->guarantee_more(6, CHECK_(nullHandle)); // method_attribute_name_index, method_attribute_length
duke@435	1422	u2 method_attribute_name_index = cfs->get_u2_fast();
duke@435	1423	u4 method_attribute_length = cfs->get_u4_fast();
duke@435	1424	check_property(
duke@435	1425	valid_cp_range(method_attribute_name_index, cp_size) &&
duke@435	1426	cp->tag_at(method_attribute_name_index).is_utf8(),
duke@435	1427	"Invalid method attribute name index %u in class file %s",
duke@435	1428	method_attribute_name_index, CHECK_(nullHandle));
duke@435	1429
duke@435	1430	symbolOop method_attribute_name = cp->symbol_at(method_attribute_name_index);
duke@435	1431	if (method_attribute_name == vmSymbols::tag_code()) {
duke@435	1432	// Parse Code attribute
duke@435	1433	if (_need_verify) {
duke@435	1434	guarantee_property(!access_flags.is_native() && !access_flags.is_abstract(),
duke@435	1435	"Code attribute in native or abstract methods in class file %s",
duke@435	1436	CHECK_(nullHandle));
duke@435	1437	}
duke@435	1438	if (parsed_code_attribute) {
duke@435	1439	classfile_parse_error("Multiple Code attributes in class file %s", CHECK_(nullHandle));
duke@435	1440	}
duke@435	1441	parsed_code_attribute = true;
duke@435	1442
duke@435	1443	// Stack size, locals size, and code size
duke@435	1444	if (_major_version == 45 && _minor_version <= 2) {
duke@435	1445	cfs->guarantee_more(4, CHECK_(nullHandle));
duke@435	1446	max_stack = cfs->get_u1_fast();
duke@435	1447	max_locals = cfs->get_u1_fast();
duke@435	1448	code_length = cfs->get_u2_fast();
duke@435	1449	} else {
duke@435	1450	cfs->guarantee_more(8, CHECK_(nullHandle));
duke@435	1451	max_stack = cfs->get_u2_fast();
duke@435	1452	max_locals = cfs->get_u2_fast();
duke@435	1453	code_length = cfs->get_u4_fast();
duke@435	1454	}
duke@435	1455	if (_need_verify) {
duke@435	1456	guarantee_property(args_size <= max_locals,
duke@435	1457	"Arguments can't fit into locals in class file %s", CHECK_(nullHandle));
duke@435	1458	guarantee_property(code_length > 0 && code_length <= MAX_CODE_SIZE,
duke@435	1459	"Invalid method Code length %u in class file %s",
duke@435	1460	code_length, CHECK_(nullHandle));
duke@435	1461	}
duke@435	1462	// Code pointer
duke@435	1463	code_start = cfs->get_u1_buffer();
duke@435	1464	assert(code_start != NULL, "null code start");
duke@435	1465	cfs->guarantee_more(code_length, CHECK_(nullHandle));
duke@435	1466	cfs->skip_u1_fast(code_length);
duke@435	1467
duke@435	1468	// Exception handler table
duke@435	1469	cfs->guarantee_more(2, CHECK_(nullHandle)); // exception_table_length
duke@435	1470	exception_table_length = cfs->get_u2_fast();
duke@435	1471	if (exception_table_length > 0) {
duke@435	1472	exception_handlers =
duke@435	1473	parse_exception_table(code_length, exception_table_length, cp, CHECK_(nullHandle));
duke@435	1474	}
duke@435	1475
duke@435	1476	// Parse additional attributes in code attribute
duke@435	1477	cfs->guarantee_more(2, CHECK_(nullHandle)); // code_attributes_count
duke@435	1478	u2 code_attributes_count = cfs->get_u2_fast();
kamg@527	1479
kamg@527	1480	unsigned int calculated_attribute_length = 0;
kamg@527	1481
kamg@527	1482	if (_major_version > 45 || (_major_version == 45 && _minor_version > 2)) {
kamg@527	1483	calculated_attribute_length =
kamg@527	1484	sizeof(max_stack) + sizeof(max_locals) + sizeof(code_length);
kamg@527	1485	} else {
kamg@527	1486	// max_stack, locals and length are smaller in pre-version 45.2 classes
kamg@527	1487	calculated_attribute_length = sizeof(u1) + sizeof(u1) + sizeof(u2);
kamg@527	1488	}
kamg@527	1489	calculated_attribute_length +=
kamg@527	1490	code_length +
kamg@527	1491	sizeof(exception_table_length) +
kamg@527	1492	sizeof(code_attributes_count) +
kamg@527	1493	exception_table_length *
kamg@527	1494	( sizeof(u2) + // start_pc
kamg@527	1495	sizeof(u2) + // end_pc
kamg@527	1496	sizeof(u2) + // handler_pc
kamg@527	1497	sizeof(u2) ); // catch_type_index
duke@435	1498
duke@435	1499	while (code_attributes_count--) {
duke@435	1500	cfs->guarantee_more(6, CHECK_(nullHandle)); // code_attribute_name_index, code_attribute_length
duke@435	1501	u2 code_attribute_name_index = cfs->get_u2_fast();
duke@435	1502	u4 code_attribute_length = cfs->get_u4_fast();
duke@435	1503	calculated_attribute_length += code_attribute_length +
duke@435	1504	sizeof(code_attribute_name_index) +
duke@435	1505	sizeof(code_attribute_length);
duke@435	1506	check_property(valid_cp_range(code_attribute_name_index, cp_size) &&
duke@435	1507	cp->tag_at(code_attribute_name_index).is_utf8(),
duke@435	1508	"Invalid code attribute name index %u in class file %s",
duke@435	1509	code_attribute_name_index,
duke@435	1510	CHECK_(nullHandle));
duke@435	1511	if (LoadLineNumberTables &&
duke@435	1512	cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) {
duke@435	1513	// Parse and compress line number table
duke@435	1514	parse_linenumber_table(code_attribute_length, code_length,
duke@435	1515	&linenumber_table, CHECK_(nullHandle));
duke@435	1516
duke@435	1517	} else if (LoadLocalVariableTables &&
duke@435	1518	cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) {
duke@435	1519	// Parse local variable table
duke@435	1520	if (!lvt_allocated) {
duke@435	1521	localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1522	THREAD, u2, INITIAL_MAX_LVT_NUMBER);
duke@435	1523	localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1524	THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
duke@435	1525	localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1526	THREAD, u2, INITIAL_MAX_LVT_NUMBER);
duke@435	1527	localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1528	THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
duke@435	1529	lvt_allocated = true;
duke@435	1530	}
duke@435	1531	if (lvt_cnt == max_lvt_cnt) {
duke@435	1532	max_lvt_cnt <<= 1;
duke@435	1533	REALLOC_RESOURCE_ARRAY(u2, localvariable_table_length, lvt_cnt, max_lvt_cnt);
duke@435	1534	REALLOC_RESOURCE_ARRAY(u2*, localvariable_table_start, lvt_cnt, max_lvt_cnt);
duke@435	1535	}
duke@435	1536	localvariable_table_start[lvt_cnt] =
duke@435	1537	parse_localvariable_table(code_length,
duke@435	1538	max_locals,
duke@435	1539	code_attribute_length,
duke@435	1540	cp,
duke@435	1541	&localvariable_table_length[lvt_cnt],
duke@435	1542	false, // is not LVTT
duke@435	1543	CHECK_(nullHandle));
duke@435	1544	total_lvt_length += localvariable_table_length[lvt_cnt];
duke@435	1545	lvt_cnt++;
duke@435	1546	} else if (LoadLocalVariableTypeTables &&
duke@435	1547	_major_version >= JAVA_1_5_VERSION &&
duke@435	1548	cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) {
duke@435	1549	if (!lvt_allocated) {
duke@435	1550	localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1551	THREAD, u2, INITIAL_MAX_LVT_NUMBER);
duke@435	1552	localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1553	THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
duke@435	1554	localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1555	THREAD, u2, INITIAL_MAX_LVT_NUMBER);
duke@435	1556	localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1557	THREAD, u2*, INITIAL_MAX_LVT_NUMBER);
duke@435	1558	lvt_allocated = true;
duke@435	1559	}
duke@435	1560	// Parse local variable type table
duke@435	1561	if (lvtt_cnt == max_lvtt_cnt) {
duke@435	1562	max_lvtt_cnt <<= 1;
duke@435	1563	REALLOC_RESOURCE_ARRAY(u2, localvariable_type_table_length, lvtt_cnt, max_lvtt_cnt);
duke@435	1564	REALLOC_RESOURCE_ARRAY(u2*, localvariable_type_table_start, lvtt_cnt, max_lvtt_cnt);
duke@435	1565	}
duke@435	1566	localvariable_type_table_start[lvtt_cnt] =
duke@435	1567	parse_localvariable_table(code_length,
duke@435	1568	max_locals,
duke@435	1569	code_attribute_length,
duke@435	1570	cp,
duke@435	1571	&localvariable_type_table_length[lvtt_cnt],
duke@435	1572	true, // is LVTT
duke@435	1573	CHECK_(nullHandle));
duke@435	1574	lvtt_cnt++;
duke@435	1575	} else if (UseSplitVerifier &&
duke@435	1576	_major_version >= Verifier::STACKMAP_ATTRIBUTE_MAJOR_VERSION &&
duke@435	1577	cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) {
duke@435	1578	// Stack map is only needed by the new verifier in JDK1.5.
duke@435	1579	if (parsed_stackmap_attribute) {
duke@435	1580	classfile_parse_error("Multiple StackMapTable attributes in class file %s", CHECK_(nullHandle));
duke@435	1581	}
duke@435	1582	typeArrayOop sm =
duke@435	1583	parse_stackmap_table(code_attribute_length, CHECK_(nullHandle));
duke@435	1584	stackmap_data = typeArrayHandle(THREAD, sm);
duke@435	1585	parsed_stackmap_attribute = true;
duke@435	1586	} else {
duke@435	1587	// Skip unknown attributes
duke@435	1588	cfs->skip_u1(code_attribute_length, CHECK_(nullHandle));
duke@435	1589	}
duke@435	1590	}
duke@435	1591	// check method attribute length
duke@435	1592	if (_need_verify) {
duke@435	1593	guarantee_property(method_attribute_length == calculated_attribute_length,
duke@435	1594	"Code segment has wrong length in class file %s", CHECK_(nullHandle));
duke@435	1595	}
duke@435	1596	} else if (method_attribute_name == vmSymbols::tag_exceptions()) {
duke@435	1597	// Parse Exceptions attribute
duke@435	1598	if (parsed_checked_exceptions_attribute) {
duke@435	1599	classfile_parse_error("Multiple Exceptions attributes in class file %s", CHECK_(nullHandle));
duke@435	1600	}
duke@435	1601	parsed_checked_exceptions_attribute = true;
duke@435	1602	checked_exceptions_start =
duke@435	1603	parse_checked_exceptions(&checked_exceptions_length,
duke@435	1604	method_attribute_length,
duke@435	1605	cp, CHECK_(nullHandle));
duke@435	1606	} else if (method_attribute_name == vmSymbols::tag_synthetic()) {
duke@435	1607	if (method_attribute_length != 0) {
duke@435	1608	classfile_parse_error(
duke@435	1609	"Invalid Synthetic method attribute length %u in class file %s",
duke@435	1610	method_attribute_length, CHECK_(nullHandle));
duke@435	1611	}
duke@435	1612	// Should we check that there hasn't already been a synthetic attribute?
duke@435	1613	access_flags.set_is_synthetic();
duke@435	1614	} else if (method_attribute_name == vmSymbols::tag_deprecated()) { // 4276120
duke@435	1615	if (method_attribute_length != 0) {
duke@435	1616	classfile_parse_error(
duke@435	1617	"Invalid Deprecated method attribute length %u in class file %s",
duke@435	1618	method_attribute_length, CHECK_(nullHandle));
duke@435	1619	}
duke@435	1620	} else if (_major_version >= JAVA_1_5_VERSION) {
duke@435	1621	if (method_attribute_name == vmSymbols::tag_signature()) {
duke@435	1622	if (method_attribute_length != 2) {
duke@435	1623	classfile_parse_error(
duke@435	1624	"Invalid Signature attribute length %u in class file %s",
duke@435	1625	method_attribute_length, CHECK_(nullHandle));
duke@435	1626	}
duke@435	1627	cfs->guarantee_more(2, CHECK_(nullHandle)); // generic_signature_index
duke@435	1628	generic_signature_index = cfs->get_u2_fast();
duke@435	1629	} else if (method_attribute_name == vmSymbols::tag_runtime_visible_annotations()) {
duke@435	1630	runtime_visible_annotations_length = method_attribute_length;
duke@435	1631	runtime_visible_annotations = cfs->get_u1_buffer();
duke@435	1632	assert(runtime_visible_annotations != NULL, "null visible annotations");
duke@435	1633	cfs->skip_u1(runtime_visible_annotations_length, CHECK_(nullHandle));
duke@435	1634	} else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {
duke@435	1635	runtime_invisible_annotations_length = method_attribute_length;
duke@435	1636	runtime_invisible_annotations = cfs->get_u1_buffer();
duke@435	1637	assert(runtime_invisible_annotations != NULL, "null invisible annotations");
duke@435	1638	cfs->skip_u1(runtime_invisible_annotations_length, CHECK_(nullHandle));
duke@435	1639	} else if (method_attribute_name == vmSymbols::tag_runtime_visible_parameter_annotations()) {
duke@435	1640	runtime_visible_parameter_annotations_length = method_attribute_length;
duke@435	1641	runtime_visible_parameter_annotations = cfs->get_u1_buffer();
duke@435	1642	assert(runtime_visible_parameter_annotations != NULL, "null visible parameter annotations");
duke@435	1643	cfs->skip_u1(runtime_visible_parameter_annotations_length, CHECK_(nullHandle));
duke@435	1644	} else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_parameter_annotations()) {
duke@435	1645	runtime_invisible_parameter_annotations_length = method_attribute_length;
duke@435	1646	runtime_invisible_parameter_annotations = cfs->get_u1_buffer();
duke@435	1647	assert(runtime_invisible_parameter_annotations != NULL, "null invisible parameter annotations");
duke@435	1648	cfs->skip_u1(runtime_invisible_parameter_annotations_length, CHECK_(nullHandle));
duke@435	1649	} else if (method_attribute_name == vmSymbols::tag_annotation_default()) {
duke@435	1650	annotation_default_length = method_attribute_length;
duke@435	1651	annotation_default = cfs->get_u1_buffer();
duke@435	1652	assert(annotation_default != NULL, "null annotation default");
duke@435	1653	cfs->skip_u1(annotation_default_length, CHECK_(nullHandle));
duke@435	1654	} else {
duke@435	1655	// Skip unknown attributes
duke@435	1656	cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
duke@435	1657	}
duke@435	1658	} else {
duke@435	1659	// Skip unknown attributes
duke@435	1660	cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
duke@435	1661	}
duke@435	1662	}
duke@435	1663
duke@435	1664	if (linenumber_table != NULL) {
duke@435	1665	linenumber_table->write_terminator();
duke@435	1666	linenumber_table_length = linenumber_table->position();
duke@435	1667	}
duke@435	1668
duke@435	1669	// Make sure there's at least one Code attribute in non-native/non-abstract method
duke@435	1670	if (_need_verify) {
duke@435	1671	guarantee_property(access_flags.is_native() || access_flags.is_abstract() || parsed_code_attribute,
duke@435	1672	"Absent Code attribute in method that is not native or abstract in class file %s", CHECK_(nullHandle));
duke@435	1673	}
duke@435	1674
duke@435	1675	// All sizing information for a methodOop is finally available, now create it
duke@435	1676	methodOop m_oop = oopFactory::new_method(
duke@435	1677	code_length, access_flags, linenumber_table_length,
duke@435	1678	total_lvt_length, checked_exceptions_length, CHECK_(nullHandle));
duke@435	1679	methodHandle m (THREAD, m_oop);
duke@435	1680
duke@435	1681	ClassLoadingService::add_class_method_size(m_oop->size()*HeapWordSize);
duke@435	1682
duke@435	1683	// Fill in information from fixed part (access_flags already set)
duke@435	1684	m->set_constants(cp());
duke@435	1685	m->set_name_index(name_index);
duke@435	1686	m->set_signature_index(signature_index);
duke@435	1687	m->set_generic_signature_index(generic_signature_index);
duke@435	1688	#ifdef CC_INTERP
duke@435	1689	// hmm is there a gc issue here??
duke@435	1690	ResultTypeFinder rtf(cp->symbol_at(signature_index));
duke@435	1691	m->set_result_index(rtf.type());
duke@435	1692	#endif
duke@435	1693
duke@435	1694	if (args_size >= 0) {
duke@435	1695	m->set_size_of_parameters(args_size);
duke@435	1696	} else {
duke@435	1697	m->compute_size_of_parameters(THREAD);
duke@435	1698	}
duke@435	1699	#ifdef ASSERT
duke@435	1700	if (args_size >= 0) {
duke@435	1701	m->compute_size_of_parameters(THREAD);
duke@435	1702	assert(args_size == m->size_of_parameters(), "");
duke@435	1703	}
duke@435	1704	#endif
duke@435	1705
duke@435	1706	// Fill in code attribute information
duke@435	1707	m->set_max_stack(max_stack);
duke@435	1708	m->set_max_locals(max_locals);
duke@435	1709	m->constMethod()->set_stackmap_data(stackmap_data());
duke@435	1710
duke@435	1711	/**
duke@435	1712	* The exception_table field is the flag used to indicate
duke@435	1713	* that the methodOop and it's associated constMethodOop are partially
duke@435	1714	* initialized and thus are exempt from pre/post GC verification. Once
duke@435	1715	* the field is set, the oops are considered fully initialized so make
duke@435	1716	* sure that the oops can pass verification when this field is set.
duke@435	1717	*/
duke@435	1718	m->set_exception_table(exception_handlers());
duke@435	1719
duke@435	1720	// Copy byte codes
duke@435	1721	if (code_length > 0) {
duke@435	1722	memcpy(m->code_base(), code_start, code_length);
duke@435	1723	}
duke@435	1724
duke@435	1725	// Copy line number table
duke@435	1726	if (linenumber_table != NULL) {
duke@435	1727	memcpy(m->compressed_linenumber_table(),
duke@435	1728	linenumber_table->buffer(), linenumber_table_length);
duke@435	1729	}
duke@435	1730
duke@435	1731	// Copy checked exceptions
duke@435	1732	if (checked_exceptions_length > 0) {
duke@435	1733	int size = checked_exceptions_length * sizeof(CheckedExceptionElement) / sizeof(u2);
duke@435	1734	copy_u2_with_conversion((u2*) m->checked_exceptions_start(), checked_exceptions_start, size);
duke@435	1735	}
duke@435	1736
duke@435	1737	/* Copy class file LVT's/LVTT's into the HotSpot internal LVT.
duke@435	1738	*
duke@435	1739	* Rules for LVT's and LVTT's are:
duke@435	1740	* - There can be any number of LVT's and LVTT's.
duke@435	1741	* - If there are n LVT's, it is the same as if there was just
duke@435	1742	* one LVT containing all the entries from the n LVT's.
duke@435	1743	* - There may be no more than one LVT entry per local variable.
duke@435	1744	* Two LVT entries are 'equal' if these fields are the same:
duke@435	1745	* start_pc, length, name, slot
duke@435	1746	* - There may be no more than one LVTT entry per each LVT entry.
duke@435	1747	* Each LVTT entry has to match some LVT entry.
duke@435	1748	* - HotSpot internal LVT keeps natural ordering of class file LVT entries.
duke@435	1749	*/
duke@435	1750	if (total_lvt_length > 0) {
duke@435	1751	int tbl_no, idx;
duke@435	1752
duke@435	1753	promoted_flags->set_has_localvariable_table();
duke@435	1754
duke@435	1755	LVT_Hash** lvt_Hash = NEW_RESOURCE_ARRAY(LVT_Hash*, HASH_ROW_SIZE);
duke@435	1756	initialize_hashtable(lvt_Hash);
duke@435	1757
duke@435	1758	// To fill LocalVariableTable in
duke@435	1759	Classfile_LVT_Element* cf_lvt;
duke@435	1760	LocalVariableTableElement* lvt = m->localvariable_table_start();
duke@435	1761
duke@435	1762	for (tbl_no = 0; tbl_no < lvt_cnt; tbl_no++) {
duke@435	1763	cf_lvt = (Classfile_LVT_Element *) localvariable_table_start[tbl_no];
duke@435	1764	for (idx = 0; idx < localvariable_table_length[tbl_no]; idx++, lvt++) {
duke@435	1765	copy_lvt_element(&cf_lvt[idx], lvt);
duke@435	1766	// If no duplicates, add LVT elem in hashtable lvt_Hash.
duke@435	1767	if (LVT_put_after_lookup(lvt, lvt_Hash) == false
duke@435	1768	&& _need_verify
duke@435	1769	&& _major_version >= JAVA_1_5_VERSION ) {
duke@435	1770	clear_hashtable(lvt_Hash);
duke@435	1771	classfile_parse_error("Duplicated LocalVariableTable attribute "
duke@435	1772	"entry for '%s' in class file %s",
duke@435	1773	cp->symbol_at(lvt->name_cp_index)->as_utf8(),
duke@435	1774	CHECK_(nullHandle));
duke@435	1775	}
duke@435	1776	}
duke@435	1777	}
duke@435	1778
duke@435	1779	// To merge LocalVariableTable and LocalVariableTypeTable
duke@435	1780	Classfile_LVT_Element* cf_lvtt;
duke@435	1781	LocalVariableTableElement lvtt_elem;
duke@435	1782
duke@435	1783	for (tbl_no = 0; tbl_no < lvtt_cnt; tbl_no++) {
duke@435	1784	cf_lvtt = (Classfile_LVT_Element *) localvariable_type_table_start[tbl_no];
duke@435	1785	for (idx = 0; idx < localvariable_type_table_length[tbl_no]; idx++) {
duke@435	1786	copy_lvt_element(&cf_lvtt[idx], &lvtt_elem);
duke@435	1787	int index = hash(&lvtt_elem);
duke@435	1788	LVT_Hash* entry = LVT_lookup(&lvtt_elem, index, lvt_Hash);
duke@435	1789	if (entry == NULL) {
duke@435	1790	if (_need_verify) {
duke@435	1791	clear_hashtable(lvt_Hash);
duke@435	1792	classfile_parse_error("LVTT entry for '%s' in class file %s "
duke@435	1793	"does not match any LVT entry",
duke@435	1794	cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
duke@435	1795	CHECK_(nullHandle));
duke@435	1796	}
duke@435	1797	} else if (entry->_elem->signature_cp_index != 0 && _need_verify) {
duke@435	1798	clear_hashtable(lvt_Hash);
duke@435	1799	classfile_parse_error("Duplicated LocalVariableTypeTable attribute "
duke@435	1800	"entry for '%s' in class file %s",
duke@435	1801	cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),
duke@435	1802	CHECK_(nullHandle));
duke@435	1803	} else {
duke@435	1804	// to add generic signatures into LocalVariableTable
duke@435	1805	entry->_elem->signature_cp_index = lvtt_elem.descriptor_cp_index;
duke@435	1806	}
duke@435	1807	}
duke@435	1808	}
duke@435	1809	clear_hashtable(lvt_Hash);
duke@435	1810	}
duke@435	1811
duke@435	1812	*method_annotations = assemble_annotations(runtime_visible_annotations,
duke@435	1813	runtime_visible_annotations_length,
duke@435	1814	runtime_invisible_annotations,
duke@435	1815	runtime_invisible_annotations_length,
duke@435	1816	CHECK_(nullHandle));
duke@435	1817	*method_parameter_annotations = assemble_annotations(runtime_visible_parameter_annotations,
duke@435	1818	runtime_visible_parameter_annotations_length,
duke@435	1819	runtime_invisible_parameter_annotations,
duke@435	1820	runtime_invisible_parameter_annotations_length,
duke@435	1821	CHECK_(nullHandle));
duke@435	1822	*method_default_annotations = assemble_annotations(annotation_default,
duke@435	1823	annotation_default_length,
duke@435	1824	NULL,
duke@435	1825	0,
duke@435	1826	CHECK_(nullHandle));
duke@435	1827
duke@435	1828	if (name() == vmSymbols::finalize_method_name() &&
duke@435	1829	signature() == vmSymbols::void_method_signature()) {
duke@435	1830	if (m->is_empty_method()) {
duke@435	1831	_has_empty_finalizer = true;
duke@435	1832	} else {
duke@435	1833	_has_finalizer = true;
duke@435	1834	}
duke@435	1835	}
duke@435	1836	if (name() == vmSymbols::object_initializer_name() &&
duke@435	1837	signature() == vmSymbols::void_method_signature() &&
duke@435	1838	m->is_vanilla_constructor()) {
duke@435	1839	_has_vanilla_constructor = true;
duke@435	1840	}
duke@435	1841
duke@435	1842	return m;
duke@435	1843	}
duke@435	1844
duke@435	1845
duke@435	1846	// The promoted_flags parameter is used to pass relevant access_flags
duke@435	1847	// from the methods back up to the containing klass. These flag values
duke@435	1848	// are added to klass's access_flags.
duke@435	1849
duke@435	1850	objArrayHandle ClassFileParser::parse_methods(constantPoolHandle cp, bool is_interface,
duke@435	1851	AccessFlags* promoted_flags,
duke@435	1852	bool* has_final_method,
duke@435	1853	objArrayOop* methods_annotations_oop,
duke@435	1854	objArrayOop* methods_parameter_annotations_oop,
duke@435	1855	objArrayOop* methods_default_annotations_oop,
duke@435	1856	TRAPS) {
duke@435	1857	ClassFileStream* cfs = stream();
duke@435	1858	objArrayHandle nullHandle;
duke@435	1859	typeArrayHandle method_annotations;
duke@435	1860	typeArrayHandle method_parameter_annotations;
duke@435	1861	typeArrayHandle method_default_annotations;
duke@435	1862	cfs->guarantee_more(2, CHECK_(nullHandle)); // length
duke@435	1863	u2 length = cfs->get_u2_fast();
duke@435	1864	if (length == 0) {
duke@435	1865	return objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
duke@435	1866	} else {
duke@435	1867	objArrayOop m = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
duke@435	1868	objArrayHandle methods(THREAD, m);
duke@435	1869	HandleMark hm(THREAD);
duke@435	1870	objArrayHandle methods_annotations;
duke@435	1871	objArrayHandle methods_parameter_annotations;
duke@435	1872	objArrayHandle methods_default_annotations;
duke@435	1873	for (int index = 0; index < length; index++) {
duke@435	1874	methodHandle method = parse_method(cp, is_interface,
duke@435	1875	promoted_flags,
duke@435	1876	&method_annotations,
duke@435	1877	&method_parameter_annotations,
duke@435	1878	&method_default_annotations,
duke@435	1879	CHECK_(nullHandle));
duke@435	1880	if (method->is_final()) {
duke@435	1881	*has_final_method = true;
duke@435	1882	}
duke@435	1883	methods->obj_at_put(index, method());
duke@435	1884	if (method_annotations.not_null()) {
duke@435	1885	if (methods_annotations.is_null()) {
duke@435	1886	objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
duke@435	1887	methods_annotations = objArrayHandle(THREAD, md);
duke@435	1888	}
duke@435	1889	methods_annotations->obj_at_put(index, method_annotations());
duke@435	1890	}
duke@435	1891	if (method_parameter_annotations.not_null()) {
duke@435	1892	if (methods_parameter_annotations.is_null()) {
duke@435	1893	objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
duke@435	1894	methods_parameter_annotations = objArrayHandle(THREAD, md);
duke@435	1895	}
duke@435	1896	methods_parameter_annotations->obj_at_put(index, method_parameter_annotations());
duke@435	1897	}
duke@435	1898	if (method_default_annotations.not_null()) {
duke@435	1899	if (methods_default_annotations.is_null()) {
duke@435	1900	objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));
duke@435	1901	methods_default_annotations = objArrayHandle(THREAD, md);
duke@435	1902	}
duke@435	1903	methods_default_annotations->obj_at_put(index, method_default_annotations());
duke@435	1904	}
duke@435	1905	}
duke@435	1906	if (_need_verify && length > 1) {
duke@435	1907	// Check duplicated methods
duke@435	1908	ResourceMark rm(THREAD);
duke@435	1909	NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	1910	THREAD, NameSigHash*, HASH_ROW_SIZE);
duke@435	1911	initialize_hashtable(names_and_sigs);
duke@435	1912	bool dup = false;
duke@435	1913	{
duke@435	1914	debug_only(No_Safepoint_Verifier nsv;)
duke@435	1915	for (int i = 0; i < length; i++) {
duke@435	1916	methodOop m = (methodOop)methods->obj_at(i);
duke@435	1917	// If no duplicates, add name/signature in hashtable names_and_sigs.
duke@435	1918	if (!put_after_lookup(m->name(), m->signature(), names_and_sigs)) {
duke@435	1919	dup = true;
duke@435	1920	break;
duke@435	1921	}
duke@435	1922	}
duke@435	1923	}
duke@435	1924	if (dup) {
duke@435	1925	classfile_parse_error("Duplicate method name&signature in class file %s",
duke@435	1926	CHECK_(nullHandle));
duke@435	1927	}
duke@435	1928	}
duke@435	1929
duke@435	1930	*methods_annotations_oop = methods_annotations();
duke@435	1931	*methods_parameter_annotations_oop = methods_parameter_annotations();
duke@435	1932	*methods_default_annotations_oop = methods_default_annotations();
duke@435	1933
duke@435	1934	return methods;
duke@435	1935	}
duke@435	1936	}
duke@435	1937
duke@435	1938
duke@435	1939	typeArrayHandle ClassFileParser::sort_methods(objArrayHandle methods,
duke@435	1940	objArrayHandle methods_annotations,
duke@435	1941	objArrayHandle methods_parameter_annotations,
duke@435	1942	objArrayHandle methods_default_annotations,
duke@435	1943	TRAPS) {
duke@435	1944	typeArrayHandle nullHandle;
duke@435	1945	int length = methods()->length();
duke@435	1946	// If JVMTI original method ordering is enabled we have to
duke@435	1947	// remember the original class file ordering.
duke@435	1948	// We temporarily use the vtable_index field in the methodOop to store the
duke@435	1949	// class file index, so we can read in after calling qsort.
duke@435	1950	if (JvmtiExport::can_maintain_original_method_order()) {
duke@435	1951	for (int index = 0; index < length; index++) {
duke@435	1952	methodOop m = methodOop(methods->obj_at(index));
duke@435	1953	assert(!m->valid_vtable_index(), "vtable index should not be set");
duke@435	1954	m->set_vtable_index(index);
duke@435	1955	}
duke@435	1956	}
duke@435	1957	// Sort method array by ascending method name (for faster lookups & vtable construction)
duke@435	1958	// Note that the ordering is not alphabetical, see symbolOopDesc::fast_compare
duke@435	1959	methodOopDesc::sort_methods(methods(),
duke@435	1960	methods_annotations(),
duke@435	1961	methods_parameter_annotations(),
duke@435	1962	methods_default_annotations());
duke@435	1963
duke@435	1964	// If JVMTI original method ordering is enabled construct int array remembering the original ordering
duke@435	1965	if (JvmtiExport::can_maintain_original_method_order()) {
duke@435	1966	typeArrayOop new_ordering = oopFactory::new_permanent_intArray(length, CHECK_(nullHandle));
duke@435	1967	typeArrayHandle method_ordering(THREAD, new_ordering);
duke@435	1968	for (int index = 0; index < length; index++) {
duke@435	1969	methodOop m = methodOop(methods->obj_at(index));
duke@435	1970	int old_index = m->vtable_index();
duke@435	1971	assert(old_index >= 0 && old_index < length, "invalid method index");
duke@435	1972	method_ordering->int_at_put(index, old_index);
duke@435	1973	m->set_vtable_index(methodOopDesc::invalid_vtable_index);
duke@435	1974	}
duke@435	1975	return method_ordering;
duke@435	1976	} else {
duke@435	1977	return typeArrayHandle(THREAD, Universe::the_empty_int_array());
duke@435	1978	}
duke@435	1979	}
duke@435	1980
duke@435	1981
duke@435	1982	void ClassFileParser::parse_classfile_sourcefile_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
duke@435	1983	ClassFileStream* cfs = stream();
duke@435	1984	cfs->guarantee_more(2, CHECK); // sourcefile_index
duke@435	1985	u2 sourcefile_index = cfs->get_u2_fast();
duke@435	1986	check_property(
duke@435	1987	valid_cp_range(sourcefile_index, cp->length()) &&
duke@435	1988	cp->tag_at(sourcefile_index).is_utf8(),
duke@435	1989	"Invalid SourceFile attribute at constant pool index %u in class file %s",
duke@435	1990	sourcefile_index, CHECK);
duke@435	1991	k->set_source_file_name(cp->symbol_at(sourcefile_index));
duke@435	1992	}
duke@435	1993
duke@435	1994
duke@435	1995
duke@435	1996	void ClassFileParser::parse_classfile_source_debug_extension_attribute(constantPoolHandle cp,
duke@435	1997	instanceKlassHandle k,
duke@435	1998	int length, TRAPS) {
duke@435	1999	ClassFileStream* cfs = stream();
duke@435	2000	u1* sde_buffer = cfs->get_u1_buffer();
duke@435	2001	assert(sde_buffer != NULL, "null sde buffer");
duke@435	2002
duke@435	2003	// Don't bother storing it if there is no way to retrieve it
duke@435	2004	if (JvmtiExport::can_get_source_debug_extension()) {
duke@435	2005	// Optimistically assume that only 1 byte UTF format is used
duke@435	2006	// (common case)
duke@435	2007	symbolOop sde_symbol = oopFactory::new_symbol((char*)sde_buffer,
duke@435	2008	length, CHECK);
duke@435	2009	k->set_source_debug_extension(sde_symbol);
duke@435	2010	}
duke@435	2011	// Got utf8 string, set stream position forward
duke@435	2012	cfs->skip_u1(length, CHECK);
duke@435	2013	}
duke@435	2014
duke@435	2015
duke@435	2016	// Inner classes can be static, private or protected (classic VM does this)
duke@435	2017	#define RECOGNIZED_INNER_CLASS_MODIFIERS (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED | JVM_ACC_STATIC)
duke@435	2018
duke@435	2019	// Return number of classes in the inner classes attribute table
duke@435	2020	u2 ClassFileParser::parse_classfile_inner_classes_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
duke@435	2021	ClassFileStream* cfs = stream();
duke@435	2022	cfs->guarantee_more(2, CHECK_0); // length
duke@435	2023	u2 length = cfs->get_u2_fast();
duke@435	2024
duke@435	2025	// 4-tuples of shorts [inner_class_info_index, outer_class_info_index, inner_name_index, inner_class_access_flags]
duke@435	2026	typeArrayOop ic = oopFactory::new_permanent_shortArray(length*4, CHECK_0);
duke@435	2027	typeArrayHandle inner_classes(THREAD, ic);
duke@435	2028	int index = 0;
duke@435	2029	int cp_size = cp->length();
duke@435	2030	cfs->guarantee_more(8 * length, CHECK_0); // 4-tuples of u2
duke@435	2031	for (int n = 0; n < length; n++) {
duke@435	2032	// Inner class index
duke@435	2033	u2 inner_class_info_index = cfs->get_u2_fast();
duke@435	2034	check_property(
duke@435	2035	inner_class_info_index == 0 ||
duke@435	2036	(valid_cp_range(inner_class_info_index, cp_size) &&
jrose@866	2037	is_klass_reference(cp, inner_class_info_index)),
duke@435	2038	"inner_class_info_index %u has bad constant type in class file %s",
duke@435	2039	inner_class_info_index, CHECK_0);
duke@435	2040	// Outer class index
duke@435	2041	u2 outer_class_info_index = cfs->get_u2_fast();
duke@435	2042	check_property(
duke@435	2043	outer_class_info_index == 0 ||
duke@435	2044	(valid_cp_range(outer_class_info_index, cp_size) &&
jrose@866	2045	is_klass_reference(cp, outer_class_info_index)),
duke@435	2046	"outer_class_info_index %u has bad constant type in class file %s",
duke@435	2047	outer_class_info_index, CHECK_0);
duke@435	2048	// Inner class name
duke@435	2049	u2 inner_name_index = cfs->get_u2_fast();
duke@435	2050	check_property(
duke@435	2051	inner_name_index == 0 || (valid_cp_range(inner_name_index, cp_size) &&
duke@435	2052	cp->tag_at(inner_name_index).is_utf8()),
duke@435	2053	"inner_name_index %u has bad constant type in class file %s",
duke@435	2054	inner_name_index, CHECK_0);
duke@435	2055	if (_need_verify) {
duke@435	2056	guarantee_property(inner_class_info_index != outer_class_info_index,
duke@435	2057	"Class is both outer and inner class in class file %s", CHECK_0);
duke@435	2058	}
duke@435	2059	// Access flags
duke@435	2060	AccessFlags inner_access_flags;
duke@435	2061	jint flags = cfs->get_u2_fast() & RECOGNIZED_INNER_CLASS_MODIFIERS;
duke@435	2062	if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
duke@435	2063	// Set abstract bit for old class files for backward compatibility
duke@435	2064	flags |= JVM_ACC_ABSTRACT;
duke@435	2065	}
duke@435	2066	verify_legal_class_modifiers(flags, CHECK_0);
duke@435	2067	inner_access_flags.set_flags(flags);
duke@435	2068
duke@435	2069	inner_classes->short_at_put(index++, inner_class_info_index);
duke@435	2070	inner_classes->short_at_put(index++, outer_class_info_index);
duke@435	2071	inner_classes->short_at_put(index++, inner_name_index);
duke@435	2072	inner_classes->short_at_put(index++, inner_access_flags.as_short());
duke@435	2073	}
duke@435	2074
duke@435	2075	// 4347400: make sure there's no duplicate entry in the classes array
duke@435	2076	if (_need_verify && _major_version >= JAVA_1_5_VERSION) {
duke@435	2077	for(int i = 0; i < inner_classes->length(); i += 4) {
duke@435	2078	for(int j = i + 4; j < inner_classes->length(); j += 4) {
duke@435	2079	guarantee_property((inner_classes->ushort_at(i) != inner_classes->ushort_at(j) ||
duke@435	2080	inner_classes->ushort_at(i+1) != inner_classes->ushort_at(j+1) ||
duke@435	2081	inner_classes->ushort_at(i+2) != inner_classes->ushort_at(j+2) ||
duke@435	2082	inner_classes->ushort_at(i+3) != inner_classes->ushort_at(j+3)),
duke@435	2083	"Duplicate entry in InnerClasses in class file %s",
duke@435	2084	CHECK_0);
duke@435	2085	}
duke@435	2086	}
duke@435	2087	}
duke@435	2088
duke@435	2089	// Update instanceKlass with inner class info.
duke@435	2090	k->set_inner_classes(inner_classes());
duke@435	2091	return length;
duke@435	2092	}
duke@435	2093
duke@435	2094	void ClassFileParser::parse_classfile_synthetic_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
duke@435	2095	k->set_is_synthetic();
duke@435	2096	}
duke@435	2097
duke@435	2098	void ClassFileParser::parse_classfile_signature_attribute(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
duke@435	2099	ClassFileStream* cfs = stream();
duke@435	2100	u2 signature_index = cfs->get_u2(CHECK);
duke@435	2101	check_property(
duke@435	2102	valid_cp_range(signature_index, cp->length()) &&
duke@435	2103	cp->tag_at(signature_index).is_utf8(),
duke@435	2104	"Invalid constant pool index %u in Signature attribute in class file %s",
duke@435	2105	signature_index, CHECK);
duke@435	2106	k->set_generic_signature(cp->symbol_at(signature_index));
duke@435	2107	}
duke@435	2108
duke@435	2109	void ClassFileParser::parse_classfile_attributes(constantPoolHandle cp, instanceKlassHandle k, TRAPS) {
duke@435	2110	ClassFileStream* cfs = stream();
duke@435	2111	// Set inner classes attribute to default sentinel
duke@435	2112	k->set_inner_classes(Universe::the_empty_short_array());
duke@435	2113	cfs->guarantee_more(2, CHECK); // attributes_count
duke@435	2114	u2 attributes_count = cfs->get_u2_fast();
duke@435	2115	bool parsed_sourcefile_attribute = false;
duke@435	2116	bool parsed_innerclasses_attribute = false;
duke@435	2117	bool parsed_enclosingmethod_attribute = false;
duke@435	2118	u1* runtime_visible_annotations = NULL;
duke@435	2119	int runtime_visible_annotations_length = 0;
duke@435	2120	u1* runtime_invisible_annotations = NULL;
duke@435	2121	int runtime_invisible_annotations_length = 0;
duke@435	2122	// Iterate over attributes
duke@435	2123	while (attributes_count--) {
duke@435	2124	cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length
duke@435	2125	u2 attribute_name_index = cfs->get_u2_fast();
duke@435	2126	u4 attribute_length = cfs->get_u4_fast();
duke@435	2127	check_property(
duke@435	2128	valid_cp_range(attribute_name_index, cp->length()) &&
duke@435	2129	cp->tag_at(attribute_name_index).is_utf8(),
duke@435	2130	"Attribute name has bad constant pool index %u in class file %s",
duke@435	2131	attribute_name_index, CHECK);
duke@435	2132	symbolOop tag = cp->symbol_at(attribute_name_index);
duke@435	2133	if (tag == vmSymbols::tag_source_file()) {
duke@435	2134	// Check for SourceFile tag
duke@435	2135	if (_need_verify) {
duke@435	2136	guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK);
duke@435	2137	}
duke@435	2138	if (parsed_sourcefile_attribute) {
duke@435	2139	classfile_parse_error("Multiple SourceFile attributes in class file %s", CHECK);
duke@435	2140	} else {
duke@435	2141	parsed_sourcefile_attribute = true;
duke@435	2142	}
duke@435	2143	parse_classfile_sourcefile_attribute(cp, k, CHECK);
duke@435	2144	} else if (tag == vmSymbols::tag_source_debug_extension()) {
duke@435	2145	// Check for SourceDebugExtension tag
duke@435	2146	parse_classfile_source_debug_extension_attribute(cp, k, (int)attribute_length, CHECK);
duke@435	2147	} else if (tag == vmSymbols::tag_inner_classes()) {
duke@435	2148	// Check for InnerClasses tag
duke@435	2149	if (parsed_innerclasses_attribute) {
duke@435	2150	classfile_parse_error("Multiple InnerClasses attributes in class file %s", CHECK);
duke@435	2151	} else {
duke@435	2152	parsed_innerclasses_attribute = true;
duke@435	2153	}
duke@435	2154	u2 num_of_classes = parse_classfile_inner_classes_attribute(cp, k, CHECK);
duke@435	2155	if (_need_verify && _major_version >= JAVA_1_5_VERSION) {
duke@435	2156	guarantee_property(attribute_length == sizeof(num_of_classes) + 4 * sizeof(u2) * num_of_classes,
duke@435	2157	"Wrong InnerClasses attribute length in class file %s", CHECK);
duke@435	2158	}
duke@435	2159	} else if (tag == vmSymbols::tag_synthetic()) {
duke@435	2160	// Check for Synthetic tag
duke@435	2161	// Shouldn't we check that the synthetic flags wasn't already set? - not required in spec
duke@435	2162	if (attribute_length != 0) {
duke@435	2163	classfile_parse_error(
duke@435	2164	"Invalid Synthetic classfile attribute length %u in class file %s",
duke@435	2165	attribute_length, CHECK);
duke@435	2166	}
duke@435	2167	parse_classfile_synthetic_attribute(cp, k, CHECK);
duke@435	2168	} else if (tag == vmSymbols::tag_deprecated()) {
duke@435	2169	// Check for Deprecatd tag - 4276120
duke@435	2170	if (attribute_length != 0) {
duke@435	2171	classfile_parse_error(
duke@435	2172	"Invalid Deprecated classfile attribute length %u in class file %s",
duke@435	2173	attribute_length, CHECK);
duke@435	2174	}
duke@435	2175	} else if (_major_version >= JAVA_1_5_VERSION) {
duke@435	2176	if (tag == vmSymbols::tag_signature()) {
duke@435	2177	if (attribute_length != 2) {
duke@435	2178	classfile_parse_error(
duke@435	2179	"Wrong Signature attribute length %u in class file %s",
duke@435	2180	attribute_length, CHECK);
duke@435	2181	}
duke@435	2182	parse_classfile_signature_attribute(cp, k, CHECK);
duke@435	2183	} else if (tag == vmSymbols::tag_runtime_visible_annotations()) {
duke@435	2184	runtime_visible_annotations_length = attribute_length;
duke@435	2185	runtime_visible_annotations = cfs->get_u1_buffer();
duke@435	2186	assert(runtime_visible_annotations != NULL, "null visible annotations");
duke@435	2187	cfs->skip_u1(runtime_visible_annotations_length, CHECK);
duke@435	2188	} else if (PreserveAllAnnotations && tag == vmSymbols::tag_runtime_invisible_annotations()) {
duke@435	2189	runtime_invisible_annotations_length = attribute_length;
duke@435	2190	runtime_invisible_annotations = cfs->get_u1_buffer();
duke@435	2191	assert(runtime_invisible_annotations != NULL, "null invisible annotations");
duke@435	2192	cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
duke@435	2193	} else if (tag == vmSymbols::tag_enclosing_method()) {
duke@435	2194	if (parsed_enclosingmethod_attribute) {
duke@435	2195	classfile_parse_error("Multiple EnclosingMethod attributes in class file %s", CHECK);
duke@435	2196	} else {
duke@435	2197	parsed_enclosingmethod_attribute = true;
duke@435	2198	}
duke@435	2199	cfs->guarantee_more(4, CHECK); // class_index, method_index
duke@435	2200	u2 class_index = cfs->get_u2_fast();
duke@435	2201	u2 method_index = cfs->get_u2_fast();
duke@435	2202	if (class_index == 0) {
duke@435	2203	classfile_parse_error("Invalid class index in EnclosingMethod attribute in class file %s", CHECK);
duke@435	2204	}
duke@435	2205	// Validate the constant pool indices and types
duke@435	2206	if (!cp->is_within_bounds(class_index) ||
jrose@866	2207	!is_klass_reference(cp, class_index)) {
duke@435	2208	classfile_parse_error("Invalid or out-of-bounds class index in EnclosingMethod attribute in class file %s", CHECK);
duke@435	2209	}
duke@435	2210	if (method_index != 0 &&
duke@435	2211	(!cp->is_within_bounds(method_index) ||
duke@435	2212	!cp->tag_at(method_index).is_name_and_type())) {
duke@435	2213	classfile_parse_error("Invalid or out-of-bounds method index in EnclosingMethod attribute in class file %s", CHECK);
duke@435	2214	}
duke@435	2215	k->set_enclosing_method_indices(class_index, method_index);
duke@435	2216	} else {
duke@435	2217	// Unknown attribute
duke@435	2218	cfs->skip_u1(attribute_length, CHECK);
duke@435	2219	}
duke@435	2220	} else {
duke@435	2221	// Unknown attribute
duke@435	2222	cfs->skip_u1(attribute_length, CHECK);
duke@435	2223	}
duke@435	2224	}
duke@435	2225	typeArrayHandle annotations = assemble_annotations(runtime_visible_annotations,
duke@435	2226	runtime_visible_annotations_length,
duke@435	2227	runtime_invisible_annotations,
duke@435	2228	runtime_invisible_annotations_length,
duke@435	2229	CHECK);
duke@435	2230	k->set_class_annotations(annotations());
duke@435	2231	}
duke@435	2232
duke@435	2233
duke@435	2234	typeArrayHandle ClassFileParser::assemble_annotations(u1* runtime_visible_annotations,
duke@435	2235	int runtime_visible_annotations_length,
duke@435	2236	u1* runtime_invisible_annotations,
duke@435	2237	int runtime_invisible_annotations_length, TRAPS) {
duke@435	2238	typeArrayHandle annotations;
duke@435	2239	if (runtime_visible_annotations != NULL ||
duke@435	2240	runtime_invisible_annotations != NULL) {
duke@435	2241	typeArrayOop anno = oopFactory::new_permanent_byteArray(runtime_visible_annotations_length +
duke@435	2242	runtime_invisible_annotations_length, CHECK_(annotations));
duke@435	2243	annotations = typeArrayHandle(THREAD, anno);
duke@435	2244	if (runtime_visible_annotations != NULL) {
duke@435	2245	memcpy(annotations->byte_at_addr(0), runtime_visible_annotations, runtime_visible_annotations_length);
duke@435	2246	}
duke@435	2247	if (runtime_invisible_annotations != NULL) {
duke@435	2248	memcpy(annotations->byte_at_addr(runtime_visible_annotations_length), runtime_invisible_annotations, runtime_invisible_annotations_length);
duke@435	2249	}
duke@435	2250	}
duke@435	2251	return annotations;
duke@435	2252	}
duke@435	2253
duke@435	2254
duke@435	2255	static void initialize_static_field(fieldDescriptor* fd, TRAPS) {
duke@435	2256	KlassHandle h_k (THREAD, fd->field_holder());
duke@435	2257	assert(h_k.not_null() && fd->is_static(), "just checking");
duke@435	2258	if (fd->has_initial_value()) {
duke@435	2259	BasicType t = fd->field_type();
duke@435	2260	switch (t) {
duke@435	2261	case T_BYTE:
duke@435	2262	h_k()->byte_field_put(fd->offset(), fd->int_initial_value());
duke@435	2263	break;
duke@435	2264	case T_BOOLEAN:
duke@435	2265	h_k()->bool_field_put(fd->offset(), fd->int_initial_value());
duke@435	2266	break;
duke@435	2267	case T_CHAR:
duke@435	2268	h_k()->char_field_put(fd->offset(), fd->int_initial_value());
duke@435	2269	break;
duke@435	2270	case T_SHORT:
duke@435	2271	h_k()->short_field_put(fd->offset(), fd->int_initial_value());
duke@435	2272	break;
duke@435	2273	case T_INT:
duke@435	2274	h_k()->int_field_put(fd->offset(), fd->int_initial_value());
duke@435	2275	break;
duke@435	2276	case T_FLOAT:
duke@435	2277	h_k()->float_field_put(fd->offset(), fd->float_initial_value());
duke@435	2278	break;
duke@435	2279	case T_DOUBLE:
duke@435	2280	h_k()->double_field_put(fd->offset(), fd->double_initial_value());
duke@435	2281	break;
duke@435	2282	case T_LONG:
duke@435	2283	h_k()->long_field_put(fd->offset(), fd->long_initial_value());
duke@435	2284	break;
duke@435	2285	case T_OBJECT:
duke@435	2286	{
duke@435	2287	#ifdef ASSERT
duke@435	2288	symbolOop sym = oopFactory::new_symbol("Ljava/lang/String;", CHECK);
duke@435	2289	assert(fd->signature() == sym, "just checking");
duke@435	2290	#endif
duke@435	2291	oop string = fd->string_initial_value(CHECK);
duke@435	2292	h_k()->obj_field_put(fd->offset(), string);
duke@435	2293	}
duke@435	2294	break;
duke@435	2295	default:
duke@435	2296	THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
duke@435	2297	"Illegal ConstantValue attribute in class file");
duke@435	2298	}
duke@435	2299	}
duke@435	2300	}
duke@435	2301
duke@435	2302
duke@435	2303	void ClassFileParser::java_lang_ref_Reference_fix_pre(typeArrayHandle* fields_ptr,
duke@435	2304	constantPoolHandle cp, FieldAllocationCount *fac_ptr, TRAPS) {
duke@435	2305	// This code is for compatibility with earlier jdk's that do not
duke@435	2306	// have the "discovered" field in java.lang.ref.Reference. For 1.5
duke@435	2307	// the check for the "discovered" field should issue a warning if
duke@435	2308	// the field is not found. For 1.6 this code should be issue a
duke@435	2309	// fatal error if the "discovered" field is not found.
duke@435	2310	//
duke@435	2311	// Increment fac.nonstatic_oop_count so that the start of the
duke@435	2312	// next type of non-static oops leaves room for the fake oop.
duke@435	2313	// Do not increment next_nonstatic_oop_offset so that the
duke@435	2314	// fake oop is place after the java.lang.ref.Reference oop
duke@435	2315	// fields.
duke@435	2316	//
duke@435	2317	// Check the fields in java.lang.ref.Reference for the "discovered"
duke@435	2318	// field. If it is not present, artifically create a field for it.
duke@435	2319	// This allows this VM to run on early JDK where the field is not
duke@435	2320	// present.
duke@435	2321
duke@435	2322	//
duke@435	2323	// Increment fac.nonstatic_oop_count so that the start of the
duke@435	2324	// next type of non-static oops leaves room for the fake oop.
duke@435	2325	// Do not increment next_nonstatic_oop_offset so that the
duke@435	2326	// fake oop is place after the java.lang.ref.Reference oop
duke@435	2327	// fields.
duke@435	2328	//
duke@435	2329	// Check the fields in java.lang.ref.Reference for the "discovered"
duke@435	2330	// field. If it is not present, artifically create a field for it.
duke@435	2331	// This allows this VM to run on early JDK where the field is not
duke@435	2332	// present.
duke@435	2333	int reference_sig_index = 0;
duke@435	2334	int reference_name_index = 0;
duke@435	2335	int reference_index = 0;
duke@435	2336	int extra = java_lang_ref_Reference::number_of_fake_oop_fields;
duke@435	2337	const int n = (*fields_ptr)()->length();
duke@435	2338	for (int i = 0; i < n; i += instanceKlass::next_offset ) {
duke@435	2339	int name_index =
duke@435	2340	(*fields_ptr)()->ushort_at(i + instanceKlass::name_index_offset);
duke@435	2341	int sig_index =
duke@435	2342	(*fields_ptr)()->ushort_at(i + instanceKlass::signature_index_offset);
duke@435	2343	symbolOop f_name = cp->symbol_at(name_index);
duke@435	2344	symbolOop f_sig = cp->symbol_at(sig_index);
duke@435	2345	if (f_sig == vmSymbols::reference_signature() && reference_index == 0) {
duke@435	2346	// Save the index for reference signature for later use.
duke@435	2347	// The fake discovered field does not entries in the
duke@435	2348	// constant pool so the index for its signature cannot
duke@435	2349	// be extracted from the constant pool. It will need
duke@435	2350	// later, however. It's signature is vmSymbols::reference_signature()
duke@435	2351	// so same an index for that signature.
duke@435	2352	reference_sig_index = sig_index;
duke@435	2353	reference_name_index = name_index;
duke@435	2354	reference_index = i;
duke@435	2355	}
duke@435	2356	if (f_name == vmSymbols::reference_discovered_name() &&
duke@435	2357	f_sig == vmSymbols::reference_signature()) {
duke@435	2358	// The values below are fake but will force extra
duke@435	2359	// non-static oop fields and a corresponding non-static
duke@435	2360	// oop map block to be allocated.
duke@435	2361	extra = 0;
duke@435	2362	break;
duke@435	2363	}
duke@435	2364	}
duke@435	2365	if (extra != 0) {
duke@435	2366	fac_ptr->nonstatic_oop_count += extra;
duke@435	2367	// Add the additional entry to "fields" so that the klass
duke@435	2368	// contains the "discoverd" field and the field will be initialized
duke@435	2369	// in instances of the object.
duke@435	2370	int fields_with_fix_length = (*fields_ptr)()->length() +
duke@435	2371	instanceKlass::next_offset;
duke@435	2372	typeArrayOop ff = oopFactory::new_permanent_shortArray(
duke@435	2373	fields_with_fix_length, CHECK);
duke@435	2374	typeArrayHandle fields_with_fix(THREAD, ff);
duke@435	2375
duke@435	2376	// Take everything from the original but the length.
duke@435	2377	for (int idx = 0; idx < (*fields_ptr)->length(); idx++) {
duke@435	2378	fields_with_fix->ushort_at_put(idx, (*fields_ptr)->ushort_at(idx));
duke@435	2379	}
duke@435	2380
duke@435	2381	// Add the fake field at the end.
duke@435	2382	int i = (*fields_ptr)->length();
duke@435	2383	// There is no name index for the fake "discovered" field nor
duke@435	2384	// signature but a signature is needed so that the field will
duke@435	2385	// be properly initialized. Use one found for
duke@435	2386	// one of the other reference fields. Be sure the index for the
duke@435	2387	// name is 0. In fieldDescriptor::initialize() the index of the
duke@435	2388	// name is checked. That check is by passed for the last nonstatic
duke@435	2389	// oop field in a java.lang.ref.Reference which is assumed to be
duke@435	2390	// this artificial "discovered" field. An assertion checks that
duke@435	2391	// the name index is 0.
duke@435	2392	assert(reference_index != 0, "Missing signature for reference");
duke@435	2393
duke@435	2394	int j;
duke@435	2395	for (j = 0; j < instanceKlass::next_offset; j++) {
duke@435	2396	fields_with_fix->ushort_at_put(i + j,
duke@435	2397	(*fields_ptr)->ushort_at(reference_index +j));
duke@435	2398	}
duke@435	2399	// Clear the public access flag and set the private access flag.
duke@435	2400	short flags;
duke@435	2401	flags =
duke@435	2402	fields_with_fix->ushort_at(i + instanceKlass::access_flags_offset);
duke@435	2403	assert(!(flags & JVM_RECOGNIZED_FIELD_MODIFIERS), "Unexpected access flags set");
duke@435	2404	flags = flags & (~JVM_ACC_PUBLIC);
duke@435	2405	flags = flags | JVM_ACC_PRIVATE;
duke@435	2406	AccessFlags access_flags;
duke@435	2407	access_flags.set_flags(flags);
duke@435	2408	assert(!access_flags.is_public(), "Failed to clear public flag");
duke@435	2409	assert(access_flags.is_private(), "Failed to set private flag");
duke@435	2410	fields_with_fix->ushort_at_put(i + instanceKlass::access_flags_offset,
duke@435	2411	flags);
duke@435	2412
duke@435	2413	assert(fields_with_fix->ushort_at(i + instanceKlass::name_index_offset)
duke@435	2414	== reference_name_index, "The fake reference name is incorrect");
duke@435	2415	assert(fields_with_fix->ushort_at(i + instanceKlass::signature_index_offset)
duke@435	2416	== reference_sig_index, "The fake reference signature is incorrect");
duke@435	2417	// The type of the field is stored in the low_offset entry during
duke@435	2418	// parsing.
duke@435	2419	assert(fields_with_fix->ushort_at(i + instanceKlass::low_offset) ==
duke@435	2420	NONSTATIC_OOP, "The fake reference type is incorrect");
duke@435	2421
duke@435	2422	// "fields" is allocated in the permanent generation. Disgard
duke@435	2423	// it and let it be collected.
duke@435	2424	(*fields_ptr) = fields_with_fix;
duke@435	2425	}
duke@435	2426	return;
duke@435	2427	}
duke@435	2428
duke@435	2429
duke@435	2430	void ClassFileParser::java_lang_Class_fix_pre(objArrayHandle* methods_ptr,
duke@435	2431	FieldAllocationCount *fac_ptr, TRAPS) {
duke@435	2432	// Add fake fields for java.lang.Class instances
duke@435	2433	//
duke@435	2434	// This is not particularly nice. We should consider adding a
duke@435	2435	// private transient object field at the Java level to
duke@435	2436	// java.lang.Class. Alternatively we could add a subclass of
duke@435	2437	// instanceKlass which provides an accessor and size computer for
duke@435	2438	// this field, but that appears to be more code than this hack.
duke@435	2439	//
duke@435	2440	// NOTE that we wedge these in at the beginning rather than the
duke@435	2441	// end of the object because the Class layout changed between JDK
duke@435	2442	// 1.3 and JDK 1.4 with the new reflection implementation; some
duke@435	2443	// nonstatic oop fields were added at the Java level. The offsets
duke@435	2444	// of these fake fields can't change between these two JDK
duke@435	2445	// versions because when the offsets are computed at bootstrap
duke@435	2446	// time we don't know yet which version of the JDK we're running in.
duke@435	2447
duke@435	2448	// The values below are fake but will force two non-static oop fields and
duke@435	2449	// a corresponding non-static oop map block to be allocated.
duke@435	2450	const int extra = java_lang_Class::number_of_fake_oop_fields;
duke@435	2451	fac_ptr->nonstatic_oop_count += extra;
duke@435	2452	}
duke@435	2453
duke@435	2454
duke@435	2455	void ClassFileParser::java_lang_Class_fix_post(int* next_nonstatic_oop_offset_ptr) {
duke@435	2456	// Cause the extra fake fields in java.lang.Class to show up before
duke@435	2457	// the Java fields for layout compatibility between 1.3 and 1.4
duke@435	2458	// Incrementing next_nonstatic_oop_offset here advances the
duke@435	2459	// location where the real java fields are placed.
duke@435	2460	const int extra = java_lang_Class::number_of_fake_oop_fields;
coleenp@548	2461	(*next_nonstatic_oop_offset_ptr) += (extra * heapOopSize);
duke@435	2462	}
duke@435	2463
duke@435	2464
duke@435	2465	instanceKlassHandle ClassFileParser::parseClassFile(symbolHandle name,
duke@435	2466	Handle class_loader,
duke@435	2467	Handle protection_domain,
jrose@866	2468	GrowableArray<Handle>* cp_patches,
duke@435	2469	symbolHandle& parsed_name,
duke@435	2470	TRAPS) {
duke@435	2471	// So that JVMTI can cache class file in the state before retransformable agents
duke@435	2472	// have modified it
duke@435	2473	unsigned char *cached_class_file_bytes = NULL;
duke@435	2474	jint cached_class_file_length;
duke@435	2475
duke@435	2476	ClassFileStream* cfs = stream();
duke@435	2477	// Timing
duke@435	2478	PerfTraceTime vmtimer(ClassLoader::perf_accumulated_time());
duke@435	2479
duke@435	2480	_has_finalizer = _has_empty_finalizer = _has_vanilla_constructor = false;
duke@435	2481
duke@435	2482	if (JvmtiExport::should_post_class_file_load_hook()) {
duke@435	2483	unsigned char* ptr = cfs->buffer();
duke@435	2484	unsigned char* end_ptr = cfs->buffer() + cfs->length();
duke@435	2485
duke@435	2486	JvmtiExport::post_class_file_load_hook(name, class_loader, protection_domain,
duke@435	2487	&ptr, &end_ptr,
duke@435	2488	&cached_class_file_bytes,
duke@435	2489	&cached_class_file_length);
duke@435	2490
duke@435	2491	if (ptr != cfs->buffer()) {
duke@435	2492	// JVMTI agent has modified class file data.
duke@435	2493	// Set new class file stream using JVMTI agent modified
duke@435	2494	// class file data.
duke@435	2495	cfs = new ClassFileStream(ptr, end_ptr - ptr, cfs->source());
duke@435	2496	set_stream(cfs);
duke@435	2497	}
duke@435	2498	}
duke@435	2499
jrose@866	2500	_cp_patches = cp_patches;
duke@435	2501
duke@435	2502	instanceKlassHandle nullHandle;
duke@435	2503
duke@435	2504	// Figure out whether we can skip format checking (matching classic VM behavior)
duke@435	2505	_need_verify = Verifier::should_verify_for(class_loader());
duke@435	2506
duke@435	2507	// Set the verify flag in stream
duke@435	2508	cfs->set_verify(_need_verify);
duke@435	2509
duke@435	2510	// Save the class file name for easier error message printing.
duke@435	2511	_class_name = name.not_null()? name : vmSymbolHandles::unknown_class_name();
duke@435	2512
duke@435	2513	cfs->guarantee_more(8, CHECK_(nullHandle)); // magic, major, minor
duke@435	2514	// Magic value
duke@435	2515	u4 magic = cfs->get_u4_fast();
duke@435	2516	guarantee_property(magic == JAVA_CLASSFILE_MAGIC,
duke@435	2517	"Incompatible magic value %u in class file %s",
duke@435	2518	magic, CHECK_(nullHandle));
duke@435	2519
duke@435	2520	// Version numbers
duke@435	2521	u2 minor_version = cfs->get_u2_fast();
duke@435	2522	u2 major_version = cfs->get_u2_fast();
duke@435	2523
duke@435	2524	// Check version numbers - we check this even with verifier off
duke@435	2525	if (!is_supported_version(major_version, minor_version)) {
duke@435	2526	if (name.is_null()) {
duke@435	2527	Exceptions::fthrow(
duke@435	2528	THREAD_AND_LOCATION,
duke@435	2529	vmSymbolHandles::java_lang_UnsupportedClassVersionError(),
duke@435	2530	"Unsupported major.minor version %u.%u",
duke@435	2531	major_version,
duke@435	2532	minor_version);
duke@435	2533	} else {
duke@435	2534	ResourceMark rm(THREAD);
duke@435	2535	Exceptions::fthrow(
duke@435	2536	THREAD_AND_LOCATION,
duke@435	2537	vmSymbolHandles::java_lang_UnsupportedClassVersionError(),
duke@435	2538	"%s : Unsupported major.minor version %u.%u",
duke@435	2539	name->as_C_string(),
duke@435	2540	major_version,
duke@435	2541	minor_version);
duke@435	2542	}
duke@435	2543	return nullHandle;
duke@435	2544	}
duke@435	2545
duke@435	2546	_major_version = major_version;
duke@435	2547	_minor_version = minor_version;
duke@435	2548
duke@435	2549
duke@435	2550	// Check if verification needs to be relaxed for this class file
duke@435	2551	// Do not restrict it to jdk1.0 or jdk1.1 to maintain backward compatibility (4982376)
duke@435	2552	_relax_verify = Verifier::relax_verify_for(class_loader());
duke@435	2553
duke@435	2554	// Constant pool
duke@435	2555	constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle));
duke@435	2556	int cp_size = cp->length();
duke@435	2557
duke@435	2558	cfs->guarantee_more(8, CHECK_(nullHandle)); // flags, this_class, super_class, infs_len
duke@435	2559
duke@435	2560	// Access flags
duke@435	2561	AccessFlags access_flags;
duke@435	2562	jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS;
duke@435	2563
duke@435	2564	if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
duke@435	2565	// Set abstract bit for old class files for backward compatibility
duke@435	2566	flags |= JVM_ACC_ABSTRACT;
duke@435	2567	}
duke@435	2568	verify_legal_class_modifiers(flags, CHECK_(nullHandle));
duke@435	2569	access_flags.set_flags(flags);
duke@435	2570
duke@435	2571	// This class and superclass
duke@435	2572	instanceKlassHandle super_klass;
duke@435	2573	u2 this_class_index = cfs->get_u2_fast();
duke@435	2574	check_property(
duke@435	2575	valid_cp_range(this_class_index, cp_size) &&
duke@435	2576	cp->tag_at(this_class_index).is_unresolved_klass(),
duke@435	2577	"Invalid this class index %u in constant pool in class file %s",
duke@435	2578	this_class_index, CHECK_(nullHandle));
duke@435	2579
duke@435	2580	symbolHandle class_name (THREAD, cp->unresolved_klass_at(this_class_index));
duke@435	2581	assert(class_name.not_null(), "class_name can't be null");
duke@435	2582
duke@435	2583	// It's important to set parsed_name *before* resolving the super class.
duke@435	2584	// (it's used for cleanup by the caller if parsing fails)
duke@435	2585	parsed_name = class_name;
duke@435	2586
duke@435	2587	// Update _class_name which could be null previously to be class_name
duke@435	2588	_class_name = class_name;
duke@435	2589
duke@435	2590	// Don't need to check whether this class name is legal or not.
duke@435	2591	// It has been checked when constant pool is parsed.
duke@435	2592	// However, make sure it is not an array type.
duke@435	2593	if (_need_verify) {
duke@435	2594	guarantee_property(class_name->byte_at(0) != JVM_SIGNATURE_ARRAY,
duke@435	2595	"Bad class name in class file %s",
duke@435	2596	CHECK_(nullHandle));
duke@435	2597	}
duke@435	2598
duke@435	2599	klassOop preserve_this_klass; // for storing result across HandleMark
duke@435	2600
duke@435	2601	// release all handles when parsing is done
duke@435	2602	{ HandleMark hm(THREAD);
duke@435	2603
duke@435	2604	// Checks if name in class file matches requested name
duke@435	2605	if (name.not_null() && class_name() != name()) {
duke@435	2606	ResourceMark rm(THREAD);
duke@435	2607	Exceptions::fthrow(
duke@435	2608	THREAD_AND_LOCATION,
duke@435	2609	vmSymbolHandles::java_lang_NoClassDefFoundError(),
duke@435	2610	"%s (wrong name: %s)",
duke@435	2611	name->as_C_string(),
duke@435	2612	class_name->as_C_string()
duke@435	2613	);
duke@435	2614	return nullHandle;
duke@435	2615	}
duke@435	2616
duke@435	2617	if (TraceClassLoadingPreorder) {
duke@435	2618	tty->print("[Loading %s", name()->as_klass_external_name());
duke@435	2619	if (cfs->source() != NULL) tty->print(" from %s", cfs->source());
duke@435	2620	tty->print_cr("]");
duke@435	2621	}
duke@435	2622
duke@435	2623	u2 super_class_index = cfs->get_u2_fast();
duke@435	2624	if (super_class_index == 0) {
duke@435	2625	check_property(class_name() == vmSymbols::java_lang_Object(),
duke@435	2626	"Invalid superclass index %u in class file %s",
duke@435	2627	super_class_index,
duke@435	2628	CHECK_(nullHandle));
duke@435	2629	} else {
duke@435	2630	check_property(valid_cp_range(super_class_index, cp_size) &&
jrose@866	2631	is_klass_reference(cp, super_class_index),
duke@435	2632	"Invalid superclass index %u in class file %s",
duke@435	2633	super_class_index,
duke@435	2634	CHECK_(nullHandle));
duke@435	2635	// The class name should be legal because it is checked when parsing constant pool.
duke@435	2636	// However, make sure it is not an array type.
jrose@866	2637	bool is_array = false;
jrose@866	2638	if (cp->tag_at(super_class_index).is_klass()) {
jrose@866	2639	super_klass = instanceKlassHandle(THREAD, cp->resolved_klass_at(super_class_index));
jrose@866	2640	if (_need_verify)
jrose@866	2641	is_array = super_klass->oop_is_array();
jrose@866	2642	} else if (_need_verify) {
jrose@866	2643	is_array = (cp->unresolved_klass_at(super_class_index)->byte_at(0) == JVM_SIGNATURE_ARRAY);
jrose@866	2644	}
duke@435	2645	if (_need_verify) {
jrose@866	2646	guarantee_property(!is_array,
duke@435	2647	"Bad superclass name in class file %s", CHECK_(nullHandle));
duke@435	2648	}
duke@435	2649	}
duke@435	2650
duke@435	2651	// Interfaces
duke@435	2652	u2 itfs_len = cfs->get_u2_fast();
duke@435	2653	objArrayHandle local_interfaces;
duke@435	2654	if (itfs_len == 0) {
duke@435	2655	local_interfaces = objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
duke@435	2656	} else {
duke@435	2657	local_interfaces = parse_interfaces(cp, itfs_len, class_loader, protection_domain, &vmtimer, _class_name, CHECK_(nullHandle));
duke@435	2658	}
duke@435	2659
duke@435	2660	// Fields (offsets are filled in later)
duke@435	2661	struct FieldAllocationCount fac = {0,0,0,0,0,0,0,0,0,0};
duke@435	2662	objArrayHandle fields_annotations;
duke@435	2663	typeArrayHandle fields = parse_fields(cp, access_flags.is_interface(), &fac, &fields_annotations, CHECK_(nullHandle));
duke@435	2664	// Methods
duke@435	2665	bool has_final_method = false;
duke@435	2666	AccessFlags promoted_flags;
duke@435	2667	promoted_flags.set_flags(0);
duke@435	2668	// These need to be oop pointers because they are allocated lazily
duke@435	2669	// inside parse_methods inside a nested HandleMark
duke@435	2670	objArrayOop methods_annotations_oop = NULL;
duke@435	2671	objArrayOop methods_parameter_annotations_oop = NULL;
duke@435	2672	objArrayOop methods_default_annotations_oop = NULL;
duke@435	2673	objArrayHandle methods = parse_methods(cp, access_flags.is_interface(),
duke@435	2674	&promoted_flags,
duke@435	2675	&has_final_method,
duke@435	2676	&methods_annotations_oop,
duke@435	2677	&methods_parameter_annotations_oop,
duke@435	2678	&methods_default_annotations_oop,
duke@435	2679	CHECK_(nullHandle));
duke@435	2680
duke@435	2681	objArrayHandle methods_annotations(THREAD, methods_annotations_oop);
duke@435	2682	objArrayHandle methods_parameter_annotations(THREAD, methods_parameter_annotations_oop);
duke@435	2683	objArrayHandle methods_default_annotations(THREAD, methods_default_annotations_oop);
duke@435	2684
duke@435	2685	// We check super class after class file is parsed and format is checked
jrose@866	2686	if (super_class_index > 0 && super_klass.is_null()) {
duke@435	2687	symbolHandle sk (THREAD, cp->klass_name_at(super_class_index));
duke@435	2688	if (access_flags.is_interface()) {
duke@435	2689	// Before attempting to resolve the superclass, check for class format
duke@435	2690	// errors not checked yet.
duke@435	2691	guarantee_property(sk() == vmSymbols::java_lang_Object(),
duke@435	2692	"Interfaces must have java.lang.Object as superclass in class file %s",
duke@435	2693	CHECK_(nullHandle));
duke@435	2694	}
duke@435	2695	klassOop k = SystemDictionary::resolve_super_or_fail(class_name,
duke@435	2696	sk,
duke@435	2697	class_loader,
duke@435	2698	protection_domain,
duke@435	2699	true,
duke@435	2700	CHECK_(nullHandle));
duke@435	2701	KlassHandle kh (THREAD, k);
duke@435	2702	super_klass = instanceKlassHandle(THREAD, kh());
jrose@909	2703	if (LinkWellKnownClasses) // my super class is well known to me
jrose@909	2704	cp->klass_at_put(super_class_index, super_klass()); // eagerly resolve
jrose@866	2705	}
jrose@866	2706	if (super_klass.not_null()) {
duke@435	2707	if (super_klass->is_interface()) {
duke@435	2708	ResourceMark rm(THREAD);
duke@435	2709	Exceptions::fthrow(
duke@435	2710	THREAD_AND_LOCATION,
duke@435	2711	vmSymbolHandles::java_lang_IncompatibleClassChangeError(),
duke@435	2712	"class %s has interface %s as super class",
duke@435	2713	class_name->as_klass_external_name(),
duke@435	2714	super_klass->external_name()
duke@435	2715	);
duke@435	2716	return nullHandle;
duke@435	2717	}
duke@435	2718	// Make sure super class is not final
duke@435	2719	if (super_klass->is_final()) {
duke@435	2720	THROW_MSG_(vmSymbols::java_lang_VerifyError(), "Cannot inherit from final class", nullHandle);
duke@435	2721	}
duke@435	2722	}
duke@435	2723
duke@435	2724	// Compute the transitive list of all unique interfaces implemented by this class
duke@435	2725	objArrayHandle transitive_interfaces = compute_transitive_interfaces(super_klass, local_interfaces, CHECK_(nullHandle));
duke@435	2726
duke@435	2727	// sort methods
duke@435	2728	typeArrayHandle method_ordering = sort_methods(methods,
duke@435	2729	methods_annotations,
duke@435	2730	methods_parameter_annotations,
duke@435	2731	methods_default_annotations,
duke@435	2732	CHECK_(nullHandle));
duke@435	2733
duke@435	2734	// promote flags from parse_methods() to the klass' flags
duke@435	2735	access_flags.add_promoted_flags(promoted_flags.as_int());
duke@435	2736
duke@435	2737	// Size of Java vtable (in words)
duke@435	2738	int vtable_size = 0;
duke@435	2739	int itable_size = 0;
duke@435	2740	int num_miranda_methods = 0;
duke@435	2741
duke@435	2742	klassVtable::compute_vtable_size_and_num_mirandas(vtable_size,
duke@435	2743	num_miranda_methods,
duke@435	2744	super_klass(),
duke@435	2745	methods(),
duke@435	2746	access_flags,
duke@435	2747	class_loader(),
duke@435	2748	class_name(),
duke@435	2749	local_interfaces());
duke@435	2750
duke@435	2751	// Size of Java itable (in words)
duke@435	2752	itable_size = access_flags.is_interface() ? 0 : klassItable::compute_itable_size(transitive_interfaces);
duke@435	2753
duke@435	2754	// Field size and offset computation
duke@435	2755	int nonstatic_field_size = super_klass() == NULL ? 0 : super_klass->nonstatic_field_size();
duke@435	2756	#ifndef PRODUCT
duke@435	2757	int orig_nonstatic_field_size = 0;
duke@435	2758	#endif
duke@435	2759	int static_field_size = 0;
duke@435	2760	int next_static_oop_offset;
duke@435	2761	int next_static_double_offset;
duke@435	2762	int next_static_word_offset;
duke@435	2763	int next_static_short_offset;
duke@435	2764	int next_static_byte_offset;
duke@435	2765	int next_static_type_offset;
duke@435	2766	int next_nonstatic_oop_offset;
duke@435	2767	int next_nonstatic_double_offset;
duke@435	2768	int next_nonstatic_word_offset;
duke@435	2769	int next_nonstatic_short_offset;
duke@435	2770	int next_nonstatic_byte_offset;
duke@435	2771	int next_nonstatic_type_offset;
duke@435	2772	int first_nonstatic_oop_offset;
duke@435	2773	int first_nonstatic_field_offset;
duke@435	2774	int next_nonstatic_field_offset;
duke@435	2775
duke@435	2776	// Calculate the starting byte offsets
duke@435	2777	next_static_oop_offset = (instanceKlass::header_size() +
duke@435	2778	align_object_offset(vtable_size) +
duke@435	2779	align_object_offset(itable_size)) * wordSize;
duke@435	2780	next_static_double_offset = next_static_oop_offset +
coleenp@548	2781	(fac.static_oop_count * heapOopSize);
duke@435	2782	if ( fac.static_double_count &&
duke@435	2783	(Universe::field_type_should_be_aligned(T_DOUBLE) ||
duke@435	2784	Universe::field_type_should_be_aligned(T_LONG)) ) {
duke@435	2785	next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong);
duke@435	2786	}
duke@435	2787
duke@435	2788	next_static_word_offset = next_static_double_offset +
duke@435	2789	(fac.static_double_count * BytesPerLong);
duke@435	2790	next_static_short_offset = next_static_word_offset +
duke@435	2791	(fac.static_word_count * BytesPerInt);
duke@435	2792	next_static_byte_offset = next_static_short_offset +
duke@435	2793	(fac.static_short_count * BytesPerShort);
duke@435	2794	next_static_type_offset = align_size_up((next_static_byte_offset +
duke@435	2795	fac.static_byte_count ), wordSize );
duke@435	2796	static_field_size = (next_static_type_offset -
duke@435	2797	next_static_oop_offset) / wordSize;
kvn@600	2798	first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
kvn@600	2799	nonstatic_field_size * heapOopSize;
duke@435	2800	next_nonstatic_field_offset = first_nonstatic_field_offset;
duke@435	2801
duke@435	2802	// Add fake fields for java.lang.Class instances (also see below)
duke@435	2803	if (class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
duke@435	2804	java_lang_Class_fix_pre(&methods, &fac, CHECK_(nullHandle));
duke@435	2805	}
duke@435	2806
duke@435	2807	// Add a fake "discovered" field if it is not present
duke@435	2808	// for compatibility with earlier jdk's.
duke@435	2809	if (class_name() == vmSymbols::java_lang_ref_Reference()
duke@435	2810	&& class_loader.is_null()) {
duke@435	2811	java_lang_ref_Reference_fix_pre(&fields, cp, &fac, CHECK_(nullHandle));
duke@435	2812	}
duke@435	2813	// end of "discovered" field compactibility fix
duke@435	2814
duke@435	2815	int nonstatic_double_count = fac.nonstatic_double_count;
duke@435	2816	int nonstatic_word_count = fac.nonstatic_word_count;
duke@435	2817	int nonstatic_short_count = fac.nonstatic_short_count;
duke@435	2818	int nonstatic_byte_count = fac.nonstatic_byte_count;
duke@435	2819	int nonstatic_oop_count = fac.nonstatic_oop_count;
duke@435	2820
coleenp@548	2821	bool super_has_nonstatic_fields =
coleenp@548	2822	(super_klass() != NULL && super_klass->has_nonstatic_fields());
coleenp@548	2823	bool has_nonstatic_fields = super_has_nonstatic_fields ||
coleenp@548	2824	((nonstatic_double_count + nonstatic_word_count +
coleenp@548	2825	nonstatic_short_count + nonstatic_byte_count +
coleenp@548	2826	nonstatic_oop_count) != 0);
coleenp@548	2827
coleenp@548	2828
duke@435	2829	// Prepare list of oops for oop maps generation.
duke@435	2830	u2* nonstatic_oop_offsets;
duke@435	2831	u2* nonstatic_oop_length;
duke@435	2832	int nonstatic_oop_map_count = 0;
duke@435	2833
duke@435	2834	nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	2835	THREAD, u2, nonstatic_oop_count+1);
duke@435	2836	nonstatic_oop_length = NEW_RESOURCE_ARRAY_IN_THREAD(
duke@435	2837	THREAD, u2, nonstatic_oop_count+1);
duke@435	2838
duke@435	2839	// Add fake fields for java.lang.Class instances (also see above).
duke@435	2840	// FieldsAllocationStyle and CompactFields values will be reset to default.
duke@435	2841	if(class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
duke@435	2842	java_lang_Class_fix_post(&next_nonstatic_field_offset);
duke@435	2843	nonstatic_oop_offsets[0] = (u2)first_nonstatic_field_offset;
duke@435	2844	int fake_oop_count = (( next_nonstatic_field_offset -
coleenp@548	2845	first_nonstatic_field_offset ) / heapOopSize);
duke@435	2846	nonstatic_oop_length [0] = (u2)fake_oop_count;
duke@435	2847	nonstatic_oop_map_count = 1;
duke@435	2848	nonstatic_oop_count -= fake_oop_count;
duke@435	2849	first_nonstatic_oop_offset = first_nonstatic_field_offset;
duke@435	2850	} else {
duke@435	2851	first_nonstatic_oop_offset = 0; // will be set for first oop field
duke@435	2852	}
duke@435	2853
duke@435	2854	#ifndef PRODUCT
duke@435	2855	if( PrintCompactFieldsSavings ) {
duke@435	2856	next_nonstatic_double_offset = next_nonstatic_field_offset +
coleenp@548	2857	(nonstatic_oop_count * heapOopSize);
duke@435	2858	if ( nonstatic_double_count > 0 ) {
duke@435	2859	next_nonstatic_double_offset = align_size_up(next_nonstatic_double_offset, BytesPerLong);
duke@435	2860	}
duke@435	2861	next_nonstatic_word_offset = next_nonstatic_double_offset +
duke@435	2862	(nonstatic_double_count * BytesPerLong);
duke@435	2863	next_nonstatic_short_offset = next_nonstatic_word_offset +
duke@435	2864	(nonstatic_word_count * BytesPerInt);
duke@435	2865	next_nonstatic_byte_offset = next_nonstatic_short_offset +
duke@435	2866	(nonstatic_short_count * BytesPerShort);
duke@435	2867	next_nonstatic_type_offset = align_size_up((next_nonstatic_byte_offset +
kvn@600	2868	nonstatic_byte_count ), heapOopSize );
duke@435	2869	orig_nonstatic_field_size = nonstatic_field_size +
kvn@600	2870	((next_nonstatic_type_offset - first_nonstatic_field_offset)/heapOopSize);
duke@435	2871	}
duke@435	2872	#endif
duke@435	2873	bool compact_fields = CompactFields;
duke@435	2874	int allocation_style = FieldsAllocationStyle;
duke@435	2875	if( allocation_style < 0 || allocation_style > 1 ) { // Out of range?
duke@435	2876	assert(false, "0 <= FieldsAllocationStyle <= 1");
duke@435	2877	allocation_style = 1; // Optimistic
duke@435	2878	}
duke@435	2879
duke@435	2880	// The next classes have predefined hard-coded fields offsets
duke@435	2881	// (see in JavaClasses::compute_hard_coded_offsets()).
duke@435	2882	// Use default fields allocation order for them.
duke@435	2883	if( (allocation_style != 0 || compact_fields ) && class_loader.is_null() &&
duke@435	2884	(class_name() == vmSymbols::java_lang_AssertionStatusDirectives() ||
duke@435	2885	class_name() == vmSymbols::java_lang_Class() ||
duke@435	2886	class_name() == vmSymbols::java_lang_ClassLoader() ||
duke@435	2887	class_name() == vmSymbols::java_lang_ref_Reference() ||
duke@435	2888	class_name() == vmSymbols::java_lang_ref_SoftReference() ||
duke@435	2889	class_name() == vmSymbols::java_lang_StackTraceElement() ||
duke@435	2890	class_name() == vmSymbols::java_lang_String() ||
coleenp@548	2891	class_name() == vmSymbols::java_lang_Throwable() ||
coleenp@548	2892	class_name() == vmSymbols::java_lang_Boolean() ||
coleenp@548	2893	class_name() == vmSymbols::java_lang_Character() ||
coleenp@548	2894	class_name() == vmSymbols::java_lang_Float() ||
coleenp@548	2895	class_name() == vmSymbols::java_lang_Double() ||
coleenp@548	2896	class_name() == vmSymbols::java_lang_Byte() ||
coleenp@548	2897	class_name() == vmSymbols::java_lang_Short() ||
coleenp@548	2898	class_name() == vmSymbols::java_lang_Integer() ||
coleenp@548	2899	class_name() == vmSymbols::java_lang_Long())) {
duke@435	2900	allocation_style = 0; // Allocate oops first
duke@435	2901	compact_fields = false; // Don't compact fields
duke@435	2902	}
duke@435	2903
duke@435	2904	if( allocation_style == 0 ) {
duke@435	2905	// Fields order: oops, longs/doubles, ints, shorts/chars, bytes
duke@435	2906	next_nonstatic_oop_offset = next_nonstatic_field_offset;
duke@435	2907	next_nonstatic_double_offset = next_nonstatic_oop_offset +
coleenp@548	2908	(nonstatic_oop_count * heapOopSize);
duke@435	2909	} else if( allocation_style == 1 ) {
duke@435	2910	// Fields order: longs/doubles, ints, shorts/chars, bytes, oops
duke@435	2911	next_nonstatic_double_offset = next_nonstatic_field_offset;
duke@435	2912	} else {
duke@435	2913	ShouldNotReachHere();
duke@435	2914	}
duke@435	2915
duke@435	2916	int nonstatic_oop_space_count = 0;
duke@435	2917	int nonstatic_word_space_count = 0;
duke@435	2918	int nonstatic_short_space_count = 0;
duke@435	2919	int nonstatic_byte_space_count = 0;
duke@435	2920	int nonstatic_oop_space_offset;
duke@435	2921	int nonstatic_word_space_offset;
duke@435	2922	int nonstatic_short_space_offset;
duke@435	2923	int nonstatic_byte_space_offset;
duke@435	2924
kvn@600	2925	if( nonstatic_double_count > 0 ) {
kvn@600	2926	int offset = next_nonstatic_double_offset;
duke@435	2927	next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
duke@435	2928	if( compact_fields && offset != next_nonstatic_double_offset ) {
duke@435	2929	// Allocate available fields into the gap before double field.
duke@435	2930	int length = next_nonstatic_double_offset - offset;
duke@435	2931	assert(length == BytesPerInt, "");
duke@435	2932	nonstatic_word_space_offset = offset;
duke@435	2933	if( nonstatic_word_count > 0 ) {
duke@435	2934	nonstatic_word_count -= 1;
duke@435	2935	nonstatic_word_space_count = 1; // Only one will fit
duke@435	2936	length -= BytesPerInt;
duke@435	2937	offset += BytesPerInt;
duke@435	2938	}
duke@435	2939	nonstatic_short_space_offset = offset;
duke@435	2940	while( length >= BytesPerShort && nonstatic_short_count > 0 ) {
duke@435	2941	nonstatic_short_count -= 1;
duke@435	2942	nonstatic_short_space_count += 1;
duke@435	2943	length -= BytesPerShort;
duke@435	2944	offset += BytesPerShort;
duke@435	2945	}
duke@435	2946	nonstatic_byte_space_offset = offset;
duke@435	2947	while( length > 0 && nonstatic_byte_count > 0 ) {
duke@435	2948	nonstatic_byte_count -= 1;
duke@435	2949	nonstatic_byte_space_count += 1;
duke@435	2950	length -= 1;
duke@435	2951	}
duke@435	2952	// Allocate oop field in the gap if there are no other fields for that.
duke@435	2953	nonstatic_oop_space_offset = offset;
kvn@600	2954	if( length >= heapOopSize && nonstatic_oop_count > 0 &&
duke@435	2955	allocation_style != 0 ) { // when oop fields not first
duke@435	2956	nonstatic_oop_count -= 1;
duke@435	2957	nonstatic_oop_space_count = 1; // Only one will fit
coleenp@548	2958	length -= heapOopSize;
coleenp@548	2959	offset += heapOopSize;
duke@435	2960	}
duke@435	2961	}
duke@435	2962	}
duke@435	2963
duke@435	2964	next_nonstatic_word_offset = next_nonstatic_double_offset +
duke@435	2965	(nonstatic_double_count * BytesPerLong);
duke@435	2966	next_nonstatic_short_offset = next_nonstatic_word_offset +
duke@435	2967	(nonstatic_word_count * BytesPerInt);
duke@435	2968	next_nonstatic_byte_offset = next_nonstatic_short_offset +
duke@435	2969	(nonstatic_short_count * BytesPerShort);
duke@435	2970
duke@435	2971	int notaligned_offset;
duke@435	2972	if( allocation_style == 0 ) {
duke@435	2973	notaligned_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
duke@435	2974	} else { // allocation_style == 1
duke@435	2975	next_nonstatic_oop_offset = next_nonstatic_byte_offset + nonstatic_byte_count;
duke@435	2976	if( nonstatic_oop_count > 0 ) {
coleenp@548	2977	next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
duke@435	2978	}
coleenp@548	2979	notaligned_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
duke@435	2980	}
kvn@600	2981	next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
duke@435	2982	nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
kvn@600	2983	- first_nonstatic_field_offset)/heapOopSize);
duke@435	2984
duke@435	2985	// Iterate over fields again and compute correct offsets.
duke@435	2986	// The field allocation type was temporarily stored in the offset slot.
duke@435	2987	// oop fields are located before non-oop fields (static and non-static).
duke@435	2988	int len = fields->length();
duke@435	2989	for (int i = 0; i < len; i += instanceKlass::next_offset) {
duke@435	2990	int real_offset;
duke@435	2991	FieldAllocationType atype = (FieldAllocationType) fields->ushort_at(i+4);
duke@435	2992	switch (atype) {
duke@435	2993	case STATIC_OOP:
duke@435	2994	real_offset = next_static_oop_offset;
coleenp@548	2995	next_static_oop_offset += heapOopSize;
duke@435	2996	break;
duke@435	2997	case STATIC_BYTE:
duke@435	2998	real_offset = next_static_byte_offset;
duke@435	2999	next_static_byte_offset += 1;
duke@435	3000	break;
duke@435	3001	case STATIC_SHORT:
duke@435	3002	real_offset = next_static_short_offset;
duke@435	3003	next_static_short_offset += BytesPerShort;
duke@435	3004	break;
duke@435	3005	case STATIC_WORD:
duke@435	3006	real_offset = next_static_word_offset;
duke@435	3007	next_static_word_offset += BytesPerInt;
duke@435	3008	break;
duke@435	3009	case STATIC_ALIGNED_DOUBLE:
duke@435	3010	case STATIC_DOUBLE:
duke@435	3011	real_offset = next_static_double_offset;
duke@435	3012	next_static_double_offset += BytesPerLong;
duke@435	3013	break;
duke@435	3014	case NONSTATIC_OOP:
duke@435	3015	if( nonstatic_oop_space_count > 0 ) {
duke@435	3016	real_offset = nonstatic_oop_space_offset;
coleenp@548	3017	nonstatic_oop_space_offset += heapOopSize;
duke@435	3018	nonstatic_oop_space_count -= 1;
duke@435	3019	} else {
duke@435	3020	real_offset = next_nonstatic_oop_offset;
coleenp@548	3021	next_nonstatic_oop_offset += heapOopSize;
duke@435	3022	}
duke@435	3023	// Update oop maps
duke@435	3024	if( nonstatic_oop_map_count > 0 &&
duke@435	3025	nonstatic_oop_offsets[nonstatic_oop_map_count - 1] ==
coleenp@548	3026	(u2)(real_offset - nonstatic_oop_length[nonstatic_oop_map_count - 1] * heapOopSize) ) {
duke@435	3027	// Extend current oop map
duke@435	3028	nonstatic_oop_length[nonstatic_oop_map_count - 1] += 1;
duke@435	3029	} else {
duke@435	3030	// Create new oop map
duke@435	3031	nonstatic_oop_offsets[nonstatic_oop_map_count] = (u2)real_offset;
duke@435	3032	nonstatic_oop_length [nonstatic_oop_map_count] = 1;
duke@435	3033	nonstatic_oop_map_count += 1;
duke@435	3034	if( first_nonstatic_oop_offset == 0 ) { // Undefined
duke@435	3035	first_nonstatic_oop_offset = real_offset;
duke@435	3036	}
duke@435	3037	}
duke@435	3038	break;
duke@435	3039	case NONSTATIC_BYTE:
duke@435	3040	if( nonstatic_byte_space_count > 0 ) {
duke@435	3041	real_offset = nonstatic_byte_space_offset;
duke@435	3042	nonstatic_byte_space_offset += 1;
duke@435	3043	nonstatic_byte_space_count -= 1;
duke@435	3044	} else {
duke@435	3045	real_offset = next_nonstatic_byte_offset;
duke@435	3046	next_nonstatic_byte_offset += 1;
duke@435	3047	}
duke@435	3048	break;
duke@435	3049	case NONSTATIC_SHORT:
duke@435	3050	if( nonstatic_short_space_count > 0 ) {
duke@435	3051	real_offset = nonstatic_short_space_offset;
duke@435	3052	nonstatic_short_space_offset += BytesPerShort;
duke@435	3053	nonstatic_short_space_count -= 1;
duke@435	3054	} else {
duke@435	3055	real_offset = next_nonstatic_short_offset;
duke@435	3056	next_nonstatic_short_offset += BytesPerShort;
duke@435	3057	}
duke@435	3058	break;
duke@435	3059	case NONSTATIC_WORD:
duke@435	3060	if( nonstatic_word_space_count > 0 ) {
duke@435	3061	real_offset = nonstatic_word_space_offset;
duke@435	3062	nonstatic_word_space_offset += BytesPerInt;
duke@435	3063	nonstatic_word_space_count -= 1;
duke@435	3064	} else {
duke@435	3065	real_offset = next_nonstatic_word_offset;
duke@435	3066	next_nonstatic_word_offset += BytesPerInt;
duke@435	3067	}
duke@435	3068	break;
duke@435	3069	case NONSTATIC_ALIGNED_DOUBLE:
duke@435	3070	case NONSTATIC_DOUBLE:
duke@435	3071	real_offset = next_nonstatic_double_offset;
duke@435	3072	next_nonstatic_double_offset += BytesPerLong;
duke@435	3073	break;
duke@435	3074	default:
duke@435	3075	ShouldNotReachHere();
duke@435	3076	}
duke@435	3077	fields->short_at_put(i+4, extract_low_short_from_int(real_offset) );
duke@435	3078	fields->short_at_put(i+5, extract_high_short_from_int(real_offset) );
duke@435	3079	}
duke@435	3080
duke@435	3081	// Size of instances
duke@435	3082	int instance_size;
duke@435	3083
kvn@600	3084	next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
duke@435	3085	instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
duke@435	3086
kvn@600	3087	assert(instance_size == align_object_size(align_size_up((instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize), wordSize) / wordSize), "consistent layout helper value");
duke@435	3088
duke@435	3089	// Size of non-static oop map blocks (in words) allocated at end of klass
duke@435	3090	int nonstatic_oop_map_size = compute_oop_map_size(super_klass, nonstatic_oop_map_count, first_nonstatic_oop_offset);
duke@435	3091
duke@435	3092	// Compute reference type
duke@435	3093	ReferenceType rt;
duke@435	3094	if (super_klass() == NULL) {
duke@435	3095	rt = REF_NONE;
duke@435	3096	} else {
duke@435	3097	rt = super_klass->reference_type();
duke@435	3098	}
duke@435	3099
duke@435	3100	// We can now create the basic klassOop for this klass
duke@435	3101	klassOop ik = oopFactory::new_instanceKlass(
duke@435	3102	vtable_size, itable_size,
duke@435	3103	static_field_size, nonstatic_oop_map_size,
duke@435	3104	rt, CHECK_(nullHandle));
duke@435	3105	instanceKlassHandle this_klass (THREAD, ik);
duke@435	3106
duke@435	3107	assert(this_klass->static_field_size() == static_field_size &&
duke@435	3108	this_klass->nonstatic_oop_map_size() == nonstatic_oop_map_size, "sanity check");
duke@435	3109
duke@435	3110	// Fill in information already parsed
duke@435	3111	this_klass->set_access_flags(access_flags);
duke@435	3112	jint lh = Klass::instance_layout_helper(instance_size, false);
duke@435	3113	this_klass->set_layout_helper(lh);
duke@435	3114	assert(this_klass->oop_is_instance(), "layout is correct");
duke@435	3115	assert(this_klass->size_helper() == instance_size, "correct size_helper");
duke@435	3116	// Not yet: supers are done below to support the new subtype-checking fields
duke@435	3117	//this_klass->set_super(super_klass());
duke@435	3118	this_klass->set_class_loader(class_loader());
duke@435	3119	this_klass->set_nonstatic_field_size(nonstatic_field_size);
coleenp@548	3120	this_klass->set_has_nonstatic_fields(has_nonstatic_fields);
duke@435	3121	this_klass->set_static_oop_field_size(fac.static_oop_count);
duke@435	3122	cp->set_pool_holder(this_klass());
duke@435	3123	this_klass->set_constants(cp());
duke@435	3124	this_klass->set_local_interfaces(local_interfaces());
duke@435	3125	this_klass->set_fields(fields());
duke@435	3126	this_klass->set_methods(methods());
duke@435	3127	if (has_final_method) {
duke@435	3128	this_klass->set_has_final_method();
duke@435	3129	}
duke@435	3130	this_klass->set_method_ordering(method_ordering());
duke@435	3131	this_klass->set_initial_method_idnum(methods->length());
duke@435	3132	this_klass->set_name(cp->klass_name_at(this_class_index));
jrose@909	3133	if (LinkWellKnownClasses) // I am well known to myself
jrose@909	3134	cp->klass_at_put(this_class_index, this_klass()); // eagerly resolve
duke@435	3135	this_klass->set_protection_domain(protection_domain());
duke@435	3136	this_klass->set_fields_annotations(fields_annotations());
duke@435	3137	this_klass->set_methods_annotations(methods_annotations());
duke@435	3138	this_klass->set_methods_parameter_annotations(methods_parameter_annotations());
duke@435	3139	this_klass->set_methods_default_annotations(methods_default_annotations());
duke@435	3140
duke@435	3141	this_klass->set_minor_version(minor_version);
duke@435	3142	this_klass->set_major_version(major_version);
duke@435	3143
duke@435	3144	if (cached_class_file_bytes != NULL) {
duke@435	3145	// JVMTI: we have an instanceKlass now, tell it about the cached bytes
duke@435	3146	this_klass->set_cached_class_file(cached_class_file_bytes,
duke@435	3147	cached_class_file_length);
duke@435	3148	}
duke@435	3149
duke@435	3150	// Miranda methods
duke@435	3151	if ((num_miranda_methods > 0) ||
duke@435	3152	// if this class introduced new miranda methods or
duke@435	3153	(super_klass.not_null() && (super_klass->has_miranda_methods()))
duke@435	3154	// super class exists and this class inherited miranda methods
duke@435	3155	) {
duke@435	3156	this_klass->set_has_miranda_methods(); // then set a flag
duke@435	3157	}
duke@435	3158
duke@435	3159	// Additional attributes
duke@435	3160	parse_classfile_attributes(cp, this_klass, CHECK_(nullHandle));
duke@435	3161
duke@435	3162	// Make sure this is the end of class file stream
duke@435	3163	guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle));
duke@435	3164
duke@435	3165	// Initialize static fields
duke@435	3166	this_klass->do_local_static_fields(&initialize_static_field, CHECK_(nullHandle));
duke@435	3167
duke@435	3168	// VerifyOops believes that once this has been set, the object is completely loaded.
duke@435	3169	// Compute transitive closure of interfaces this class implements
duke@435	3170	this_klass->set_transitive_interfaces(transitive_interfaces());
duke@435	3171
duke@435	3172	// Fill in information needed to compute superclasses.
duke@435	3173	this_klass->initialize_supers(super_klass(), CHECK_(nullHandle));
duke@435	3174
duke@435	3175	// Initialize itable offset tables
duke@435	3176	klassItable::setup_itable_offset_table(this_klass);
duke@435	3177
duke@435	3178	// Do final class setup
duke@435	3179	fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_length);
duke@435	3180
duke@435	3181	set_precomputed_flags(this_klass);
duke@435	3182
duke@435	3183	// reinitialize modifiers, using the InnerClasses attribute
duke@435	3184	int computed_modifiers = this_klass->compute_modifier_flags(CHECK_(nullHandle));
duke@435	3185	this_klass->set_modifier_flags(computed_modifiers);
duke@435	3186
duke@435	3187	// check if this class can access its super class
duke@435	3188	check_super_class_access(this_klass, CHECK_(nullHandle));
duke@435	3189
duke@435	3190	// check if this class can access its superinterfaces
duke@435	3191	check_super_interface_access(this_klass, CHECK_(nullHandle));
duke@435	3192
duke@435	3193	// check if this class overrides any final method
duke@435	3194	check_final_method_override(this_klass, CHECK_(nullHandle));
duke@435	3195
duke@435	3196	// check that if this class is an interface then it doesn't have static methods
duke@435	3197	if (this_klass->is_interface()) {
duke@435	3198	check_illegal_static_method(this_klass, CHECK_(nullHandle));
duke@435	3199	}
duke@435	3200
duke@435	3201	ClassLoadingService::notify_class_loaded(instanceKlass::cast(this_klass()),
duke@435	3202	false /* not shared class */);
duke@435	3203
duke@435	3204	if (TraceClassLoading) {
duke@435	3205	// print in a single call to reduce interleaving of output
duke@435	3206	if (cfs->source() != NULL) {
duke@435	3207	tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
duke@435	3208	cfs->source());
duke@435	3209	} else if (class_loader.is_null()) {
duke@435	3210	if (THREAD->is_Java_thread()) {
duke@435	3211	klassOop caller = ((JavaThread*)THREAD)->security_get_caller_class(1);
duke@435	3212	tty->print("[Loaded %s by instance of %s]\n",
duke@435	3213	this_klass->external_name(),
duke@435	3214	instanceKlass::cast(caller)->external_name());
duke@435	3215	} else {
duke@435	3216	tty->print("[Loaded %s]\n", this_klass->external_name());
duke@435	3217	}
duke@435	3218	} else {
duke@435	3219	ResourceMark rm;
duke@435	3220	tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
duke@435	3221	instanceKlass::cast(class_loader->klass())->external_name());
duke@435	3222	}
duke@435	3223	}
duke@435	3224
duke@435	3225	if (TraceClassResolution) {
duke@435	3226	// print out the superclass.
duke@435	3227	const char * from = Klass::cast(this_klass())->external_name();
duke@435	3228	if (this_klass->java_super() != NULL) {
duke@435	3229	tty->print("RESOLVE %s %s\n", from, instanceKlass::cast(this_klass->java_super())->external_name());
duke@435	3230	}
duke@435	3231	// print out each of the interface classes referred to by this class.
duke@435	3232	objArrayHandle local_interfaces(THREAD, this_klass->local_interfaces());
duke@435	3233	if (!local_interfaces.is_null()) {
duke@435	3234	int length = local_interfaces->length();
duke@435	3235	for (int i = 0; i < length; i++) {
duke@435	3236	klassOop k = klassOop(local_interfaces->obj_at(i));
duke@435	3237	instanceKlass* to_class = instanceKlass::cast(k);
duke@435	3238	const char * to = to_class->external_name();
duke@435	3239	tty->print("RESOLVE %s %s\n", from, to);
duke@435	3240	}
duke@435	3241	}
duke@435	3242	}
duke@435	3243
duke@435	3244	#ifndef PRODUCT
duke@435	3245	if( PrintCompactFieldsSavings ) {
duke@435	3246	if( nonstatic_field_size < orig_nonstatic_field_size ) {
kvn@600	3247	tty->print("[Saved %d of %d bytes in %s]\n",
kvn@600	3248	(orig_nonstatic_field_size - nonstatic_field_size)*heapOopSize,
kvn@600	3249	orig_nonstatic_field_size*heapOopSize,
kvn@600	3250	this_klass->external_name());
duke@435	3251	} else if( nonstatic_field_size > orig_nonstatic_field_size ) {
kvn@600	3252	tty->print("[Wasted %d over %d bytes in %s]\n",
kvn@600	3253	(nonstatic_field_size - orig_nonstatic_field_size)*heapOopSize,
kvn@600	3254	orig_nonstatic_field_size*heapOopSize,
kvn@600	3255	this_klass->external_name());
duke@435	3256	}
duke@435	3257	}
duke@435	3258	#endif
duke@435	3259
duke@435	3260	// preserve result across HandleMark
duke@435	3261	preserve_this_klass = this_klass();
duke@435	3262	}
duke@435	3263
duke@435	3264	// Create new handle outside HandleMark
duke@435	3265	instanceKlassHandle this_klass (THREAD, preserve_this_klass);
duke@435	3266	debug_only(this_klass->as_klassOop()->verify();)
duke@435	3267
duke@435	3268	return this_klass;
duke@435	3269	}
duke@435	3270
duke@435	3271
duke@435	3272	int ClassFileParser::compute_oop_map_size(instanceKlassHandle super, int nonstatic_oop_map_count, int first_nonstatic_oop_offset) {
duke@435	3273	int map_size = super.is_null() ? 0 : super->nonstatic_oop_map_size();
duke@435	3274	if (nonstatic_oop_map_count > 0) {
duke@435	3275	// We have oops to add to map
duke@435	3276	if (map_size == 0) {
duke@435	3277	map_size = nonstatic_oop_map_count;
duke@435	3278	} else {
duke@435	3279	// Check whether we should add a new map block or whether the last one can be extended
duke@435	3280	OopMapBlock* first_map = super->start_of_nonstatic_oop_maps();
duke@435	3281	OopMapBlock* last_map = first_map + map_size - 1;
duke@435	3282
coleenp@548	3283	int next_offset = last_map->offset() + (last_map->length() * heapOopSize);
duke@435	3284	if (next_offset == first_nonstatic_oop_offset) {
duke@435	3285	// There is no gap bettwen superklass's last oop field and first
duke@435	3286	// local oop field, merge maps.
duke@435	3287	nonstatic_oop_map_count -= 1;
duke@435	3288	} else {
duke@435	3289	// Superklass didn't end with a oop field, add extra maps
duke@435	3290	assert(next_offset<first_nonstatic_oop_offset, "just checking");
duke@435	3291	}
duke@435	3292	map_size += nonstatic_oop_map_count;
duke@435	3293	}
duke@435	3294	}
duke@435	3295	return map_size;
duke@435	3296	}
duke@435	3297
duke@435	3298
duke@435	3299	void ClassFileParser::fill_oop_maps(instanceKlassHandle k,
duke@435	3300	int nonstatic_oop_map_count,
duke@435	3301	u2* nonstatic_oop_offsets, u2* nonstatic_oop_length) {
duke@435	3302	OopMapBlock* this_oop_map = k->start_of_nonstatic_oop_maps();
duke@435	3303	OopMapBlock* last_oop_map = this_oop_map + k->nonstatic_oop_map_size();
duke@435	3304	instanceKlass* super = k->superklass();
duke@435	3305	if (super != NULL) {
duke@435	3306	int super_oop_map_size = super->nonstatic_oop_map_size();
duke@435	3307	OopMapBlock* super_oop_map = super->start_of_nonstatic_oop_maps();
duke@435	3308	// Copy maps from superklass
duke@435	3309	while (super_oop_map_size-- > 0) {
duke@435	3310	*this_oop_map++ = *super_oop_map++;
duke@435	3311	}
duke@435	3312	}
duke@435	3313	if (nonstatic_oop_map_count > 0) {
duke@435	3314	if (this_oop_map + nonstatic_oop_map_count > last_oop_map) {
duke@435	3315	// Calculated in compute_oop_map_size() number of oop maps is less then
duke@435	3316	// collected oop maps since there is no gap between superklass's last oop
duke@435	3317	// field and first local oop field. Extend the last oop map copied
duke@435	3318	// from the superklass instead of creating new one.
duke@435	3319	nonstatic_oop_map_count--;
duke@435	3320	nonstatic_oop_offsets++;
duke@435	3321	this_oop_map--;
duke@435	3322	this_oop_map->set_length(this_oop_map->length() + *nonstatic_oop_length++);
duke@435	3323	this_oop_map++;
duke@435	3324	}
duke@435	3325	assert((this_oop_map + nonstatic_oop_map_count) == last_oop_map, "just checking");
duke@435	3326	// Add new map blocks, fill them
duke@435	3327	while (nonstatic_oop_map_count-- > 0) {
duke@435	3328	this_oop_map->set_offset(*nonstatic_oop_offsets++);
duke@435	3329	this_oop_map->set_length(*nonstatic_oop_length++);
duke@435	3330	this_oop_map++;
duke@435	3331	}
duke@435	3332	}
duke@435	3333	}
duke@435	3334
duke@435	3335
duke@435	3336	void ClassFileParser::set_precomputed_flags(instanceKlassHandle k) {
duke@435	3337	klassOop super = k->super();
duke@435	3338
duke@435	3339	// Check if this klass has an empty finalize method (i.e. one with return bytecode only),
duke@435	3340	// in which case we don't have to register objects as finalizable
duke@435	3341	if (!_has_empty_finalizer) {
duke@435	3342	if (_has_finalizer ||
duke@435	3343	(super != NULL && super->klass_part()->has_finalizer())) {
duke@435	3344	k->set_has_finalizer();
duke@435	3345	}
duke@435	3346	}
duke@435	3347
duke@435	3348	#ifdef ASSERT
duke@435	3349	bool f = false;
duke@435	3350	methodOop m = k->lookup_method(vmSymbols::finalize_method_name(),
duke@435	3351	vmSymbols::void_method_signature());
duke@435	3352	if (m != NULL && !m->is_empty_method()) {
duke@435	3353	f = true;
duke@435	3354	}
duke@435	3355	assert(f == k->has_finalizer(), "inconsistent has_finalizer");
duke@435	3356	#endif
duke@435	3357
duke@435	3358	// Check if this klass supports the java.lang.Cloneable interface
duke@435	3359	if (SystemDictionary::cloneable_klass_loaded()) {
duke@435	3360	if (k->is_subtype_of(SystemDictionary::cloneable_klass())) {
duke@435	3361	k->set_is_cloneable();
duke@435	3362	}
duke@435	3363	}
duke@435	3364
duke@435	3365	// Check if this klass has a vanilla default constructor
duke@435	3366	if (super == NULL) {
duke@435	3367	// java.lang.Object has empty default constructor
duke@435	3368	k->set_has_vanilla_constructor();
duke@435	3369	} else {
duke@435	3370	if (Klass::cast(super)->has_vanilla_constructor() &&
duke@435	3371	_has_vanilla_constructor) {
duke@435	3372	k->set_has_vanilla_constructor();
duke@435	3373	}
duke@435	3374	#ifdef ASSERT
duke@435	3375	bool v = false;
duke@435	3376	if (Klass::cast(super)->has_vanilla_constructor()) {
duke@435	3377	methodOop constructor = k->find_method(vmSymbols::object_initializer_name(
duke@435	3378	), vmSymbols::void_method_signature());
duke@435	3379	if (constructor != NULL && constructor->is_vanilla_constructor()) {
duke@435	3380	v = true;
duke@435	3381	}
duke@435	3382	}
duke@435	3383	assert(v == k->has_vanilla_constructor(), "inconsistent has_vanilla_constructor");
duke@435	3384	#endif
duke@435	3385	}
duke@435	3386
duke@435	3387	// If it cannot be fast-path allocated, set a bit in the layout helper.
duke@435	3388	// See documentation of instanceKlass::can_be_fastpath_allocated().
duke@435	3389	assert(k->size_helper() > 0, "layout_helper is initialized");
duke@435	3390	if ((!RegisterFinalizersAtInit && k->has_finalizer())
duke@435	3391	|| k->is_abstract() || k->is_interface()
duke@435	3392	|| (k->name() == vmSymbols::java_lang_Class()
duke@435	3393	&& k->class_loader() == NULL)
duke@435	3394	|| k->size_helper() >= FastAllocateSizeLimit) {
duke@435	3395	// Forbid fast-path allocation.
duke@435	3396	jint lh = Klass::instance_layout_helper(k->size_helper(), true);
duke@435	3397	k->set_layout_helper(lh);
duke@435	3398	}
duke@435	3399	}
duke@435	3400
duke@435	3401
duke@435	3402	// utility method for appending and array with check for duplicates
duke@435	3403
duke@435	3404	void append_interfaces(objArrayHandle result, int& index, objArrayOop ifs) {
duke@435	3405	// iterate over new interfaces
duke@435	3406	for (int i = 0; i < ifs->length(); i++) {
duke@435	3407	oop e = ifs->obj_at(i);
duke@435	3408	assert(e->is_klass() && instanceKlass::cast(klassOop(e))->is_interface(), "just checking");
duke@435	3409	// check for duplicates
duke@435	3410	bool duplicate = false;
duke@435	3411	for (int j = 0; j < index; j++) {
duke@435	3412	if (result->obj_at(j) == e) {
duke@435	3413	duplicate = true;
duke@435	3414	break;
duke@435	3415	}
duke@435	3416	}
duke@435	3417	// add new interface
duke@435	3418	if (!duplicate) {
duke@435	3419	result->obj_at_put(index++, e);
duke@435	3420	}
duke@435	3421	}
duke@435	3422	}
duke@435	3423
duke@435	3424	objArrayHandle ClassFileParser::compute_transitive_interfaces(instanceKlassHandle super, objArrayHandle local_ifs, TRAPS) {
duke@435	3425	// Compute maximum size for transitive interfaces
duke@435	3426	int max_transitive_size = 0;
duke@435	3427	int super_size = 0;
duke@435	3428	// Add superclass transitive interfaces size
duke@435	3429	if (super.not_null()) {
duke@435	3430	super_size = super->transitive_interfaces()->length();
duke@435	3431	max_transitive_size += super_size;
duke@435	3432	}
duke@435	3433	// Add local interfaces' super interfaces
duke@435	3434	int local_size = local_ifs->length();
duke@435	3435	for (int i = 0; i < local_size; i++) {
duke@435	3436	klassOop l = klassOop(local_ifs->obj_at(i));
duke@435	3437	max_transitive_size += instanceKlass::cast(l)->transitive_interfaces()->length();
duke@435	3438	}
duke@435	3439	// Finally add local interfaces
duke@435	3440	max_transitive_size += local_size;
duke@435	3441	// Construct array
duke@435	3442	objArrayHandle result;
duke@435	3443	if (max_transitive_size == 0) {
duke@435	3444	// no interfaces, use canonicalized array
duke@435	3445	result = objArrayHandle(THREAD, Universe::the_empty_system_obj_array());
duke@435	3446	} else if (max_transitive_size == super_size) {
duke@435	3447	// no new local interfaces added, share superklass' transitive interface array
duke@435	3448	result = objArrayHandle(THREAD, super->transitive_interfaces());
duke@435	3449	} else if (max_transitive_size == local_size) {
duke@435	3450	// only local interfaces added, share local interface array
duke@435	3451	result = local_ifs;
duke@435	3452	} else {
duke@435	3453	objArrayHandle nullHandle;
duke@435	3454	objArrayOop new_objarray = oopFactory::new_system_objArray(max_transitive_size, CHECK_(nullHandle));
duke@435	3455	result = objArrayHandle(THREAD, new_objarray);
duke@435	3456	int index = 0;
duke@435	3457	// Copy down from superclass
duke@435	3458	if (super.not_null()) {
duke@435	3459	append_interfaces(result, index, super->transitive_interfaces());
duke@435	3460	}
duke@435	3461	// Copy down from local interfaces' superinterfaces
duke@435	3462	for (int i = 0; i < local_ifs->length(); i++) {
duke@435	3463	klassOop l = klassOop(local_ifs->obj_at(i));
duke@435	3464	append_interfaces(result, index, instanceKlass::cast(l)->transitive_interfaces());
duke@435	3465	}
duke@435	3466	// Finally add local interfaces
duke@435	3467	append_interfaces(result, index, local_ifs());
duke@435	3468
duke@435	3469	// Check if duplicates were removed
duke@435	3470	if (index != max_transitive_size) {
duke@435	3471	assert(index < max_transitive_size, "just checking");
duke@435	3472	objArrayOop new_result = oopFactory::new_system_objArray(index, CHECK_(nullHandle));
duke@435	3473	for (int i = 0; i < index; i++) {
duke@435	3474	oop e = result->obj_at(i);
duke@435	3475	assert(e != NULL, "just checking");
duke@435	3476	new_result->obj_at_put(i, e);
duke@435	3477	}
duke@435	3478	result = objArrayHandle(THREAD, new_result);
duke@435	3479	}
duke@435	3480	}
duke@435	3481	return result;
duke@435	3482	}
duke@435	3483
duke@435	3484
duke@435	3485	void ClassFileParser::check_super_class_access(instanceKlassHandle this_klass, TRAPS) {
duke@435	3486	klassOop super = this_klass->super();
duke@435	3487	if ((super != NULL) &&
duke@435	3488	(!Reflection::verify_class_access(this_klass->as_klassOop(), super, false))) {
duke@435	3489	ResourceMark rm(THREAD);
duke@435	3490	Exceptions::fthrow(
duke@435	3491	THREAD_AND_LOCATION,
duke@435	3492	vmSymbolHandles::java_lang_IllegalAccessError(),
duke@435	3493	"class %s cannot access its superclass %s",
duke@435	3494	this_klass->external_name(),
duke@435	3495	instanceKlass::cast(super)->external_name()
duke@435	3496	);
duke@435	3497	return;
duke@435	3498	}
duke@435	3499	}
duke@435	3500
duke@435	3501
duke@435	3502	void ClassFileParser::check_super_interface_access(instanceKlassHandle this_klass, TRAPS) {
duke@435	3503	objArrayHandle local_interfaces (THREAD, this_klass->local_interfaces());
duke@435	3504	int lng = local_interfaces->length();
duke@435	3505	for (int i = lng - 1; i >= 0; i--) {
duke@435	3506	klassOop k = klassOop(local_interfaces->obj_at(i));
duke@435	3507	assert (k != NULL && Klass::cast(k)->is_interface(), "invalid interface");
duke@435	3508	if (!Reflection::verify_class_access(this_klass->as_klassOop(), k, false)) {
duke@435	3509	ResourceMark rm(THREAD);
duke@435	3510	Exceptions::fthrow(
duke@435	3511	THREAD_AND_LOCATION,
duke@435	3512	vmSymbolHandles::java_lang_IllegalAccessError(),
duke@435	3513	"class %s cannot access its superinterface %s",
duke@435	3514	this_klass->external_name(),
duke@435	3515	instanceKlass::cast(k)->external_name()
duke@435	3516	);
duke@435	3517	return;
duke@435	3518	}
duke@435	3519	}
duke@435	3520	}
duke@435	3521
duke@435	3522
duke@435	3523	void ClassFileParser::check_final_method_override(instanceKlassHandle this_klass, TRAPS) {
duke@435	3524	objArrayHandle methods (THREAD, this_klass->methods());
duke@435	3525	int num_methods = methods->length();
duke@435	3526
duke@435	3527	// go thru each method and check if it overrides a final method
duke@435	3528	for (int index = 0; index < num_methods; index++) {
duke@435	3529	methodOop m = (methodOop)methods->obj_at(index);
duke@435	3530
duke@435	3531	// skip private, static and <init> methods
duke@435	3532	if ((!m->is_private()) &&
duke@435	3533	(!m->is_static()) &&
duke@435	3534	(m->name() != vmSymbols::object_initializer_name())) {
duke@435	3535
duke@435	3536	symbolOop name = m->name();
duke@435	3537	symbolOop signature = m->signature();
duke@435	3538	klassOop k = this_klass->super();
duke@435	3539	methodOop super_m = NULL;
duke@435	3540	while (k != NULL) {
duke@435	3541	// skip supers that don't have final methods.
duke@435	3542	if (k->klass_part()->has_final_method()) {
duke@435	3543	// lookup a matching method in the super class hierarchy
duke@435	3544	super_m = instanceKlass::cast(k)->lookup_method(name, signature);
duke@435	3545	if (super_m == NULL) {
duke@435	3546	break; // didn't find any match; get out
duke@435	3547	}
duke@435	3548
duke@435	3549	if (super_m->is_final() &&
duke@435	3550	// matching method in super is final
duke@435	3551	(Reflection::verify_field_access(this_klass->as_klassOop(),
duke@435	3552	super_m->method_holder(),
duke@435	3553	super_m->method_holder(),
duke@435	3554	super_m->access_flags(), false))
duke@435	3555	// this class can access super final method and therefore override
duke@435	3556	) {
duke@435	3557	ResourceMark rm(THREAD);
duke@435	3558	Exceptions::fthrow(
duke@435	3559	THREAD_AND_LOCATION,
duke@435	3560	vmSymbolHandles::java_lang_VerifyError(),
duke@435	3561	"class %s overrides final method %s.%s",
duke@435	3562	this_klass->external_name(),
duke@435	3563	name->as_C_string(),
duke@435	3564	signature->as_C_string()
duke@435	3565	);
duke@435	3566	return;
duke@435	3567	}
duke@435	3568
duke@435	3569	// continue to look from super_m's holder's super.
duke@435	3570	k = instanceKlass::cast(super_m->method_holder())->super();
duke@435	3571	continue;
duke@435	3572	}
duke@435	3573
duke@435	3574	k = k->klass_part()->super();
duke@435	3575	}
duke@435	3576	}
duke@435	3577	}
duke@435	3578	}
duke@435	3579
duke@435	3580
duke@435	3581	// assumes that this_klass is an interface
duke@435	3582	void ClassFileParser::check_illegal_static_method(instanceKlassHandle this_klass, TRAPS) {
duke@435	3583	assert(this_klass->is_interface(), "not an interface");
duke@435	3584	objArrayHandle methods (THREAD, this_klass->methods());
duke@435	3585	int num_methods = methods->length();
duke@435	3586
duke@435	3587	for (int index = 0; index < num_methods; index++) {
duke@435	3588	methodOop m = (methodOop)methods->obj_at(index);
duke@435	3589	// if m is static and not the init method, throw a verify error
duke@435	3590	if ((m->is_static()) && (m->name() != vmSymbols::class_initializer_name())) {
duke@435	3591	ResourceMark rm(THREAD);
duke@435	3592	Exceptions::fthrow(
duke@435	3593	THREAD_AND_LOCATION,
duke@435	3594	vmSymbolHandles::java_lang_VerifyError(),
duke@435	3595	"Illegal static method %s in interface %s",
duke@435	3596	m->name()->as_C_string(),
duke@435	3597	this_klass->external_name()
duke@435	3598	);
duke@435	3599	return;
duke@435	3600	}
duke@435	3601	}
duke@435	3602	}
duke@435	3603
duke@435	3604	// utility methods for format checking
duke@435	3605
duke@435	3606	void ClassFileParser::verify_legal_class_modifiers(jint flags, TRAPS) {
duke@435	3607	if (!_need_verify) { return; }
duke@435	3608
duke@435	3609	const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0;
duke@435	3610	const bool is_abstract = (flags & JVM_ACC_ABSTRACT) != 0;
duke@435	3611	const bool is_final = (flags & JVM_ACC_FINAL) != 0;
duke@435	3612	const bool is_super = (flags & JVM_ACC_SUPER) != 0;
duke@435	3613	const bool is_enum = (flags & JVM_ACC_ENUM) != 0;
duke@435	3614	const bool is_annotation = (flags & JVM_ACC_ANNOTATION) != 0;
duke@435	3615	const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
duke@435	3616
duke@435	3617	if ((is_abstract && is_final) ||
duke@435	3618	(is_interface && !is_abstract) ||
duke@435	3619	(is_interface && major_gte_15 && (is_super || is_enum)) ||
duke@435	3620	(!is_interface && major_gte_15 && is_annotation)) {
duke@435	3621	ResourceMark rm(THREAD);
duke@435	3622	Exceptions::fthrow(
duke@435	3623	THREAD_AND_LOCATION,
duke@435	3624	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3625	"Illegal class modifiers in class %s: 0x%X",
duke@435	3626	_class_name->as_C_string(), flags
duke@435	3627	);
duke@435	3628	return;
duke@435	3629	}
duke@435	3630	}
duke@435	3631
duke@435	3632	bool ClassFileParser::has_illegal_visibility(jint flags) {
duke@435	3633	const bool is_public = (flags & JVM_ACC_PUBLIC) != 0;
duke@435	3634	const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
duke@435	3635	const bool is_private = (flags & JVM_ACC_PRIVATE) != 0;
duke@435	3636
duke@435	3637	return ((is_public && is_protected) ||
duke@435	3638	(is_public && is_private) ||
duke@435	3639	(is_protected && is_private));
duke@435	3640	}
duke@435	3641
duke@435	3642	bool ClassFileParser::is_supported_version(u2 major, u2 minor) {
kamg@611	3643	u2 max_version = JDK_Version::is_gte_jdk17x_version() ?
kamg@611	3644	JAVA_MAX_SUPPORTED_VERSION : JAVA_6_VERSION;
duke@435	3645	return (major >= JAVA_MIN_SUPPORTED_VERSION) &&
kamg@611	3646	(major <= max_version) &&
kamg@611	3647	((major != max_version) ||
duke@435	3648	(minor <= JAVA_MAX_SUPPORTED_MINOR_VERSION));
duke@435	3649	}
duke@435	3650
duke@435	3651	void ClassFileParser::verify_legal_field_modifiers(
duke@435	3652	jint flags, bool is_interface, TRAPS) {
duke@435	3653	if (!_need_verify) { return; }
duke@435	3654
duke@435	3655	const bool is_public = (flags & JVM_ACC_PUBLIC) != 0;
duke@435	3656	const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
duke@435	3657	const bool is_private = (flags & JVM_ACC_PRIVATE) != 0;
duke@435	3658	const bool is_static = (flags & JVM_ACC_STATIC) != 0;
duke@435	3659	const bool is_final = (flags & JVM_ACC_FINAL) != 0;
duke@435	3660	const bool is_volatile = (flags & JVM_ACC_VOLATILE) != 0;
duke@435	3661	const bool is_transient = (flags & JVM_ACC_TRANSIENT) != 0;
duke@435	3662	const bool is_enum = (flags & JVM_ACC_ENUM) != 0;
duke@435	3663	const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
duke@435	3664
duke@435	3665	bool is_illegal = false;
duke@435	3666
duke@435	3667	if (is_interface) {
duke@435	3668	if (!is_public || !is_static || !is_final || is_private ||
duke@435	3669	is_protected || is_volatile || is_transient ||
duke@435	3670	(major_gte_15 && is_enum)) {
duke@435	3671	is_illegal = true;
duke@435	3672	}
duke@435	3673	} else { // not interface
duke@435	3674	if (has_illegal_visibility(flags) || (is_final && is_volatile)) {
duke@435	3675	is_illegal = true;
duke@435	3676	}
duke@435	3677	}
duke@435	3678
duke@435	3679	if (is_illegal) {
duke@435	3680	ResourceMark rm(THREAD);
duke@435	3681	Exceptions::fthrow(
duke@435	3682	THREAD_AND_LOCATION,
duke@435	3683	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3684	"Illegal field modifiers in class %s: 0x%X",
duke@435	3685	_class_name->as_C_string(), flags);
duke@435	3686	return;
duke@435	3687	}
duke@435	3688	}
duke@435	3689
duke@435	3690	void ClassFileParser::verify_legal_method_modifiers(
duke@435	3691	jint flags, bool is_interface, symbolHandle name, TRAPS) {
duke@435	3692	if (!_need_verify) { return; }
duke@435	3693
duke@435	3694	const bool is_public = (flags & JVM_ACC_PUBLIC) != 0;
duke@435	3695	const bool is_private = (flags & JVM_ACC_PRIVATE) != 0;
duke@435	3696	const bool is_static = (flags & JVM_ACC_STATIC) != 0;
duke@435	3697	const bool is_final = (flags & JVM_ACC_FINAL) != 0;
duke@435	3698	const bool is_native = (flags & JVM_ACC_NATIVE) != 0;
duke@435	3699	const bool is_abstract = (flags & JVM_ACC_ABSTRACT) != 0;
duke@435	3700	const bool is_bridge = (flags & JVM_ACC_BRIDGE) != 0;
duke@435	3701	const bool is_strict = (flags & JVM_ACC_STRICT) != 0;
duke@435	3702	const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0;
duke@435	3703	const bool major_gte_15 = _major_version >= JAVA_1_5_VERSION;
duke@435	3704	const bool is_initializer = (name == vmSymbols::object_initializer_name());
duke@435	3705
duke@435	3706	bool is_illegal = false;
duke@435	3707
duke@435	3708	if (is_interface) {
duke@435	3709	if (!is_abstract || !is_public || is_static || is_final ||
duke@435	3710	is_native || (major_gte_15 && (is_synchronized || is_strict))) {
duke@435	3711	is_illegal = true;
duke@435	3712	}
duke@435	3713	} else { // not interface
duke@435	3714	if (is_initializer) {
duke@435	3715	if (is_static || is_final || is_synchronized || is_native ||
duke@435	3716	is_abstract || (major_gte_15 && is_bridge)) {
duke@435	3717	is_illegal = true;
duke@435	3718	}
duke@435	3719	} else { // not initializer
duke@435	3720	if (is_abstract) {
duke@435	3721	if ((is_final || is_native || is_private || is_static ||
duke@435	3722	(major_gte_15 && (is_synchronized || is_strict)))) {
duke@435	3723	is_illegal = true;
duke@435	3724	}
duke@435	3725	}
duke@435	3726	if (has_illegal_visibility(flags)) {
duke@435	3727	is_illegal = true;
duke@435	3728	}
duke@435	3729	}
duke@435	3730	}
duke@435	3731
duke@435	3732	if (is_illegal) {
duke@435	3733	ResourceMark rm(THREAD);
duke@435	3734	Exceptions::fthrow(
duke@435	3735	THREAD_AND_LOCATION,
duke@435	3736	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3737	"Method %s in class %s has illegal modifiers: 0x%X",
duke@435	3738	name->as_C_string(), _class_name->as_C_string(), flags);
duke@435	3739	return;
duke@435	3740	}
duke@435	3741	}
duke@435	3742
duke@435	3743	void ClassFileParser::verify_legal_utf8(const unsigned char* buffer, int length, TRAPS) {
duke@435	3744	assert(_need_verify, "only called when _need_verify is true");
duke@435	3745	int i = 0;
duke@435	3746	int count = length >> 2;
duke@435	3747	for (int k=0; k<count; k++) {
duke@435	3748	unsigned char b0 = buffer[i];
duke@435	3749	unsigned char b1 = buffer[i+1];
duke@435	3750	unsigned char b2 = buffer[i+2];
duke@435	3751	unsigned char b3 = buffer[i+3];
duke@435	3752	// For an unsigned char v,
duke@435	3753	// (v | v - 1) is < 128 (highest bit 0) for 0 < v < 128;
duke@435	3754	// (v | v - 1) is >= 128 (highest bit 1) for v == 0 or v >= 128.
duke@435	3755	unsigned char res = b0 | b0 - 1 |
duke@435	3756	b1 | b1 - 1 |
duke@435	3757	b2 | b2 - 1 |
duke@435	3758	b3 | b3 - 1;
duke@435	3759	if (res >= 128) break;
duke@435	3760	i += 4;
duke@435	3761	}
duke@435	3762	for(; i < length; i++) {
duke@435	3763	unsigned short c;
duke@435	3764	// no embedded zeros
duke@435	3765	guarantee_property((buffer[i] != 0), "Illegal UTF8 string in constant pool in class file %s", CHECK);
duke@435	3766	if(buffer[i] < 128) {
duke@435	3767	continue;
duke@435	3768	}
duke@435	3769	if ((i + 5) < length) { // see if it's legal supplementary character
duke@435	3770	if (UTF8::is_supplementary_character(&buffer[i])) {
duke@435	3771	c = UTF8::get_supplementary_character(&buffer[i]);
duke@435	3772	i += 5;
duke@435	3773	continue;
duke@435	3774	}
duke@435	3775	}
duke@435	3776	switch (buffer[i] >> 4) {
duke@435	3777	default: break;
duke@435	3778	case 0x8: case 0x9: case 0xA: case 0xB: case 0xF:
duke@435	3779	classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
duke@435	3780	case 0xC: case 0xD: // 110xxxxx 10xxxxxx
duke@435	3781	c = (buffer[i] & 0x1F) << 6;
duke@435	3782	i++;
duke@435	3783	if ((i < length) && ((buffer[i] & 0xC0) == 0x80)) {
duke@435	3784	c += buffer[i] & 0x3F;
duke@435	3785	if (_major_version <= 47 || c == 0 || c >= 0x80) {
duke@435	3786	// for classes with major > 47, c must a null or a character in its shortest form
duke@435	3787	break;
duke@435	3788	}
duke@435	3789	}
duke@435	3790	classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
duke@435	3791	case 0xE: // 1110xxxx 10xxxxxx 10xxxxxx
duke@435	3792	c = (buffer[i] & 0xF) << 12;
duke@435	3793	i += 2;
duke@435	3794	if ((i < length) && ((buffer[i-1] & 0xC0) == 0x80) && ((buffer[i] & 0xC0) == 0x80)) {
duke@435	3795	c += ((buffer[i-1] & 0x3F) << 6) + (buffer[i] & 0x3F);
duke@435	3796	if (_major_version <= 47 || c >= 0x800) {
duke@435	3797	// for classes with major > 47, c must be in its shortest form
duke@435	3798	break;
duke@435	3799	}
duke@435	3800	}
duke@435	3801	classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", CHECK);
duke@435	3802	} // end of switch
duke@435	3803	} // end of for
duke@435	3804	}
duke@435	3805
duke@435	3806	// Checks if name is a legal class name.
duke@435	3807	void ClassFileParser::verify_legal_class_name(symbolHandle name, TRAPS) {
duke@435	3808	if (!_need_verify || _relax_verify) { return; }
duke@435	3809
duke@435	3810	char buf[fixed_buffer_size];
duke@435	3811	char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
duke@435	3812	unsigned int length = name->utf8_length();
duke@435	3813	bool legal = false;
duke@435	3814
duke@435	3815	if (length > 0) {
duke@435	3816	char* p;
duke@435	3817	if (bytes[0] == JVM_SIGNATURE_ARRAY) {
duke@435	3818	p = skip_over_field_signature(bytes, false, length, CHECK);
duke@435	3819	legal = (p != NULL) && ((p - bytes) == (int)length);
duke@435	3820	} else if (_major_version < JAVA_1_5_VERSION) {
duke@435	3821	if (bytes[0] != '<') {
duke@435	3822	p = skip_over_field_name(bytes, true, length);
duke@435	3823	legal = (p != NULL) && ((p - bytes) == (int)length);
duke@435	3824	}
duke@435	3825	} else {
duke@435	3826	// 4900761: relax the constraints based on JSR202 spec
duke@435	3827	// Class names may be drawn from the entire Unicode character set.
duke@435	3828	// Identifiers between '/' must be unqualified names.
duke@435	3829	// The utf8 string has been verified when parsing cpool entries.
duke@435	3830	legal = verify_unqualified_name(bytes, length, LegalClass);
duke@435	3831	}
duke@435	3832	}
duke@435	3833	if (!legal) {
duke@435	3834	ResourceMark rm(THREAD);
duke@435	3835	Exceptions::fthrow(
duke@435	3836	THREAD_AND_LOCATION,
duke@435	3837	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3838	"Illegal class name \"%s\" in class file %s", bytes,
duke@435	3839	_class_name->as_C_string()
duke@435	3840	);
duke@435	3841	return;
duke@435	3842	}
duke@435	3843	}
duke@435	3844
duke@435	3845	// Checks if name is a legal field name.
duke@435	3846	void ClassFileParser::verify_legal_field_name(symbolHandle name, TRAPS) {
duke@435	3847	if (!_need_verify || _relax_verify) { return; }
duke@435	3848
duke@435	3849	char buf[fixed_buffer_size];
duke@435	3850	char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
duke@435	3851	unsigned int length = name->utf8_length();
duke@435	3852	bool legal = false;
duke@435	3853
duke@435	3854	if (length > 0) {
duke@435	3855	if (_major_version < JAVA_1_5_VERSION) {
duke@435	3856	if (bytes[0] != '<') {
duke@435	3857	char* p = skip_over_field_name(bytes, false, length);
duke@435	3858	legal = (p != NULL) && ((p - bytes) == (int)length);
duke@435	3859	}
duke@435	3860	} else {
duke@435	3861	// 4881221: relax the constraints based on JSR202 spec
duke@435	3862	legal = verify_unqualified_name(bytes, length, LegalField);
duke@435	3863	}
duke@435	3864	}
duke@435	3865
duke@435	3866	if (!legal) {
duke@435	3867	ResourceMark rm(THREAD);
duke@435	3868	Exceptions::fthrow(
duke@435	3869	THREAD_AND_LOCATION,
duke@435	3870	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3871	"Illegal field name \"%s\" in class %s", bytes,
duke@435	3872	_class_name->as_C_string()
duke@435	3873	);
duke@435	3874	return;
duke@435	3875	}
duke@435	3876	}
duke@435	3877
duke@435	3878	// Checks if name is a legal method name.
duke@435	3879	void ClassFileParser::verify_legal_method_name(symbolHandle name, TRAPS) {
duke@435	3880	if (!_need_verify || _relax_verify) { return; }
duke@435	3881
duke@435	3882	assert(!name.is_null(), "method name is null");
duke@435	3883	char buf[fixed_buffer_size];
duke@435	3884	char* bytes = name->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
duke@435	3885	unsigned int length = name->utf8_length();
duke@435	3886	bool legal = false;
duke@435	3887
duke@435	3888	if (length > 0) {
duke@435	3889	if (bytes[0] == '<') {
duke@435	3890	if (name == vmSymbols::object_initializer_name() || name == vmSymbols::class_initializer_name()) {
duke@435	3891	legal = true;
duke@435	3892	}
duke@435	3893	} else if (_major_version < JAVA_1_5_VERSION) {
duke@435	3894	char* p;
duke@435	3895	p = skip_over_field_name(bytes, false, length);
duke@435	3896	legal = (p != NULL) && ((p - bytes) == (int)length);
duke@435	3897	} else {
duke@435	3898	// 4881221: relax the constraints based on JSR202 spec
duke@435	3899	legal = verify_unqualified_name(bytes, length, LegalMethod);
duke@435	3900	}
duke@435	3901	}
duke@435	3902
duke@435	3903	if (!legal) {
duke@435	3904	ResourceMark rm(THREAD);
duke@435	3905	Exceptions::fthrow(
duke@435	3906	THREAD_AND_LOCATION,
duke@435	3907	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3908	"Illegal method name \"%s\" in class %s", bytes,
duke@435	3909	_class_name->as_C_string()
duke@435	3910	);
duke@435	3911	return;
duke@435	3912	}
duke@435	3913	}
duke@435	3914
duke@435	3915
duke@435	3916	// Checks if signature is a legal field signature.
duke@435	3917	void ClassFileParser::verify_legal_field_signature(symbolHandle name, symbolHandle signature, TRAPS) {
duke@435	3918	if (!_need_verify) { return; }
duke@435	3919
duke@435	3920	char buf[fixed_buffer_size];
duke@435	3921	char* bytes = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
duke@435	3922	unsigned int length = signature->utf8_length();
duke@435	3923	char* p = skip_over_field_signature(bytes, false, length, CHECK);
duke@435	3924
duke@435	3925	if (p == NULL || (p - bytes) != (int)length) {
duke@435	3926	ResourceMark rm(THREAD);
duke@435	3927	Exceptions::fthrow(
duke@435	3928	THREAD_AND_LOCATION,
duke@435	3929	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3930	"Field \"%s\" in class %s has illegal signature \"%s\"",
duke@435	3931	name->as_C_string(), _class_name->as_C_string(), bytes
duke@435	3932	);
duke@435	3933	return;
duke@435	3934	}
duke@435	3935	}
duke@435	3936
duke@435	3937	// Checks if signature is a legal method signature.
duke@435	3938	// Returns number of parameters
duke@435	3939	int ClassFileParser::verify_legal_method_signature(symbolHandle name, symbolHandle signature, TRAPS) {
duke@435	3940	if (!_need_verify) {
duke@435	3941	// make sure caller's args_size will be less than 0 even for non-static
duke@435	3942	// method so it will be recomputed in compute_size_of_parameters().
duke@435	3943	return -2;
duke@435	3944	}
duke@435	3945
duke@435	3946	unsigned int args_size = 0;
duke@435	3947	char buf[fixed_buffer_size];
duke@435	3948	char* p = signature->as_utf8_flexible_buffer(THREAD, buf, fixed_buffer_size);
duke@435	3949	unsigned int length = signature->utf8_length();
duke@435	3950	char* nextp;
duke@435	3951
duke@435	3952	// The first character must be a '('
duke@435	3953	if ((length > 0) && (*p++ == JVM_SIGNATURE_FUNC)) {
duke@435	3954	length--;
duke@435	3955	// Skip over legal field signatures
duke@435	3956	nextp = skip_over_field_signature(p, false, length, CHECK_0);
duke@435	3957	while ((length > 0) && (nextp != NULL)) {
duke@435	3958	args_size++;
duke@435	3959	if (p[0] == 'J' || p[0] == 'D') {
duke@435	3960	args_size++;
duke@435	3961	}
duke@435	3962	length -= nextp - p;
duke@435	3963	p = nextp;
duke@435	3964	nextp = skip_over_field_signature(p, false, length, CHECK_0);
duke@435	3965	}
duke@435	3966	// The first non-signature thing better be a ')'
duke@435	3967	if ((length > 0) && (*p++ == JVM_SIGNATURE_ENDFUNC)) {
duke@435	3968	length--;
duke@435	3969	if (name->utf8_length() > 0 && name->byte_at(0) == '<') {
duke@435	3970	// All internal methods must return void
duke@435	3971	if ((length == 1) && (p[0] == JVM_SIGNATURE_VOID)) {
duke@435	3972	return args_size;
duke@435	3973	}
duke@435	3974	} else {
duke@435	3975	// Now we better just have a return value
duke@435	3976	nextp = skip_over_field_signature(p, true, length, CHECK_0);
duke@435	3977	if (nextp && ((int)length == (nextp - p))) {
duke@435	3978	return args_size;
duke@435	3979	}
duke@435	3980	}
duke@435	3981	}
duke@435	3982	}
duke@435	3983	// Report error
duke@435	3984	ResourceMark rm(THREAD);
duke@435	3985	Exceptions::fthrow(
duke@435	3986	THREAD_AND_LOCATION,
duke@435	3987	vmSymbolHandles::java_lang_ClassFormatError(),
duke@435	3988	"Method \"%s\" in class %s has illegal signature \"%s\"",
duke@435	3989	name->as_C_string(), _class_name->as_C_string(), p
duke@435	3990	);
duke@435	3991	return 0;
duke@435	3992	}
duke@435	3993
duke@435	3994
duke@435	3995	// Unqualified names may not contain the characters '.', ';', or '/'.
duke@435	3996	// Method names also may not contain the characters '<' or '>', unless <init> or <clinit>.
duke@435	3997	// Note that method names may not be <init> or <clinit> in this method.
duke@435	3998	// Because these names have been checked as special cases before calling this method
duke@435	3999	// in verify_legal_method_name.
duke@435	4000	bool ClassFileParser::verify_unqualified_name(char* name, unsigned int length, int type) {
duke@435	4001	jchar ch;
duke@435	4002
duke@435	4003	for (char* p = name; p != name + length; ) {
duke@435	4004	ch = *p;
duke@435	4005	if (ch < 128) {
duke@435	4006	p++;
duke@435	4007	if (ch == '.' || ch == ';') {
duke@435	4008	return false; // do not permit '.' or ';'
duke@435	4009	}
duke@435	4010	if (type != LegalClass && ch == '/') {
duke@435	4011	return false; // do not permit '/' unless it's class name
duke@435	4012	}
duke@435	4013	if (type == LegalMethod && (ch == '<' || ch == '>')) {
duke@435	4014	return false; // do not permit '<' or '>' in method names
duke@435	4015	}
duke@435	4016	} else {
duke@435	4017	char* tmp_p = UTF8::next(p, &ch);
duke@435	4018	p = tmp_p;
duke@435	4019	}
duke@435	4020	}
duke@435	4021	return true;
duke@435	4022	}
duke@435	4023
duke@435	4024
duke@435	4025	// Take pointer to a string. Skip over the longest part of the string that could
duke@435	4026	// be taken as a fieldname. Allow '/' if slash_ok is true.
duke@435	4027	// Return a pointer to just past the fieldname.
duke@435	4028	// Return NULL if no fieldname at all was found, or in the case of slash_ok
duke@435	4029	// being true, we saw consecutive slashes (meaning we were looking for a
duke@435	4030	// qualified path but found something that was badly-formed).
duke@435	4031	char* ClassFileParser::skip_over_field_name(char* name, bool slash_ok, unsigned int length) {
duke@435	4032	char* p;
duke@435	4033	jchar ch;
duke@435	4034	jboolean last_is_slash = false;
duke@435	4035	jboolean not_first_ch = false;
duke@435	4036
duke@435	4037	for (p = name; p != name + length; not_first_ch = true) {
duke@435	4038	char* old_p = p;
duke@435	4039	ch = *p;
duke@435	4040	if (ch < 128) {
duke@435	4041	p++;
duke@435	4042	// quick check for ascii
duke@435	4043	if ((ch >= 'a' && ch <= 'z') ||
duke@435	4044	(ch >= 'A' && ch <= 'Z') ||
duke@435	4045	(ch == '_' || ch == '$') ||
duke@435	4046	(not_first_ch && ch >= '0' && ch <= '9')) {
duke@435	4047	last_is_slash = false;
duke@435	4048	continue;
duke@435	4049	}
duke@435	4050	if (slash_ok && ch == '/') {
duke@435	4051	if (last_is_slash) {
duke@435	4052	return NULL; // Don't permit consecutive slashes
duke@435	4053	}
duke@435	4054	last_is_slash = true;
duke@435	4055	continue;
duke@435	4056	}
duke@435	4057	} else {
duke@435	4058	jint unicode_ch;
duke@435	4059	char* tmp_p = UTF8::next_character(p, &unicode_ch);
duke@435	4060	p = tmp_p;
duke@435	4061	last_is_slash = false;
duke@435	4062	// Check if ch is Java identifier start or is Java identifier part
duke@435	4063	// 4672820: call java.lang.Character methods directly without generating separate tables.
duke@435	4064	EXCEPTION_MARK;
duke@435	4065	instanceKlassHandle klass (THREAD, SystemDictionary::char_klass());
duke@435	4066
duke@435	4067	// return value
duke@435	4068	JavaValue result(T_BOOLEAN);
duke@435	4069	// Set up the arguments to isJavaIdentifierStart and isJavaIdentifierPart
duke@435	4070	JavaCallArguments args;
duke@435	4071	args.push_int(unicode_ch);
duke@435	4072
duke@435	4073	// public static boolean isJavaIdentifierStart(char ch);
duke@435	4074	JavaCalls::call_static(&result,
duke@435	4075	klass,
duke@435	4076	vmSymbolHandles::isJavaIdentifierStart_name(),
duke@435	4077	vmSymbolHandles::int_bool_signature(),
duke@435	4078	&args,
duke@435	4079	THREAD);
duke@435	4080
duke@435	4081	if (HAS_PENDING_EXCEPTION) {
duke@435	4082	CLEAR_PENDING_EXCEPTION;
duke@435	4083	return 0;
duke@435	4084	}
duke@435	4085	if (result.get_jboolean()) {
duke@435	4086	continue;
duke@435	4087	}
duke@435	4088
duke@435	4089	if (not_first_ch) {
duke@435	4090	// public static boolean isJavaIdentifierPart(char ch);
duke@435	4091	JavaCalls::call_static(&result,
duke@435	4092	klass,
duke@435	4093	vmSymbolHandles::isJavaIdentifierPart_name(),
duke@435	4094	vmSymbolHandles::int_bool_signature(),
duke@435	4095	&args,
duke@435	4096	THREAD);
duke@435	4097
duke@435	4098	if (HAS_PENDING_EXCEPTION) {
duke@435	4099	CLEAR_PENDING_EXCEPTION;
duke@435	4100	return 0;
duke@435	4101	}
duke@435	4102
duke@435	4103	if (result.get_jboolean()) {
duke@435	4104	continue;
duke@435	4105	}
duke@435	4106	}
duke@435	4107	}
duke@435	4108	return (not_first_ch) ? old_p : NULL;
duke@435	4109	}
duke@435	4110	return (not_first_ch) ? p : NULL;
duke@435	4111	}
duke@435	4112
duke@435	4113
duke@435	4114	// Take pointer to a string. Skip over the longest part of the string that could
duke@435	4115	// be taken as a field signature. Allow "void" if void_ok.
duke@435	4116	// Return a pointer to just past the signature.
duke@435	4117	// Return NULL if no legal signature is found.
duke@435	4118	char* ClassFileParser::skip_over_field_signature(char* signature,
duke@435	4119	bool void_ok,
duke@435	4120	unsigned int length,
duke@435	4121	TRAPS) {
duke@435	4122	unsigned int array_dim = 0;
duke@435	4123	while (length > 0) {
duke@435	4124	switch (signature[0]) {
duke@435	4125	case JVM_SIGNATURE_VOID: if (!void_ok) { return NULL; }
duke@435	4126	case JVM_SIGNATURE_BOOLEAN:
duke@435	4127	case JVM_SIGNATURE_BYTE:
duke@435	4128	case JVM_SIGNATURE_CHAR:
duke@435	4129	case JVM_SIGNATURE_SHORT:
duke@435	4130	case JVM_SIGNATURE_INT:
duke@435	4131	case JVM_SIGNATURE_FLOAT:
duke@435	4132	case JVM_SIGNATURE_LONG:
duke@435	4133	case JVM_SIGNATURE_DOUBLE:
duke@435	4134	return signature + 1;
duke@435	4135	case JVM_SIGNATURE_CLASS: {
duke@435	4136	if (_major_version < JAVA_1_5_VERSION) {
duke@435	4137	// Skip over the class name if one is there
duke@435	4138	char* p = skip_over_field_name(signature + 1, true, --length);
duke@435	4139
duke@435	4140	// The next character better be a semicolon
duke@435	4141	if (p && (p - signature) > 1 && p[0] == ';') {
duke@435	4142	return p + 1;
duke@435	4143	}
duke@435	4144	} else {
duke@435	4145	// 4900761: For class version > 48, any unicode is allowed in class name.
duke@435	4146	length--;
duke@435	4147	signature++;
duke@435	4148	while (length > 0 && signature[0] != ';') {
duke@435	4149	if (signature[0] == '.') {
duke@435	4150	classfile_parse_error("Class name contains illegal character '.' in descriptor in class file %s", CHECK_0);
duke@435	4151	}
duke@435	4152	length--;
duke@435	4153	signature++;
duke@435	4154	}
duke@435	4155	if (signature[0] == ';') { return signature + 1; }
duke@435	4156	}
duke@435	4157
duke@435	4158	return NULL;
duke@435	4159	}
duke@435	4160	case JVM_SIGNATURE_ARRAY:
duke@435	4161	array_dim++;
duke@435	4162	if (array_dim > 255) {
duke@435	4163	// 4277370: array descriptor is valid only if it represents 255 or fewer dimensions.
duke@435	4164	classfile_parse_error("Array type descriptor has more than 255 dimensions in class file %s", CHECK_0);
duke@435	4165	}
duke@435	4166	// The rest of what's there better be a legal signature
duke@435	4167	signature++;
duke@435	4168	length--;
duke@435	4169	void_ok = false;
duke@435	4170	break;
duke@435	4171
duke@435	4172	default:
duke@435	4173	return NULL;
duke@435	4174	}
duke@435	4175	}
duke@435	4176	return NULL;
duke@435	4177	}