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

src/share/vm/oops/klassVtable.hpp@4aaa9f5e02a8 (annotated)

src/share/vm/oops/klassVtable.hpp

Wed, 18 Mar 2009 17:20:57 -0400

author

acorn

date

Wed, 18 Mar 2009 17:20:57 -0400

changeset 1087

4aaa9f5e02a8

parent 451

f8236e79048a

child 1111

d3676b4cb78c

permissions

-rw-r--r--

4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
Reviewed-by: kamg, coleenp

duke@435	1	/*
duke@435	2	* Copyright 1997-2006 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	// A klassVtable abstracts the variable-length vtable that is embedded in instanceKlass
duke@435	26	// and arrayKlass. klassVtable objects are used just as convenient transient accessors to the vtable,
duke@435	27	// not to actually hold the vtable data.
duke@435	28	// Note: the klassVtable should not be accessed before the class has been verified
duke@435	29	// (until that point, the vtable is uninitialized).
duke@435	30
duke@435	31	// Currently a klassVtable contains a direct reference to the vtable data, and is therefore
duke@435	32	// not preserved across GCs.
duke@435	33
duke@435	34	class vtableEntry;
duke@435	35
duke@435	36	class klassVtable : public ResourceObj {
duke@435	37	KlassHandle _klass; // my klass
duke@435	38	int _tableOffset; // offset of start of vtable data within klass
duke@435	39	int _length; // length of vtable (number of entries)
duke@435	40	#ifndef PRODUCT
duke@435	41	int _verify_count; // to make verify faster
duke@435	42	#endif
duke@435	43
duke@435	44	// Ordering important, so greater_than (>) can be used as an merge operator.
duke@435	45	enum AccessType {
duke@435	46	acc_private = 0,
duke@435	47	acc_package_private = 1,
duke@435	48	acc_publicprotected = 2
duke@435	49	};
duke@435	50
duke@435	51	public:
duke@435	52	klassVtable(KlassHandle h_klass, void* base, int length) : _klass(h_klass) {
duke@435	53	_tableOffset = (address)base - (address)h_klass(); _length = length;
duke@435	54	}
duke@435	55
duke@435	56	// accessors
duke@435	57	vtableEntry* table() const { return (vtableEntry*)(address(_klass()) + _tableOffset); }
duke@435	58	KlassHandle klass() const { return _klass; }
duke@435	59	int length() const { return _length; }
duke@435	60	inline methodOop method_at(int i) const;
duke@435	61	inline methodOop unchecked_method_at(int i) const;
duke@435	62	inline oop* adr_method_at(int i) const;
duke@435	63
duke@435	64	// searching; all methods return -1 if not found
duke@435	65	int index_of(methodOop m) const { return index_of(m, _length); }
duke@435	66	int index_of_miranda(symbolOop name, symbolOop signature);
duke@435	67
duke@435	68	void initialize_vtable(bool checkconstraints, TRAPS); // initialize vtable of a new klass
duke@435	69
duke@435	70	// conputes vtable length (in words) and the number of miranda methods
duke@435	71	static void compute_vtable_size_and_num_mirandas(int &vtable_length, int &num_miranda_methods,
duke@435	72	klassOop super, objArrayOop methods,
acorn@1087	73	AccessFlags class_flags, Handle classloader,
acorn@1087	74	symbolHandle classname, objArrayOop local_interfaces,
acorn@1087	75	TRAPS);
duke@435	76
duke@435	77	// RedefineClasses() API support:
duke@435	78	// If any entry of this vtable points to any of old_methods,
duke@435	79	// replace it with the corresponding new_method.
duke@435	80	// trace_name_printed is set to true if the current call has
duke@435	81	// printed the klass name so that other routines in the adjust_*
duke@435	82	// group don't print the klass name.
duke@435	83	void adjust_method_entries(methodOop* old_methods, methodOop* new_methods,
duke@435	84	int methods_length, bool * trace_name_printed);
duke@435	85
duke@435	86	// Garbage collection
duke@435	87	void oop_follow_contents();
duke@435	88	void oop_adjust_pointers();
duke@435	89
duke@435	90	#ifndef SERIALGC
duke@435	91	// Parallel Old
duke@435	92	void oop_follow_contents(ParCompactionManager* cm);
duke@435	93	void oop_update_pointers(ParCompactionManager* cm);
duke@435	94	void oop_update_pointers(ParCompactionManager* cm,
duke@435	95	HeapWord* beg_addr, HeapWord* end_addr);
duke@435	96	#endif // SERIALGC
duke@435	97
duke@435	98	// Iterators
duke@435	99	void oop_oop_iterate(OopClosure* blk);
duke@435	100	void oop_oop_iterate_m(OopClosure* blk, MemRegion mr);
duke@435	101
duke@435	102	// Debugging code
duke@435	103	void print() PRODUCT_RETURN;
duke@435	104	void verify(outputStream* st, bool force = false);
duke@435	105	static void print_statistics() PRODUCT_RETURN;
duke@435	106
duke@435	107	#ifndef PRODUCT
duke@435	108	bool check_no_old_entries();
duke@435	109	void dump_vtable();
duke@435	110	#endif
duke@435	111
duke@435	112	protected:
duke@435	113	friend class vtableEntry;
duke@435	114	private:
acorn@1087	115	enum { VTABLE_TRANSITIVE_OVERRIDE_VERSION = 51 } ;
duke@435	116	void copy_vtable_to(vtableEntry* start);
duke@435	117	int initialize_from_super(KlassHandle super);
duke@435	118	int index_of(methodOop m, int len) const; // same as index_of, but search only up to len
duke@435	119	void put_method_at(methodOop m, int index);
acorn@1087	120	static bool needs_new_vtable_entry(methodHandle m, klassOop super, Handle classloader, symbolHandle classname, AccessFlags access_flags, TRAPS);
duke@435	121
acorn@1087	122	bool update_inherited_vtable(instanceKlass* klass, methodHandle target_method, int super_vtable_len, bool checkconstraints, TRAPS);
acorn@1087	123	instanceKlass* find_transitive_override(instanceKlass* initialsuper, methodHandle target_method, int vtable_index,
acorn@1087	124	Handle target_loader, symbolHandle target_classname, Thread* THREAD);
duke@435	125
duke@435	126	// support for miranda methods
duke@435	127	bool is_miranda_entry_at(int i);
duke@435	128	void fill_in_mirandas(int& initialized);
duke@435	129	static bool is_miranda(methodOop m, objArrayOop class_methods, klassOop super);
duke@435	130	static void add_new_mirandas_to_list(GrowableArray<methodOop>* list_of_current_mirandas, objArrayOop current_interface_methods, objArrayOop class_methods, klassOop super);
duke@435	131	static void get_mirandas(GrowableArray<methodOop>* mirandas, klassOop super, objArrayOop class_methods, objArrayOop local_interfaces);
duke@435	132	static int get_num_mirandas(klassOop super, objArrayOop class_methods, objArrayOop local_interfaces);
duke@435	133
duke@435	134
duke@435	135	void verify_against(outputStream* st, klassVtable* vt, int index);
duke@435	136	inline instanceKlass* ik() const;
duke@435	137	};
duke@435	138
duke@435	139
duke@435	140	// private helper class for klassVtable
duke@435	141	// description of entry points:
duke@435	142	// destination is interpreted:
duke@435	143	// from_compiled_code_entry_point -> c2iadapter
duke@435	144	// from_interpreter_entry_point -> interpreter entry point
duke@435	145	// destination is compiled:
duke@435	146	// from_compiled_code_entry_point -> nmethod entry point
duke@435	147	// from_interpreter_entry_point -> i2cadapter
duke@435	148	class vtableEntry VALUE_OBJ_CLASS_SPEC {
duke@435	149	public:
duke@435	150	// size in words
duke@435	151	static int size() {
duke@435	152	return sizeof(vtableEntry) / sizeof(HeapWord);
duke@435	153	}
duke@435	154	static int method_offset_in_bytes() { return offset_of(vtableEntry, _method); }
duke@435	155	methodOop method() const { return _method; }
duke@435	156
duke@435	157	private:
duke@435	158	methodOop _method;
duke@435	159	void set(methodOop method) { assert(method != NULL, "use clear"); _method = method; }
duke@435	160	void clear() { _method = NULL; }
duke@435	161	void print() PRODUCT_RETURN;
duke@435	162	void verify(klassVtable* vt, outputStream* st);
duke@435	163
duke@435	164	friend class klassVtable;
duke@435	165	};
duke@435	166
duke@435	167
duke@435	168	inline methodOop klassVtable::method_at(int i) const {
duke@435	169	assert(i >= 0 && i < _length, "index out of bounds");
duke@435	170	assert(table()[i].method() != NULL, "should not be null");
duke@435	171	assert(oop(table()[i].method())->is_method(), "should be method");
duke@435	172	return table()[i].method();
duke@435	173	}
duke@435	174
duke@435	175	inline methodOop klassVtable::unchecked_method_at(int i) const {
duke@435	176	assert(i >= 0 && i < _length, "index out of bounds");
duke@435	177	return table()[i].method();
duke@435	178	}
duke@435	179
duke@435	180	inline oop* klassVtable::adr_method_at(int i) const {
duke@435	181	// Allow one past the last entry to be referenced; useful for loop bounds.
duke@435	182	assert(i >= 0 && i <= _length, "index out of bounds");
duke@435	183	return (oop*)(address(table() + i) + vtableEntry::method_offset_in_bytes());
duke@435	184	}
duke@435	185
duke@435	186	// --------------------------------------------------------------------------------
duke@435	187	class klassItable;
duke@435	188	class itableMethodEntry;
duke@435	189
duke@435	190	class itableOffsetEntry VALUE_OBJ_CLASS_SPEC {
duke@435	191	private:
duke@435	192	klassOop _interface;
duke@435	193	int _offset;
duke@435	194	public:
duke@435	195	klassOop interface_klass() const { return _interface; }
duke@435	196	int offset() const { return _offset; }
duke@435	197
duke@435	198	static itableMethodEntry* method_entry(klassOop k, int offset) { return (itableMethodEntry*)(((address)k) + offset); }
duke@435	199	itableMethodEntry* first_method_entry(klassOop k) { return method_entry(k, _offset); }
duke@435	200
duke@435	201	void initialize(klassOop interf, int offset) { _interface = interf; _offset = offset; }
duke@435	202
duke@435	203	// Static size and offset accessors
duke@435	204	static int size() { return sizeof(itableOffsetEntry) / HeapWordSize; } // size in words
duke@435	205	static int interface_offset_in_bytes() { return offset_of(itableOffsetEntry, _interface); }
duke@435	206	static int offset_offset_in_bytes() { return offset_of(itableOffsetEntry, _offset); }
duke@435	207
duke@435	208	friend class klassItable;
duke@435	209	};
duke@435	210
duke@435	211
duke@435	212	class itableMethodEntry VALUE_OBJ_CLASS_SPEC {
duke@435	213	private:
duke@435	214	methodOop _method;
duke@435	215
duke@435	216	public:
duke@435	217	methodOop method() const { return _method; }
duke@435	218
duke@435	219	void clear() { _method = NULL; }
duke@435	220
duke@435	221	void initialize(methodOop method);
duke@435	222
duke@435	223	// Static size and offset accessors
duke@435	224	static int size() { return sizeof(itableMethodEntry) / HeapWordSize; } // size in words
duke@435	225	static int method_offset_in_bytes() { return offset_of(itableMethodEntry, _method); }
duke@435	226
duke@435	227	friend class klassItable;
duke@435	228	};
duke@435	229
duke@435	230	//
duke@435	231	// Format of an itable
duke@435	232	//
duke@435	233	// ---- offset table ---
duke@435	234	// klassOop of interface 1 \
duke@435	235	// offset to vtable from start of oop / offset table entry
duke@435	236	// ...
duke@435	237	// klassOop of interface n \
duke@435	238	// offset to vtable from start of oop / offset table entry
duke@435	239	// --- vtable for interface 1 ---
duke@435	240	// methodOop \
duke@435	241	// compiler entry point / method table entry
duke@435	242	// ...
duke@435	243	// methodOop \
duke@435	244	// compiler entry point / method table entry
duke@435	245	// -- vtable for interface 2 ---
duke@435	246	// ...
duke@435	247	//
duke@435	248	class klassItable : public ResourceObj {
duke@435	249	private:
duke@435	250	instanceKlassHandle _klass; // my klass
duke@435	251	int _table_offset; // offset of start of itable data within klass (in words)
duke@435	252	int _size_offset_table; // size of offset table (in itableOffset entries)
duke@435	253	int _size_method_table; // size of methodtable (in itableMethodEntry entries)
duke@435	254
duke@435	255	void initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS);
duke@435	256	public:
duke@435	257	klassItable(instanceKlassHandle klass);
duke@435	258
duke@435	259	itableOffsetEntry* offset_entry(int i) { assert(0 <= i && i <= _size_offset_table, "index out of bounds");
duke@435	260	return &((itableOffsetEntry*)vtable_start())[i]; }
duke@435	261
duke@435	262	itableMethodEntry* method_entry(int i) { assert(0 <= i && i <= _size_method_table, "index out of bounds");
duke@435	263	return &((itableMethodEntry*)method_start())[i]; }
duke@435	264
dcubed@451	265	int size_offset_table() { return _size_offset_table; }
duke@435	266
duke@435	267	// Initialization
duke@435	268	void initialize_itable(bool checkconstraints, TRAPS);
duke@435	269
duke@435	270	// Updates
duke@435	271	void initialize_with_method(methodOop m);
duke@435	272
duke@435	273	// RedefineClasses() API support:
duke@435	274	// if any entry of this itable points to any of old_methods,
duke@435	275	// replace it with the corresponding new_method.
duke@435	276	// trace_name_printed is set to true if the current call has
duke@435	277	// printed the klass name so that other routines in the adjust_*
duke@435	278	// group don't print the klass name.
duke@435	279	void adjust_method_entries(methodOop* old_methods, methodOop* new_methods,
duke@435	280	int methods_length, bool * trace_name_printed);
duke@435	281
duke@435	282	// Garbage collection
duke@435	283	void oop_follow_contents();
duke@435	284	void oop_adjust_pointers();
duke@435	285
duke@435	286	#ifndef SERIALGC
duke@435	287	// Parallel Old
duke@435	288	void oop_follow_contents(ParCompactionManager* cm);
duke@435	289	void oop_update_pointers(ParCompactionManager* cm);
duke@435	290	void oop_update_pointers(ParCompactionManager* cm,
duke@435	291	HeapWord* beg_addr, HeapWord* end_addr);
duke@435	292	#endif // SERIALGC
duke@435	293
duke@435	294	// Iterators
duke@435	295	void oop_oop_iterate(OopClosure* blk);
duke@435	296	void oop_oop_iterate_m(OopClosure* blk, MemRegion mr);
duke@435	297
duke@435	298	// Setup of itable
duke@435	299	static int compute_itable_size(objArrayHandle transitive_interfaces);
duke@435	300	static void setup_itable_offset_table(instanceKlassHandle klass);
duke@435	301
duke@435	302	// Resolving of method to index
duke@435	303	static int compute_itable_index(methodOop m);
duke@435	304
duke@435	305	// Debugging/Statistics
duke@435	306	static void print_statistics() PRODUCT_RETURN;
duke@435	307	private:
duke@435	308	intptr_t* vtable_start() const { return ((intptr_t*)_klass()) + _table_offset; }
duke@435	309	intptr_t* method_start() const { return vtable_start() + _size_offset_table * itableOffsetEntry::size(); }
duke@435	310
duke@435	311	// Helper methods
duke@435	312	static int calc_itable_size(int num_interfaces, int num_methods) { return (num_interfaces * itableOffsetEntry::size()) + (num_methods * itableMethodEntry::size()); }
duke@435	313
duke@435	314	// Statistics
duke@435	315	NOT_PRODUCT(static int _total_classes;) // Total no. of classes with itables
duke@435	316	NOT_PRODUCT(static long _total_size;) // Total no. of bytes used for itables
duke@435	317
duke@435	318	static void update_stats(int size) PRODUCT_RETURN NOT_PRODUCT({ _total_classes++; _total_size += size; })
duke@435	319	};