Name: dkC59003 Date: 10/24/99


HotSpot doesn't enforce loading constraint imposed by preparation
as determined by the current specs, that differs from the behavior of the classic VM.

Let's consider the example. There are two classes A and B, where B
extends A, and there is overriden method m with parameter of type C in A and B.
Loading (and defining) class A by class loader La (<La,A>) and its subclass B
by class loader Lb (<Lb,B>) imposes loading constraint in the form C,La=C,Lb.
Loading class C by different class loaders La and Lb violates this constraint
and LinkError should be thrown.

This example is derived from JCK test
vm/constantpool/loadingConstraints/loadingConstraints00301 to be integrated in
JCK-kestrel. In this test class "Ancestor" corresponds to A, "Descendant" corresponds to B
and "TheClass" corresponds to C.

When we run this example on HotSpot no exception is thrown, though classic VM correctly
throws LinkError.

This behaviour contradicts specification, that says:

"5.4.2 Preparation

During preparation of a class or interface C, the Java virtual machine also
imposes loading constraints (5.3.4). Let L1 be the defining loader of C.
For each method m declared in C that overrides a method declared in a
superclass or superinterface <D, L2>, the Java virtual machine imposes the
following loading constraints: Let T0 be the name of the type returned by m,
and let T1, ..., Tn be the names of the argument types of m. Then Ti,L1=Ti,L2
for i = 0 to n (5.3.4)."

"5.3.4 Loading Constraints
...
Java virtual machine imposes loading constraints of the form N,L1 = N,L2
during preparation (5.4.2) and resolution (5.4.3).
...
A loading constraint is violated if, and only if, all the following four
conditions hold:

- There exists a loader L such that L has been recorded by the Java virtual
machine as an initiating loader of a class C named N.

- There exists a loader L' such that L' has been recorded by the Java virtual
machine as an initiating loader of a class C' named N.

- The equivalence relation defined by the (transitive closure of the) set of
imposed constraints implies N,L = N,L'.

- C != C'."


See reduced JCK test source and logs below:

---------------------------------------------------------------- Ancestor.java
public class Ancestor {
  public void f(TheClass a) {}
}
-------------------------------------------------------------- Descendant.java
public class Descendant extends Ancestor {
  public void f(TheClass a) {}
}
---------------------------------------------------------------- TheClass.java
public class TheClass {}
-------------------------------------------------------------- TestLoader.java
import java.io.*;

public class TestLoader extends ClassLoader {
  ClassLoader nextLoader;
  String key[];

  public TestLoader(ClassLoader c, String k[]) {
super(c);
nextLoader = c;
key = k;
  }

  public synchronized Class loadClass(String name) throws ClassNotFoundException {
Class c = findLoadedClass(name);
if(c != null)
{
return c;
}

for(int i=0; i<key.length; i++) {
if(name.indexOf(key[i]) != -1) {
return getClass(name);
}
}
return Class.forName(name, true, nextLoader);
  }

  private Class getClass(String name) throws ClassNotFoundException {

String cname = name.replace('.', '/') + ".class";
InputStream in = getResourceAsStream(cname);
if (in == null) {
       throw new ClassNotFoundException(name);
}

int len = 0;
byte data[];
try {
int size = 1000;
data = new byte[size];

for(int i=0;;) {
i = in.read(data, len, size-len);
if(i == -1)
break;
len += i;
if(len == size) {
byte buf[] = new byte[size*2];
System.arraycopy(data, 0, buf, 0, size);
size *= 2;
data = buf;
}
}
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
} finally {
try {
in.close();
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
}
return defineClass(name, data, 0, len);
  }
}
----------------------------------------------------------------- Test.java
import java.lang.reflect.*;

public class Test {

  public static void main(String args[]) {
String sa[] = {"Descendant", "TheClass" };
String sb[] = {"Ancestor", "TheClass" };

TestLoader cb = new TestLoader(Test.class.getClassLoader(), sb);
TestLoader ca = new TestLoader(cb, sa);

try {
Class.forName("Descendant", true, ca);
ca.loadClass("TheClass");
cb.loadClass("TheClass");
} catch (LinkageError e) {
System.out.println("OK: LinkageError is thrown");
return;
} catch (ClassNotFoundException e) {
System.out.println("Unexpected exception " + e);
return;
}
System.out.println("ERROR: No exception is thrown");
  }
}
-------------------------------------------------------------------------------

> $JDK/bin/javac Ancestor.java Descendant.java TheClass.java TestLoader.java Test.java
> $JDK/bin/java -classic Test

OK: LinkageError is thrown

> $JDK/bin/java Test

ERROR: No exception is thrown

> uname -a

SunOS novo12 5.7 Generic_Patch sun4u sparc SUNW,Ultra-2

> $JDK/bin/java -version

java version "1.3.0"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.0-J)
Java HotSpot (TM) Client VM (build 1.3-J, interpreted mode)

> $JDK/bin/java -classic -version

java version "1.3.0"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.0-J)
Classic VM (build 1.3.0-J, green threads, nojit)

======================================================================


======================================================================