From 268d48e0dad6d09bd87ea0699fc4c0465efda604 Mon Sep 17 00:00:00 2001
From: tromey <tromey@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Thu, 1 May 2003 21:36:18 +0000
Subject: [PATCH] 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.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@66348 138bc75d-0d04-0410-961f-82ee72b054a4
---
libjava/ChangeLog | 10 ++++++
libjava/java/lang/natClass.cc | 40 +++++++++++++---------
libjava/verify.cc | 62 ++---------------------------------
3 files changed, 36 insertions(+), 76 deletions(-)
diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 772a2cc0a3aa..0c956560c1ea 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 417c059ed599..0db8228d63bb 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 4a6ca4588496..3aacc273ae25 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;
--
GitLab