re PR libgcj/10582 (array assignment fails in some situations)

	PR libgcj/10582:
	* verify.cc (_Jv_BytecodeVerifier::is_assignable_from_slow):
	Removed.
	(type::compatible): Use _Jv_IsAssignableFrom.
	* java/lang/natClass.cc (iindex_mutex_initialized): Now static.
	(_Jv_IsAssignableFrom): Work even when source or target class is
	not prepared.

From-SVN: r66348

3 files changed, 36 insertions, 76 deletions

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 772a2cc..0c95656 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,13 @@
+2003-04-30  Tom Tromey  <tromey@redhat.com>
+
+	PR libgcj/10582:
+	* verify.cc (_Jv_BytecodeVerifier::is_assignable_from_slow):
+	Removed.
+	(type::compatible): Use _Jv_IsAssignableFrom.
+	* java/lang/natClass.cc (iindex_mutex_initialized): Now static.
+	(_Jv_IsAssignableFrom): Work even when source or target class is
+	not prepared.
+
 2003-04-30  Michael Koch  <konqueror@gmx.de>
 
 	* java/text/BreakIterator.java
diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index 417c059..0db8228 100644
--- a/libjava/java/lang/natClass.cc
+++ b/libjava/java/lang/natClass.cc
@@ -981,14 +981,14 @@ _Jv_IsAssignableFrom (jclass target, jclass source)
 {
   if (source == target)
     return true;
-     
+
   // If target is array, so must source be.  
-  if (target->isArray ())
+  while (target->isArray ())
     {
       if (! source->isArray())
 	return false;
-      return _Jv_IsAssignableFrom(target->getComponentType(), 
-                                  source->getComponentType());
+      target = target->getComponentType();
+      source = source->getComponentType();
     }
 
   if (target->isInterface())
@@ -998,7 +998,7 @@ _Jv_IsAssignableFrom (jclass target, jclass source)
       if (__builtin_expect 
           (source->idt == NULL || source->isInterface(), false))
         return _Jv_InterfaceAssignableFrom (target, source);
-	
+
       _Jv_IDispatchTable *cl_idt = source->idt;
       _Jv_IDispatchTable *if_idt = target->idt;
 
@@ -1014,23 +1014,31 @@ _Jv_IsAssignableFrom (jclass target, jclass source)
 	}
       return false;
     }
-     
+
   // Primitive TYPE classes are only assignable to themselves.
-  if (__builtin_expect (target->isPrimitive(), false))
+  if (__builtin_expect (target->isPrimitive() || source->isPrimitive(), false))
     return false;
-    
+
   if (target == &java::lang::Object::class$)
+    return true;
+  else if (source->ancestors == NULL || target->ancestors == NULL)
     {
-      if (source->isPrimitive())
-        return false;
-      return true;
+      // We need this case when either SOURCE or TARGET has not has
+      // its constant-time tables prepared.
+
+      // At this point we know that TARGET can't be Object, so it is
+      // safe to use that as the termination point.
+      while (source && source != &java::lang::Object::class$)
+	{
+	  if (source == target)
+	    return true;
+	  source = source->getSuperclass();
+	}
     }
-  else if (source->ancestors != NULL
-	   && target->ancestors != NULL
-	   && source->depth >= target->depth
+  else if (source->depth >= target->depth
 	   && source->ancestors[source->depth - target->depth] == target)
     return true;
-      
+
   return false;
 }
 
@@ -1373,7 +1381,7 @@ _Jv_AppendPartialITable (jclass klass, jclass iface, void **itable,
 }
 
 static _Jv_Mutex_t iindex_mutex;
-bool iindex_mutex_initialized = false;
+static bool iindex_mutex_initialized = false;
 
 // We need to find the correct offset in the Class Interface Dispatch 
 // Table for a given interface. Once we have that, invoking an interface 
diff --git a/libjava/verify.cc b/libjava/verify.cc
index 4a6ca45..3aacc27 100644
--- a/libjava/verify.cc
+++ b/libjava/verify.cc
@@ -240,64 +240,6 @@ private:
     return get_type_val_for_signature ((jchar) k->method_count);
   }
 
-  // This is like _Jv_IsAssignableFrom, but it works even if SOURCE or
-  // TARGET haven't been prepared.
-  static bool is_assignable_from_slow (jclass target, jclass source)
-  {
-    // This will terminate when SOURCE==Object.
-    while (true)
-      {
-	if (source == target)
-	  return true;
-
-	if (target->isPrimitive () || source->isPrimitive ())
-	  return false;
-
-	if (target->isArray ())
-	  {
-	    if (! source->isArray ())
-	      return false;
-	    target = target->getComponentType ();
-	    source = source->getComponentType ();
-	  }
-	else if (target->isInterface ())
-	  {
-	    for (int i = 0; i < source->interface_count; ++i)
-	      {
-		// We use a recursive call because we also need to
-		// check superinterfaces.
-		if (is_assignable_from_slow (target, source->interfaces[i]))
-		    return true;
-	      }
-	    source = source->getSuperclass ();
-	    if (source == NULL)
-	      return false;
-	  }
-	// We must do this check before we check to see if SOURCE is
-	// an interface.  This way we know that any interface is
-	// assignable to an Object.
-	else if (target == &java::lang::Object::class$)
-	  return true;
-	else if (source->isInterface ())
-	  {
-	    for (int i = 0; i < target->interface_count; ++i)
-	      {
-		// We use a recursive call because we also need to
-		// check superinterfaces.
-		if (is_assignable_from_slow (target->interfaces[i], source))
-		  return true;
-	      }
-	    target = target->getSuperclass ();
-	    if (target == NULL)
-	      return false;
-	  }
-	else if (source == &java::lang::Object::class$)
-	  return false;
-	else
-	  source = source->getSuperclass ();
-      }
-  }
-
   // This is used to keep track of which `jsr's correspond to a given
   // jsr target.
   struct subr_info
@@ -520,7 +462,7 @@ private:
       // We must resolve both types and check assignability.
       resolve (verifier);
       k.resolve (verifier);
-      return is_assignable_from_slow (data.klass, k.data.klass);
+      return _Jv_IsAssignableFrom (data.klass, k.data.klass);
     }
 
     bool isvoid () const
@@ -707,7 +649,7 @@ private:
 		  // Ordinarily this terminates when we hit Object...
 		  while (k != NULL)
 		    {
-		      if (is_assignable_from_slow (k, oldk))
+		      if (_Jv_IsAssignableFrom (k, oldk))
 			break;
 		      k = k->getSuperclass ();
 		      changed = true;