#include <gnu/gcj/runtime/StringBuffer.h>
#include <jvm.h>
-static void unintern (jobject);
static jstring* strhash = NULL;
static int strhash_count = 0; /* Number of slots used in strhash. */
static int strhash_size = 0; /* Number of slots available in strhash.
jstring* ptr = _Jv_StringGetSlot(this);
if (*ptr != NULL && *ptr != DELETED_STRING)
{
- // See description in unintern() to understand this.
+ // See description in _Jv_FinalizeString() to understand this.
*ptr = (jstring) MASK_PTR (*ptr);
return (jstring) UNMASK_PTR (*ptr);
}
- jstring str = this->data == this ? this
- : _Jv_NewString(JvGetStringChars(this), this->length());
+ jstring str = (this->data == this
+ ? this
+ : _Jv_NewString(JvGetStringChars(this), this->length()));
SET_STRING_IS_INTERNED(str);
strhash_count++;
*ptr = str;
// When string is GC'd, clear the slot in the hash table.
- _Jv_RegisterFinalizer ((void *) str, unintern);
+ _Jv_RegisterStringFinalizer (str);
return str;
}
-/* Called by String fake finalizer. */
-static void
-unintern (jobject obj)
+// The fake String finalizer. This is only used when the String has
+// been intern()d. However, we must check this case, as it might be
+// called by the Reference code for any String.
+void
+_Jv_FinalizeString (jobject obj)
{
JvSynchronize sync (&StringClass);
+
+ // We might not actually have intern()d any strings at all, if
+ // we're being called from Reference.
+ if (! strhash)
+ return;
+
jstring str = reinterpret_cast<jstring> (obj);
- jstring* ptr = _Jv_StringGetSlot(str);
- if (*ptr == NULL || *ptr == DELETED_STRING)
+ jstring *ptr = _Jv_StringGetSlot(str);
+ if (*ptr == NULL || *ptr == DELETED_STRING
+ || (jobject) UNMASK_PTR (*ptr) != obj)
return;
// We assume the lowest bit of the pointer is free for our nefarious
// interning the String. If we subsequently re-intern the same
// String, then we set the bit. When finalizing, if the bit is set
// then we clear it and re-register the finalizer. We know this is
- // a safe approach because both intern() and unintern() acquire
- // the class lock; this bit can't be manipulated when the lock is
- // not held. So if we are finalizing and the bit is clear then we
- // know all references are gone and we can clear the entry in the
- // hash table. The naive approach of simply clearing the pointer
- // here fails in the case where a request to intern a new string
- // with the same contents is made between the time the intern()d
- // string is found to be unreachable and when the finalizer is
- // actually run. In this case we could clear a pointer to a valid
- // string, and future intern() calls for that particular value would
- // spuriously fail.
+ // a safe approach because both intern() and _Jv_FinalizeString()
+ // acquire the class lock; this bit can't be manipulated when the
+ // lock is not held. So if we are finalizing and the bit is clear
+ // then we know all references are gone and we can clear the entry
+ // in the hash table. The naive approach of simply clearing the
+ // pointer here fails in the case where a request to intern a new
+ // string with the same contents is made between the time the
+ // intern()d string is found to be unreachable and when the
+ // finalizer is actually run. In this case we could clear a pointer
+ // to a valid string, and future intern() calls for that particular
+ // value would spuriously fail.
if (PTR_MASKED (*ptr))
{
*ptr = (jstring) UNMASK_PTR (*ptr);
- _Jv_RegisterFinalizer ((void *) obj, unintern);
+ _Jv_RegisterStringFinalizer (obj);
}
else
{
jstr->cachedHashCode = hash;
*ptr = jstr;
SET_STRING_IS_INTERNED(jstr);
- // When string is GC'd, clear the slot in the hash table.
- _Jv_RegisterFinalizer ((void *) jstr, unintern);
+ // When string is GC'd, clear the slot in the hash table. Note that
+ // we don't have to call _Jv_RegisterStringFinalizer here, as we
+ // know the new object cannot be referred to by a Reference.
+ _Jv_RegisterFinalizer ((void *) jstr, _Jv_FinalizeString);
return jstr;
}
}
}
+// Return list head if object is in hash, NULL otherwise.
+object_list *
+in_hash (jobject obj)
+{
+ // The hash table might not yet be initialized.
+ if (hash == NULL)
+ return NULL;
+ object_list *head = find_slot (obj);
+ if (head->reference != obj)
+ return NULL;
+ return head;
+}
+
// FIXME what happens if an object's finalizer creates a Reference to
// the object, and the object has never before been added to the hash?
// Madness!
*link = n;
}
+// Add a FINALIZE entry if one doesn't exist.
+static void
+maybe_add_finalize (object_list *entry, jobject obj)
+{
+ object_list **link = &entry->next;
+ object_list *iter = *link;
+ while (iter && iter->weight < FINALIZE)
+ {
+ link = &iter->next;
+ iter = *link;
+ }
+
+ // We want at most one FINALIZE entry in the queue.
+ if (iter && iter->weight == FINALIZE)
+ return;
+
+ object_list *n = (object_list *) _Jv_Malloc (sizeof (object_list));
+ n->reference = obj;
+ n->weight = FINALIZE;
+ n->next = *link;
+ *link = n;
+}
+
// This is called when an object is ready to be finalized. This
// actually implements the appropriate Reference semantics.
static void
enum weight w = head->weight;
if (w == FINALIZE)
{
+ // Update the list first, as _Jv_FinalizeString might end up
+ // looking at this data structure.
+ list->next = head->next;
+ _Jv_Free (head);
+
// If we have a Reference A to a Reference B, and B is
// finalized, then we have to take special care to make sure
// that B is properly deregistered. This is super gross. FIXME
// will it fail if B's finalizer resurrects B?
if (java::lang::ref::Reference::class$.isInstance (obj))
finalize_reference (obj);
+ else if (obj->getClass() == &java::lang::String::class$)
+ _Jv_FinalizeString (obj);
else
_Jv_FinalizeObject (obj);
- list->next = head->next;
- _Jv_Free (head);
}
else if (w != SOFT || _Jv_GCCanReclaimSoftReference (obj))
{
}
void
+_Jv_RegisterStringFinalizer (jobject str)
+{
+ // This function might be called before any other Reference method,
+ // so we must ensure the class is initialized.
+ _Jv_InitClass (&java::lang::ref::Reference::class$);
+ JvSynchronize sync (java::lang::ref::Reference::lock);
+ // If the object is in our hash table, then we might need to add a
+ // new FINALIZE entry. Otherwise, we just register an ordinary
+ // finalizer.
+ object_list *entry = in_hash (str);
+ if (entry)
+ maybe_add_finalize (entry, str);
+ else
+ _Jv_RegisterFinalizer ((void *) str, _Jv_FinalizeString);
+}
+
+void
::java::lang::ref::Reference::create (jobject ref)
{
// Nothing says you can't make a Reference with a NULL referent.
projects / platform / upstream / gcc.git / commitdiff