This is the mail archive of the java-patches@gcc.gnu.org mailing list for the Java project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Patch: FYI: PR 10596 fix


I'm checking this in on the trunk.

This fixes the Reference code to interact correctly with String.intern().

Tom

Index: ChangeLog
from  Tom Tromey  <tromey@redhat.com>

	PR libgcj/10596:
	* include/jvm.h (_Jv_FinalizeString,
	_Jv_RegisterStringFinalizer): Declare.
	* java/lang/natString.cc (_Jv_FinalizeString): Renamed from
	unintern.
	(intern): Updated.
	(_Jv_NewStringUtf8Const): Likewise.
	* java/lang/ref/natReference.cc (finalize_referred_to_object):
	Add special case when finalizing a String.
	(in_hash): New function.
	(_Jv_RegisterStringFinalizer): Likewise.
	(maybe_add_finalize): Likewise.

Index: include/jvm.h
===================================================================
RCS file: /cvs/gcc/gcc/libjava/include/jvm.h,v
retrieving revision 1.59
diff -u -r1.59 jvm.h
--- include/jvm.h 28 Aug 2003 22:17:36 -0000 1.59
+++ include/jvm.h 29 Sep 2003 21:09:45 -0000
@@ -290,6 +290,12 @@
    implement soft references.  */
 jboolean _Jv_GCCanReclaimSoftReference (jobject obj);
 
+/* Register a finalizer for a String object.  This is only used by
+   the intern() implementation.  */
+void _Jv_RegisterStringFinalizer (jobject str);
+/* This is called to actually finalize a possibly-intern()d String.  */
+void _Jv_FinalizeString (jobject str);
+
 /* Return approximation of total size of heap.  */
 long _Jv_GCTotalMemory (void);
 /* Return approximation of total free memory.  */
Index: java/lang/natString.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/natString.cc,v
retrieving revision 1.31
diff -u -r1.31 natString.cc
--- java/lang/natString.cc 28 Jul 2003 16:12:00 -0000 1.31
+++ java/lang/natString.cc 29 Sep 2003 21:09:47 -0000
@@ -31,7 +31,6 @@
 #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.
@@ -173,28 +172,38 @@
   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
@@ -202,21 +211,21 @@
   // 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
     {
@@ -292,8 +301,10 @@
   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;
 }
 
Index: java/lang/ref/natReference.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/ref/natReference.cc,v
retrieving revision 1.5
diff -u -r1.5 natReference.cc
--- java/lang/ref/natReference.cc 21 Aug 2003 22:08:09 -0000 1.5
+++ java/lang/ref/natReference.cc 29 Sep 2003 21:09:47 -0000
@@ -159,6 +159,19 @@
     }
 }
 
+// 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!
@@ -212,6 +225,29 @@
   *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
@@ -236,16 +272,21 @@
   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))
     {
@@ -284,6 +325,23 @@
   remove_from_hash (ref);
   // The user might have a subclass of Reference with a finalizer.
   _Jv_FinalizeObject (ref);
+}
+
+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


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]