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

src/share/vm/oops/instanceRefKlass.cpp@a61af66fc99e (annotated)

src/share/vm/oops/instanceRefKlass.cpp

Sat, 01 Dec 2007 00:00:00 +0000

author

duke

date

Sat, 01 Dec 2007 00:00:00 +0000

changeset 435

a61af66fc99e

child 548

ba764ed4b6f2

permissions

-rw-r--r--

Initial load

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	# include "incls/_precompiled.incl"
duke@435	26	# include "incls/_instanceRefKlass.cpp.incl"
duke@435	27
duke@435	28	void instanceRefKlass::oop_follow_contents(oop obj) {
duke@435	29	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
duke@435	30	oop referent = *referent_addr;
duke@435	31	debug_only(
duke@435	32	if(TraceReferenceGC && PrintGCDetails) {
duke@435	33	gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, (address)obj);
duke@435	34	}
duke@435	35	)
duke@435	36	if (referent != NULL) {
duke@435	37	if (!referent->is_gc_marked() &&
duke@435	38	MarkSweep::ref_processor()->
duke@435	39	discover_reference(obj, reference_type())) {
duke@435	40	// reference already enqueued, referent will be traversed later
duke@435	41	instanceKlass::oop_follow_contents(obj);
duke@435	42	debug_only(
duke@435	43	if(TraceReferenceGC && PrintGCDetails) {
duke@435	44	gclog_or_tty->print_cr(" Non NULL enqueued " INTPTR_FORMAT, (address)obj);
duke@435	45	}
duke@435	46	)
duke@435	47	return;
duke@435	48	} else {
duke@435	49	// treat referent as normal oop
duke@435	50	debug_only(
duke@435	51	if(TraceReferenceGC && PrintGCDetails) {
duke@435	52	gclog_or_tty->print_cr(" Non NULL normal " INTPTR_FORMAT, (address)obj);
duke@435	53	}
duke@435	54	)
duke@435	55	MarkSweep::mark_and_push(referent_addr);
duke@435	56	}
duke@435	57	}
duke@435	58	// treat next as normal oop. next is a link in the pending list.
duke@435	59	oop* next_addr = java_lang_ref_Reference::next_addr(obj);
duke@435	60	debug_only(
duke@435	61	if(TraceReferenceGC && PrintGCDetails) {
duke@435	62	gclog_or_tty->print_cr(" Process next as normal " INTPTR_FORMAT, next_addr);
duke@435	63	}
duke@435	64	)
duke@435	65	MarkSweep::mark_and_push(next_addr);
duke@435	66	instanceKlass::oop_follow_contents(obj);
duke@435	67	}
duke@435	68
duke@435	69	#ifndef SERIALGC
duke@435	70	void instanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
duke@435	71	oop obj) {
duke@435	72	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
duke@435	73	oop referent = *referent_addr;
duke@435	74	debug_only(
duke@435	75	if(TraceReferenceGC && PrintGCDetails) {
duke@435	76	gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, (address)obj);
duke@435	77	}
duke@435	78	)
duke@435	79	if (referent != NULL) {
duke@435	80	if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
duke@435	81	PSParallelCompact::ref_processor()->
duke@435	82	discover_reference(obj, reference_type())) {
duke@435	83	// reference already enqueued, referent will be traversed later
duke@435	84	instanceKlass::oop_follow_contents(cm, obj);
duke@435	85	debug_only(
duke@435	86	if(TraceReferenceGC && PrintGCDetails) {
duke@435	87	gclog_or_tty->print_cr(" Non NULL enqueued " INTPTR_FORMAT, (address)obj);
duke@435	88	}
duke@435	89	)
duke@435	90	return;
duke@435	91	} else {
duke@435	92	// treat referent as normal oop
duke@435	93	debug_only(
duke@435	94	if(TraceReferenceGC && PrintGCDetails) {
duke@435	95	gclog_or_tty->print_cr(" Non NULL normal " INTPTR_FORMAT, (address)obj);
duke@435	96	}
duke@435	97	)
duke@435	98	PSParallelCompact::mark_and_push(cm, referent_addr);
duke@435	99	}
duke@435	100	}
duke@435	101	// treat next as normal oop. next is a link in the pending list.
duke@435	102	oop* next_addr = java_lang_ref_Reference::next_addr(obj);
duke@435	103	debug_only(
duke@435	104	if(TraceReferenceGC && PrintGCDetails) {
duke@435	105	gclog_or_tty->print_cr(" Process next as normal " INTPTR_FORMAT, next_addr);
duke@435	106	}
duke@435	107	)
duke@435	108	PSParallelCompact::mark_and_push(cm, next_addr);
duke@435	109	instanceKlass::oop_follow_contents(cm, obj);
duke@435	110	}
duke@435	111	#endif // SERIALGC
duke@435	112
duke@435	113
duke@435	114	int instanceRefKlass::oop_adjust_pointers(oop obj) {
duke@435	115	int size = size_helper();
duke@435	116	instanceKlass::oop_adjust_pointers(obj);
duke@435	117
duke@435	118	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
duke@435	119	MarkSweep::adjust_pointer(referent_addr);
duke@435	120	oop* next_addr = java_lang_ref_Reference::next_addr(obj);
duke@435	121	MarkSweep::adjust_pointer(next_addr);
duke@435	122	oop* discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
duke@435	123	MarkSweep::adjust_pointer(discovered_addr);
duke@435	124
duke@435	125	#ifdef ASSERT
duke@435	126	if(TraceReferenceGC && PrintGCDetails) {
duke@435	127	gclog_or_tty->print_cr("instanceRefKlass::oop_adjust_pointers obj "
duke@435	128	INTPTR_FORMAT, (address)obj);
duke@435	129	gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
duke@435	130	INTPTR_FORMAT, referent_addr,
duke@435	131	referent_addr ? (address)*referent_addr : NULL);
duke@435	132	gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
duke@435	133	INTPTR_FORMAT, next_addr,
duke@435	134	next_addr ? (address)*next_addr : NULL);
duke@435	135	gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
duke@435	136	INTPTR_FORMAT, discovered_addr,
duke@435	137	discovered_addr ? (address)*discovered_addr : NULL);
duke@435	138	}
duke@435	139	#endif
duke@435	140
duke@435	141	return size;
duke@435	142	}
duke@435	143
duke@435	144	#define InstanceRefKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
duke@435	145	\
duke@435	146	int instanceRefKlass:: \
duke@435	147	oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \
duke@435	148	/* Get size before changing pointers */ \
duke@435	149	SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
duke@435	150	\
duke@435	151	int size = instanceKlass::oop_oop_iterate##nv_suffix(obj, closure); \
duke@435	152	\
duke@435	153	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj); \
duke@435	154	oop referent = *referent_addr; \
duke@435	155	if (referent != NULL) { \
duke@435	156	ReferenceProcessor* rp = closure->_ref_processor; \
duke@435	157	if (!referent->is_gc_marked() && (rp != NULL) && \
duke@435	158	rp->discover_reference(obj, reference_type())) { \
duke@435	159	return size; \
duke@435	160	} else { \
duke@435	161	/* treat referent as normal oop */ \
duke@435	162	SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
duke@435	163	closure->do_oop##nv_suffix(referent_addr); \
duke@435	164	} \
duke@435	165	} \
duke@435	166	\
duke@435	167	/* treat next as normal oop */ \
duke@435	168	oop* next_addr = java_lang_ref_Reference::next_addr(obj); \
duke@435	169	SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk); \
duke@435	170	closure->do_oop##nv_suffix(next_addr); \
duke@435	171	return size; \
duke@435	172	}
duke@435	173
duke@435	174	#define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
duke@435	175	\
duke@435	176	int instanceRefKlass:: \
duke@435	177	oop_oop_iterate##nv_suffix##_m(oop obj, \
duke@435	178	OopClosureType* closure, \
duke@435	179	MemRegion mr) { \
duke@435	180	SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
duke@435	181	\
duke@435	182	int size = instanceKlass::oop_oop_iterate##nv_suffix##_m(obj, closure, mr); \
duke@435	183	\
duke@435	184	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj); \
duke@435	185	oop referent = *referent_addr; \
duke@435	186	if (referent != NULL && mr.contains(referent_addr)) { \
duke@435	187	ReferenceProcessor* rp = closure->_ref_processor; \
duke@435	188	if (!referent->is_gc_marked() && (rp != NULL) && \
duke@435	189	rp->discover_reference(obj, reference_type())) { \
duke@435	190	return size; \
duke@435	191	} else { \
duke@435	192	/* treat referent as normal oop */ \
duke@435	193	SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
duke@435	194	closure->do_oop##nv_suffix(referent_addr); \
duke@435	195	} \
duke@435	196	} \
duke@435	197	\
duke@435	198	/* treat next as normal oop */ \
duke@435	199	oop* next_addr = java_lang_ref_Reference::next_addr(obj); \
duke@435	200	if (mr.contains(next_addr)) { \
duke@435	201	SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
duke@435	202	closure->do_oop##nv_suffix(next_addr); \
duke@435	203	} \
duke@435	204	return size; \
duke@435	205	}
duke@435	206
duke@435	207	ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
duke@435	208	ALL_OOP_OOP_ITERATE_CLOSURES_3(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
duke@435	209	ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
duke@435	210	ALL_OOP_OOP_ITERATE_CLOSURES_3(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
duke@435	211
duke@435	212
duke@435	213	#ifndef SERIALGC
duke@435	214	void instanceRefKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
duke@435	215	assert(!pm->depth_first(), "invariant");
duke@435	216	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
duke@435	217	if (PSScavenge::should_scavenge(*referent_addr)) {
duke@435	218	ReferenceProcessor* rp = PSScavenge::reference_processor();
duke@435	219	if (rp->discover_reference(obj, reference_type())) {
duke@435	220	// reference already enqueued, referent and next will be traversed later
duke@435	221	instanceKlass::oop_copy_contents(pm, obj);
duke@435	222	return;
duke@435	223	} else {
duke@435	224	// treat referent as normal oop
duke@435	225	pm->claim_or_forward_breadth(referent_addr);
duke@435	226	}
duke@435	227	}
duke@435	228	// treat next as normal oop
duke@435	229	oop* next_addr = java_lang_ref_Reference::next_addr(obj);
duke@435	230	if (PSScavenge::should_scavenge(*next_addr)) {
duke@435	231	pm->claim_or_forward_breadth(next_addr);
duke@435	232	}
duke@435	233	instanceKlass::oop_copy_contents(pm, obj);
duke@435	234	}
duke@435	235
duke@435	236	void instanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
duke@435	237	assert(pm->depth_first(), "invariant");
duke@435	238	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
duke@435	239	if (PSScavenge::should_scavenge(*referent_addr)) {
duke@435	240	ReferenceProcessor* rp = PSScavenge::reference_processor();
duke@435	241	if (rp->discover_reference(obj, reference_type())) {
duke@435	242	// reference already enqueued, referent and next will be traversed later
duke@435	243	instanceKlass::oop_push_contents(pm, obj);
duke@435	244	return;
duke@435	245	} else {
duke@435	246	// treat referent as normal oop
duke@435	247	pm->claim_or_forward_depth(referent_addr);
duke@435	248	}
duke@435	249	}
duke@435	250	// treat next as normal oop
duke@435	251	oop* next_addr = java_lang_ref_Reference::next_addr(obj);
duke@435	252	if (PSScavenge::should_scavenge(*next_addr)) {
duke@435	253	pm->claim_or_forward_depth(next_addr);
duke@435	254	}
duke@435	255	instanceKlass::oop_push_contents(pm, obj);
duke@435	256	}
duke@435	257
duke@435	258	int instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
duke@435	259	instanceKlass::oop_update_pointers(cm, obj);
duke@435	260
duke@435	261	oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
duke@435	262	PSParallelCompact::adjust_pointer(referent_addr);
duke@435	263	oop* next_addr = java_lang_ref_Reference::next_addr(obj);
duke@435	264	PSParallelCompact::adjust_pointer(next_addr);
duke@435	265	oop* discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
duke@435	266	PSParallelCompact::adjust_pointer(discovered_addr);
duke@435	267
duke@435	268	#ifdef ASSERT
duke@435	269	if(TraceReferenceGC && PrintGCDetails) {
duke@435	270	gclog_or_tty->print_cr("instanceRefKlass::oop_update_pointers obj "
duke@435	271	INTPTR_FORMAT, (oopDesc*) obj);
duke@435	272	gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
duke@435	273	INTPTR_FORMAT, referent_addr,
duke@435	274	referent_addr ? (oopDesc*) *referent_addr : NULL);
duke@435	275	gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
duke@435	276	INTPTR_FORMAT, next_addr,
duke@435	277	next_addr ? (oopDesc*) *next_addr : NULL);
duke@435	278	gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
duke@435	279	INTPTR_FORMAT, discovered_addr,
duke@435	280	discovered_addr ? (oopDesc*) *discovered_addr : NULL);
duke@435	281	}
duke@435	282	#endif
duke@435	283
duke@435	284	return size_helper();
duke@435	285	}
duke@435	286
duke@435	287	int
duke@435	288	instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
duke@435	289	HeapWord* beg_addr, HeapWord* end_addr) {
duke@435	290	instanceKlass::oop_update_pointers(cm, obj, beg_addr, end_addr);
duke@435	291
duke@435	292	oop* p;
duke@435	293	oop* referent_addr = p = java_lang_ref_Reference::referent_addr(obj);
duke@435	294	PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
duke@435	295	oop* next_addr = p = java_lang_ref_Reference::next_addr(obj);
duke@435	296	PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
duke@435	297	oop* discovered_addr = p = java_lang_ref_Reference::discovered_addr(obj);
duke@435	298	PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
duke@435	299
duke@435	300	#ifdef ASSERT
duke@435	301	if(TraceReferenceGC && PrintGCDetails) {
duke@435	302	gclog_or_tty->print_cr("instanceRefKlass::oop_update_pointers obj "
duke@435	303	INTPTR_FORMAT, (oopDesc*) obj);
duke@435	304	gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
duke@435	305	INTPTR_FORMAT, referent_addr,
duke@435	306	referent_addr ? (oopDesc*) *referent_addr : NULL);
duke@435	307	gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
duke@435	308	INTPTR_FORMAT, next_addr,
duke@435	309	next_addr ? (oopDesc*) *next_addr : NULL);
duke@435	310	gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
duke@435	311	INTPTR_FORMAT, discovered_addr,
duke@435	312	discovered_addr ? (oopDesc*) *discovered_addr : NULL);
duke@435	313	}
duke@435	314	#endif
duke@435	315
duke@435	316	return size_helper();
duke@435	317	}
duke@435	318	#endif // SERIALGC
duke@435	319
duke@435	320	void instanceRefKlass::update_nonstatic_oop_maps(klassOop k) {
duke@435	321	// Clear the nonstatic oop-map entries corresponding to referent
duke@435	322	// and nextPending field. They are treated specially by the
duke@435	323	// garbage collector.
duke@435	324	// The discovered field is used only by the garbage collector
duke@435	325	// and is also treated specially.
duke@435	326	instanceKlass* ik = instanceKlass::cast(k);
duke@435	327
duke@435	328	// Check that we have the right class
duke@435	329	debug_only(static bool first_time = true);
duke@435	330	assert(k == SystemDictionary::reference_klass() && first_time,
duke@435	331	"Invalid update of maps");
duke@435	332	debug_only(first_time = false);
duke@435	333	assert(ik->nonstatic_oop_map_size() == 1, "just checking");
duke@435	334
duke@435	335	OopMapBlock* map = ik->start_of_nonstatic_oop_maps();
duke@435	336
duke@435	337	// Check that the current map is (2,4) - currently points at field with
duke@435	338	// offset 2 (words) and has 4 map entries.
duke@435	339	debug_only(int offset = java_lang_ref_Reference::referent_offset);
duke@435	340	debug_only(int length = ((java_lang_ref_Reference::discovered_offset -
duke@435	341	java_lang_ref_Reference::referent_offset)/wordSize) + 1);
duke@435	342
duke@435	343	if (UseSharedSpaces) {
duke@435	344	assert(map->offset() == java_lang_ref_Reference::queue_offset &&
duke@435	345	map->length() == 1, "just checking");
duke@435	346	} else {
duke@435	347	assert(map->offset() == offset && map->length() == length,
duke@435	348	"just checking");
duke@435	349
duke@435	350	// Update map to (3,1) - point to offset of 3 (words) with 1 map entry.
duke@435	351	map->set_offset(java_lang_ref_Reference::queue_offset);
duke@435	352	map->set_length(1);
duke@435	353	}
duke@435	354	}
duke@435	355
duke@435	356
duke@435	357	// Verification
duke@435	358
duke@435	359	void instanceRefKlass::oop_verify_on(oop obj, outputStream* st) {
duke@435	360	instanceKlass::oop_verify_on(obj, st);
duke@435	361	// Verify referent field
duke@435	362	oop referent = java_lang_ref_Reference::referent(obj);
duke@435	363
duke@435	364	// We should make this general to all heaps
duke@435	365	GenCollectedHeap* gch = NULL;
duke@435	366	if (Universe::heap()->kind() == CollectedHeap::GenCollectedHeap)
duke@435	367	gch = GenCollectedHeap::heap();
duke@435	368
duke@435	369	if (referent != NULL) {
duke@435	370	guarantee(referent->is_oop(), "referent field heap failed");
duke@435	371	if (gch != NULL && !gch->is_in_youngest(obj))
duke@435	372	// We do a specific remembered set check here since the referent
duke@435	373	// field is not part of the oop mask and therefore skipped by the
duke@435	374	// regular verify code.
duke@435	375	obj->verify_old_oop(java_lang_ref_Reference::referent_addr(obj), true);
duke@435	376	}
duke@435	377	// Verify next field
duke@435	378	oop next = java_lang_ref_Reference::next(obj);
duke@435	379	if (next != NULL) {
duke@435	380	guarantee(next->is_oop(), "next field verify failed");
duke@435	381	guarantee(next->is_instanceRef(), "next field verify failed");
duke@435	382	if (gch != NULL && !gch->is_in_youngest(obj)) {
duke@435	383	// We do a specific remembered set check here since the next field is
duke@435	384	// not part of the oop mask and therefore skipped by the regular
duke@435	385	// verify code.
duke@435	386	obj->verify_old_oop(java_lang_ref_Reference::next_addr(obj), true);
duke@435	387	}
duke@435	388	}
duke@435	389	}
duke@435	390
duke@435	391	void instanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {
duke@435	392	// we may enter this with pending exception set
duke@435	393	PRESERVE_EXCEPTION_MARK; // exceptions are never thrown, needed for TRAPS argument
duke@435	394	Handle h_lock(THREAD, java_lang_ref_Reference::pending_list_lock());
duke@435	395	ObjectSynchronizer::fast_enter(h_lock, pending_list_basic_lock, false, THREAD);
duke@435	396	assert(ObjectSynchronizer::current_thread_holds_lock(
duke@435	397	JavaThread::current(), h_lock),
duke@435	398	"Locking should have succeeded");
duke@435	399	if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;
duke@435	400	}
duke@435	401
duke@435	402	void instanceRefKlass::release_and_notify_pending_list_lock(
duke@435	403	BasicLock *pending_list_basic_lock) {
duke@435	404	// we may enter this with pending exception set
duke@435	405	PRESERVE_EXCEPTION_MARK; // exceptions are never thrown, needed for TRAPS argument
duke@435	406	//
duke@435	407	Handle h_lock(THREAD, java_lang_ref_Reference::pending_list_lock());
duke@435	408	assert(ObjectSynchronizer::current_thread_holds_lock(
duke@435	409	JavaThread::current(), h_lock),
duke@435	410	"Lock should be held");
duke@435	411	// Notify waiters on pending lists lock if there is any reference.
duke@435	412	if (java_lang_ref_Reference::pending_list() != NULL) {
duke@435	413	ObjectSynchronizer::notifyall(h_lock, THREAD);
duke@435	414	}
duke@435	415	ObjectSynchronizer::fast_exit(h_lock(), pending_list_basic_lock, THREAD);
duke@435	416	if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;
duke@435	417	}