GC stress fixes and other bugfixes; classpath progress

classpath/java/io/BufferedReader.java

@@ -11,7 +11,7 @@ public class BufferedReader extends Reader {
     this.buffer = new char[bufferSize];
   }
 
-  protected BufferedReader(Reader in) {
+  public BufferedReader(Reader in) {
     this(in, 32);
   }
   

classpath/java/io/LineNumberReader.java

@@ -7,7 +7,7 @@ public class LineNumberReader extends BufferedReader {
     super(in, bufferSize);
   }
 
-  protected LineNumberReader(Reader in) {
+  public LineNumberReader(Reader in) {
     super(in);
   }
 

classpath/java/io/PrintStream.java

@@ -9,7 +9,7 @@ public class PrintStream extends OutputStream {
 
   public PrintStream(OutputStream out, boolean autoFlush) {
     this.out = out;
-    this.autoFlush = true;
+    this.autoFlush = autoFlush;
   }
 
   public PrintStream(OutputStream out) {
@@ -29,6 +29,13 @@ public class PrintStream extends OutputStream {
       if (autoFlush) flush();
     } catch (IOException e) { }
   }
+
+  public synchronized void println() {
+    try {
+      out.write(newline);
+      if (autoFlush) flush();
+    } catch (IOException e) { }
+  }
   
   public void write(int c) throws IOException {
     out.write(c);

classpath/java/io/PrintWriter.java

@@ -9,13 +9,21 @@ public class PrintWriter extends Writer {
 
   public PrintWriter(Writer out, boolean autoFlush) {
     this.out = out;
-    this.autoFlush = true;
+    this.autoFlush = autoFlush;
   }
 
   public PrintWriter(Writer out) {
     this(out, false);
   }
 
+  public PrintWriter(OutputStream out, boolean autoFlush) {
+    this(new OutputStreamWriter(out), autoFlush);
+  }
+
+  public PrintWriter(OutputStream out) {
+    this(out, false);
+  }
+
   public synchronized void print(String s) {
     try {
       out.write(s.toCharArray());
@@ -30,6 +38,13 @@ public class PrintWriter extends Writer {
     } catch (IOException e) { }
   }
 
+  public synchronized void println() {
+    try {
+      out.write(newline);
+      if (autoFlush) flush();
+    } catch (IOException e) { }
+  }
+
   public void write(char[] buffer, int offset, int length) throws IOException {
     out.write(buffer, offset, length);
     if (autoFlush) flush();

classpath/java/lang/Boolean.java

@@ -3,12 +3,31 @@ package java.lang;
 public final class Boolean {
   public static final Class TYPE = Class.forCanonicalName("Z");
 
+  public static final Boolean FALSE = new Boolean(false);
+  public static final Boolean TRUE = new Boolean(true);
+
   private final boolean value;
 
   public Boolean(boolean value) {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Boolean && ((Boolean) o).value == value;
+  }
+
+  public int hashCode() {
+    return (value ? 1 : 0);
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(boolean v) {
+    return (v ? "true" : "false");
+  }
+
   public boolean booleanValue() {
     return value;
   }

classpath/java/lang/Byte.java

@@ -9,6 +9,26 @@ public final class Byte extends Number {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Byte && ((Byte) o).value == value;
+  }
+
+  public int hashCode() {
+    return value;
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(byte v, int radix) {
+    return Long.toString(v, radix);
+  }
+
+  public static String toString(byte v) {
+    return toString(v, 10);
+  }
+
   public byte byteValue() {
     return value;
   }

classpath/java/lang/Character.java

@@ -9,6 +9,22 @@ public final class Character {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Character && ((Character) o).value == value;
+  }
+
+  public int hashCode() {
+    return (int) value;
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(char v) {
+    return new String(new char[] { v });
+  }
+
   public char charValue() {
     return value;
   }

classpath/java/lang/Class.java

@@ -38,7 +38,7 @@ public final class Class <T> {
       } else if (name.startsWith("L")) {
         return forName(name.substring(1, name.length() - 1));
       } else {
-        if (name.length() == 0) {
+        if (name.length() == 1) {
           return primitiveClass(name.charAt(0));
         } else {
           throw new ClassNotFoundException(name);

classpath/java/lang/Cloneable.java

@@ -0,0 +1,3 @@
+package java.lang;
+
+public interface Cloneable { }

classpath/java/lang/Double.java

@@ -1,14 +1,35 @@
 package java.lang;
 
-public final class Double {
+public final class Double extends Number {
   public static final Class TYPE = Class.forCanonicalName("D");
 
   private final double value;
 
+  public Double(String value) {
+    this.value = parseDouble(value);
+  }
+
   public Double(double value) {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Double && ((Double) o).value == value;
+  }
+
+  public int hashCode() {
+    long v = doubleToRawLongBits(value);
+    return (int) ((v >> 32) ^ (v & 0xFF));
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(double v) {
+    return "todo";
+  }
+
   public byte byteValue() {
     return (byte) value;
   }
@@ -32,4 +53,14 @@ public final class Double {
   public double doubleValue() {
     return value;
   }
+
+  public static double parseDouble(String s) {
+    // todo
+    return 0.0;
+  }
+
+  public static long doubleToRawLongBits(double value) {
+    // todo
+    return 0;
+  }
 }

classpath/java/lang/Float.java

@@ -9,6 +9,22 @@ public final class Float extends Number {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Float && ((Float) o).value == value;
+  }
+
+  public int hashCode() {
+    return floatToRawIntBits(value);
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(float v) {
+    return "todo";
+  }
+
   public byte byteValue() {
     return (byte) value;
   }
@@ -32,4 +48,9 @@ public final class Float extends Number {
   public double doubleValue() {
     return (double) value;
   }
+
+  public static int floatToRawIntBits(float value) {
+    // todo
+    return 0;
+  }
 }

classpath/java/lang/Integer.java

@@ -3,12 +3,35 @@ package java.lang;
 public final class Integer extends Number {
   public static final Class TYPE = Class.forCanonicalName("I");
 
+  public static final int MIN_VALUE = 0x80000000;
+  public static final int MAX_VALUE = 0x7FFFFFFF;
+
   private final int value;
 
   public Integer(int value) {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Integer && ((Integer) o).value == value;
+  }
+
+  public int hashCode() {
+    return value;
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(int v, int radix) {
+    return Long.toString(v, radix);
+  }
+
+  public static String toString(int v) {
+    return toString(v, 10);
+  }
+
   public byte byteValue() {
     return (byte) value;
   }

classpath/java/lang/Long.java

@@ -9,6 +9,54 @@ public final class Long extends Number {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Long && ((Long) o).value == value;
+  }
+
+  public int hashCode() {
+    return (int) ((value >> 32) ^ (value & 0xFF));
+  }
+
+  public String toString() {
+    return String.valueOf(value);
+  }
+
+  public static String toString(long v, int radix) {
+    if (radix < 1 || radix > 36) {
+      throw new IllegalArgumentException("radix " + radix + " not in [1,36]");
+    }
+
+    if (v == 0) {
+      return "0";
+    }
+
+    int size = (v < 0 ? 1 : 0);
+    for (long n = v; n > 0; n /= radix) ++size;
+
+    char[] array = new char[size];
+
+    int i = array.length - 1;
+    for (long n = v; n > 0; n /= radix) {
+      long digit = n % radix;
+      if (digit >= 0 && digit <= 9) {
+        array[i] = (char) ('0' + digit);
+      } else {
+        array[i] = (char) ('a' + (digit - 10));
+      }
+      --i;
+    }
+
+    if (v < 0) {
+      array[i] = '-';
+    }
+
+    return new String(array);
+  }
+
+  public static String toString(long v) {
+    return toString(v, 10);
+  }
+
   public byte byteValue() {
     return (byte) value;
   }
@@ -49,7 +97,7 @@ public final class Long extends Number {
 	long digit = ((c >= '0' && c <= '9') ? (c - '0') : (c - 'a' + 10));
 	number += digit * pow(radix, (s.length() - i - 1));
       } else {
-	throw new NumberFormatException("Invalid character " + c + " code " +
+	throw new NumberFormatException("invalid character " + c + " code " +
 					(int) c);
       }
     }

classpath/java/lang/Math.java

@@ -0,0 +1,77 @@
+package java.lang;
+
+public final class Math {
+  private Math() { }
+
+  public static int abs(int v) {
+    return (v < 0 ? -v : v);
+  }
+
+  public static long round(double v) {
+    return (long) (v + 0.5);
+  }
+
+  public static int round(float v) {
+    return (int) (v + 0.5);
+  }
+
+  public static double floor(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double ceil(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double exp(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double log(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double cos(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double sin(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double tan(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double acos(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double asin(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double atan(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double sqrt(double v) {
+    // todo
+    return 0;
+  }
+
+  public static double pow(double v, double e) {
+    // todo
+    return 0;
+  }
+}

classpath/java/lang/Short.java

@@ -9,6 +9,26 @@ public final class Short extends Number {
     this.value = value;
   }
 
+  public boolean equals(Object o) {
+    return o instanceof Short && ((Short) o).value == value;
+  }
+
+  public int hashCode() {
+    return value;
+  }
+
+  public String toString() {
+    return toString(value);
+  }
+
+  public static String toString(short v, int radix) {
+    return Long.toString(v, radix);
+  }
+
+  public static String toString(short v) {
+    return toString(v, 10);
+  }
+
   public byte byteValue() {
     return (byte) value;
   }

classpath/java/lang/String.java

@@ -14,6 +14,10 @@ public final class String implements Comparable<String> {
     this(data, offset, length, true);
   }
 
+  public String(char[] data) {
+    this(data, 0, data.length);
+  }
+
   public String(byte[] data, int offset, int length, boolean copy) {
     this((Object) data, offset, length, copy);
   }
@@ -22,6 +26,10 @@ public final class String implements Comparable<String> {
     this(data, offset, length, true);
   }
 
+  public String(byte[] data) {
+    this(data, 0, data.length);
+  }
+
   private String(Object data, int offset, int length, boolean copy) {
     if (copy) {
       Object c;
@@ -41,6 +49,10 @@ public final class String implements Comparable<String> {
     }
   }
 
+  public String toString() {
+    return this;
+  }
+
   public int length() {
     return length;
   }
@@ -91,6 +103,26 @@ public final class String implements Comparable<String> {
     }
   }
 
+  public int indexOf(char c) {
+    for (int i = 0; i < length - 1; ++i) {
+      if (charAt(i) == c) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  public int lastIndexOf(char c) {
+    for (int i = length - 1; i >= 0; --i) {
+      if (charAt(i) == c) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
   public int indexOf(String s) {
     if (s.length == 0) return 0;
 
@@ -232,29 +264,35 @@ public final class String implements Comparable<String> {
 
   public native String intern();
 
+  public static String valueOf(boolean v) {
+    return Boolean.toString(v);
+  }
+
+  public static String valueOf(byte v) {
+    return Byte.toString(v);
+  }
+
+  public static String valueOf(short v) {
+    return Short.toString(v);
+  }
+
+  public static String valueOf(char v) {
+    return Character.toString(v);
+  }
+
   public static String valueOf(int v) {
-    return valueOf((long) v);
+    return Integer.toString(v);
   }
 
   public static String valueOf(long v) {
-    if (v == 0) {
-      return valueOf('0');
-    } else {
-      final int Max = 21;
-      char[] array = new char[Max];
-      int index = Max;
-      long x = (v >= 0 ? v : -v);
+    return Long.toString(v);
+  }
 
-      while (x != 0) {
-        array[--index] = (char) ('0' + (x % 10));
-        x /= 10;
-      }
+  public static String valueOf(float v) {
+    return Float.toString(v);
+  }
 
-      if (v < 0) {
-        array[--index] = '-';
-      }
-
-      return new String(array, index, Max - index, false);
-    }
+  public static String valueOf(double v) {
+    return Double.toString(v);
   }
 }

classpath/java/lang/StringBuffer.java

@@ -1,7 +1,15 @@
 package java.lang;
 
 public class StringBuffer {
-  private final StringBuilder sb = new StringBuilder();
+  private final StringBuilder sb;
+
+  public StringBuffer(int capacity) {
+    sb = new StringBuilder(capacity);
+  }
+
+  public StringBuffer() {
+    this(0);
+  }
 
   public synchronized StringBuffer append(String s) {
     sb.append(s);

classpath/java/lang/StringBuilder.java

@@ -4,6 +4,12 @@ public class StringBuilder {
   private Cell chain;
   private int length;
 
+  public StringBuilder(int capacity) { }
+
+  public StringBuilder() {
+    this(0);
+  }
+
   public StringBuilder append(String s) {
     if (s.length() > 0) {
       chain = new Cell(s, chain);

classpath/java/net/URL.java

@@ -1,5 +1,9 @@
 package java.net;
 
 public class URL {
+  private final String value;
 
+  public URL(String s) throws MalformedURLException {
+    value = s;
+  }
 }

classpath/java/util/HashSet.java

@@ -5,6 +5,11 @@ public class HashSet<T> implements Set<T> {
 
   private final HashMap<T, Object> map;
 
+  public HashSet(Collection<T> c) {
+    map = new HashMap(c.size());
+    addAll(c);
+  }
+
   public HashSet(int capacity) {
     map = new HashMap(capacity);
   }
@@ -21,6 +26,10 @@ public class HashSet<T> implements Set<T> {
     return map.containsKey(element);
   }
 
+  public void addAll(Collection<T> c) {
+    for (T t: c) add(t);
+  }
+
   public boolean add(T element) {
     return map.put(element, Value) != Value;
   }

classpath/java/util/LinkedList.java

@@ -5,6 +5,12 @@ public class LinkedList<T> implements List<T> {
   private Cell<T> rear;
   private int size;
 
+  public LinkedList(Collection<T> c) {
+    addAll(c);
+  }
+
+  public LinkedList() { }
+
   private Cell<T> find(int index) {
     int i = 0;
     for (Cell<T> c = front; c != null; c = c.next) {
@@ -75,6 +81,10 @@ public class LinkedList<T> implements List<T> {
     return find(element) != null;
   }
 
+  public void addAll(Collection<T> c) {
+    for (T t: c) add(t);
+  }
+
   public boolean add(T element) {
     addFirst(element);
     return true;

src/builtin.cpp

@@ -101,12 +101,14 @@ Class_primitiveClass(Thread* t, jclass, jchar name)
     return pushReference(t, arrayBody(t, t->vm->types, Machine::JfloatType));
   case 'I':
     return pushReference(t, arrayBody(t, t->vm->types, Machine::JintType));
-  case 'L':
+  case 'J':
     return pushReference(t, arrayBody(t, t->vm->types, Machine::JlongType));
   case 'S':
     return pushReference(t, arrayBody(t, t->vm->types, Machine::JshortType));
   case 'V':
     return pushReference(t, arrayBody(t, t->vm->types, Machine::JvoidType));
+  case 'Z':
+    return pushReference(t, arrayBody(t, t->vm->types, Machine::JbooleanType));
   default:
     t->exception = makeIllegalArgumentException(t);
     return 0;
@@ -644,6 +646,8 @@ populateBuiltinMap(Thread* t, object map)
       reinterpret_cast<void*>(::Class_forName) },
     { "Java_java_lang_Class_isAssignableFrom",
       reinterpret_cast<void*>(::Class_isAssignableFrom) },
+    { "Java_java_lang_Class_primitiveClass",
+      reinterpret_cast<void*>(::Class_primitiveClass) },
 
     { "Java_java_lang_System_arraycopy",
       reinterpret_cast<void*>(::System_arraycopy) },

src/heap.cpp

@@ -18,7 +18,7 @@ const unsigned MinimumGen2SizeInBytes = 128 * 1024;
 const unsigned Top = ~static_cast<unsigned>(0);
 
 const bool Verbose = true;
-const bool Debug = true;
+const bool Debug = false;
 
 class Context;
 
@@ -1438,6 +1438,7 @@ class MyHeap: public Heap {
     } else if (c.nextGen2.contains(p)
                or (c.gen2.contains(p)
                    and (c.mode == ::MinorCollection
+                        or c.mode == ::OverflowCollection
                         or c.gen2.indexOf(p) >= c.gen2Base)))
     {
       return Tenured;

src/machine.cpp

@@ -136,11 +136,24 @@ visitRoots(Thread* t, Heap::Visitor* v)
   }
 }
 
+void
+finalizerTargetUnreachable(Thread* t, object* p, Heap::Visitor* v)
+{
+  v->visit(&finalizerTarget(t, *p));
+
+  object finalizer = *p;
+  *p = finalizerNext(t, finalizer);
+  finalizerNext(t, finalizer) = t->vm->finalizeQueue;
+  t->vm->finalizeQueue = finalizer;
+}
+
 void
 referenceTargetUnreachable(Thread* t, object* p, Heap::Visitor* v)
 {
-//   fprintf(stderr, "target %p unreachable for reference %p\n",
-//           jreferenceTarget(t, *p), *p);
+  if (DebugReferences) {
+    fprintf(stderr, "target %p unreachable for reference %p\n",
+            jreferenceTarget(t, *p), *p);
+  }
 
   v->visit(p);
   jreferenceTarget(t, *p) = 0;
@@ -164,27 +177,35 @@ referenceTargetUnreachable(Thread* t, object* p, Heap::Visitor* v)
 
     jreferenceQueue(t, *p) = 0;
   }
+
+  *p = jreferenceNext(t, *p);
 }
 
 void
 referenceUnreachable(Thread* t, object* p, Heap::Visitor* v)
 {
-//   fprintf(stderr, "reference %p unreachable\n",
-//           *p);
+  if (DebugReferences) {
+    fprintf(stderr, "reference %p unreachable (target %p)\n",
+            *p, jreferenceTarget(t, *p));
+  }
 
   if (jreferenceQueue(t, *p)
       and t->vm->heap->status(jreferenceQueue(t, *p)) != Heap::Unreachable)
   {
     // queue is reachable - add the reference
     referenceTargetUnreachable(t, p, v);    
+  } else {
+    *p = jreferenceNext(t, *p);
   }
 }
 
 void
 referenceTargetReachable(Thread* t, object* p, Heap::Visitor* v)
 {
-//   fprintf(stderr, "target %p reachable for reference %p\n",
-//           jreferenceTarget(t, *p), *p);
+  if (DebugReferences) {
+    fprintf(stderr, "target %p reachable for reference %p\n",
+            jreferenceTarget(t, *p), *p);
+  }
 
   v->visit(p);
   v->visit(&jreferenceTarget(t, *p));
@@ -201,6 +222,16 @@ postVisit(Thread* t, Heap::Visitor* v)
 {
   Machine* m = t->vm;
 
+  for (object* p = &(m->finalizeQueue); *p; p = &(finalizerNext(t, *p))) {
+    v->visit(p);
+    v->visit(&finalizerTarget(t, *p));
+  }
+
+  for (object* p = &(m->finalizeQueue); *p; p = &(finalizerNext(t, *p))) {
+    v->visit(p);
+    v->visit(&finalizerTarget(t, *p));
+  }
+
   object firstNewTenuredFinalizer = 0;
   object lastNewTenuredFinalizer = 0;
 
@@ -209,16 +240,9 @@ postVisit(Thread* t, Heap::Visitor* v)
 
     if (m->heap->status(finalizerTarget(t, *p)) == Heap::Unreachable) {
       // target is unreachable - queue it up for finalization
-
-      v->visit(&finalizerTarget(t, *p));
-
-      object finalizer = *p;
-      *p = finalizerNext(t, finalizer);
-      finalizerNext(t, finalizer) = m->finalizeQueue;
-      m->finalizeQueue = finalizer;
+      finalizerTargetUnreachable(t, p, v);
     } else {
       // target is reachable
-
       v->visit(&finalizerTarget(t, *p));
 
       if (m->heap->status(*p) == Heap::Tenured) {
@@ -245,17 +269,12 @@ postVisit(Thread* t, Heap::Visitor* v)
   for (object* p = &(m->weakReferences); *p;) {
     if (m->heap->status(*p) == Heap::Unreachable) {
       // reference is unreachable
-
       referenceUnreachable(t, p, v);
-      *p = jreferenceNext(t, *p);
     } else if (m->heap->status(jreferenceTarget(t, *p)) == Heap::Unreachable) {
       // target is unreachable
-
       referenceTargetUnreachable(t, p, v);
-      *p = jreferenceNext(t, *p);
     } else {
       // both reference and target are reachable
-
       referenceTargetReachable(t, p, v);
 
       if (m->heap->status(*p) == Heap::Tenured) {
@@ -283,18 +302,10 @@ postVisit(Thread* t, Heap::Visitor* v)
 
       if (m->heap->status(finalizerTarget(t, *p)) == Heap::Unreachable) {
         // target is unreachable - queue it up for finalization
-
-        v->visit(&finalizerTarget(t, *p));
-
-        object finalizer = *p;
-        *p = finalizerNext(t, finalizer);
-        finalizerNext(t, finalizer) = m->finalizeQueue;
-        m->finalizeQueue = finalizer;
+        finalizerTargetUnreachable(t, p, v);
       } else {
         // target is reachable
-
         v->visit(&finalizerTarget(t, *p));
-
         p = &finalizerNext(t, *p);
       }
     }
@@ -302,19 +313,14 @@ postVisit(Thread* t, Heap::Visitor* v)
     for (object* p = &(m->tenuredWeakReferences); *p;) {
       if (m->heap->status(*p) == Heap::Unreachable) {
         // reference is unreachable
-
         referenceUnreachable(t, p, v);
-        *p = jreferenceNext(t, *p);
       } else if (m->heap->status(jreferenceTarget(t, *p))
                  == Heap::Unreachable)
       {
         // target is unreachable
-
         referenceTargetUnreachable(t, p, v);
-        *p = jreferenceNext(t, *p);
       } else {
         // both reference and target are reachable
-
         referenceTargetReachable(t, p, v);
         p = &jreferenceNext(t, *p);
       }
@@ -771,7 +777,9 @@ parseFieldTable(Thread* t, Stream& s, object class_, object pool)
       if (fieldTable) {
         for (int i = arrayLength(t, fieldTable) - 1; i >= 0; --i) {
           object field = arrayBody(t, fieldTable, i);
-          if (fieldCode(t, field) == ObjectField) {
+          if ((fieldFlags(t, field) & ACC_STATIC) == 0
+              and fieldCode(t, field) == ObjectField)
+          {
             unsigned index = fieldOffset(t, field) / BytesPerWord;
             intArrayBody(t, mask, (index / 32)) |= 1 << (index % 32);
             sawReferenceField = true;

src/machine.h

@@ -23,6 +23,7 @@ const bool Verbose = false;
 const bool DebugRun = false;
 const bool DebugStack = false;
 const bool DebugMonitors = false;
+const bool DebugReferences = false;
 
 const uintptr_t HashTakenMark = 1;
 const uintptr_t ExtendedMark = 2;

src/run.cpp

@@ -2118,17 +2118,13 @@ run(Thread* t)
         {
           object catchType = 0;
           if (exceptionHandlerCatchType(eh)) {
-            catchType = arrayBody
-              (t, codePool(t, code), exceptionHandlerCatchType(eh) - 1);
-          }
-
-          if (catchType) {
             object e = exception;
             exception = 0;
             PROTECT(t, e);
 
             PROTECT(t, eht);
-            catchType = resolveClass(t, catchType);
+            catchType = resolveClass
+              (t, codePool(t, code), exceptionHandlerCatchType(eh) - 1);
 
             if (catchType) {
               eh = exceptionHandlerTableBody(t, eht, i);

src/types.def

@@ -178,7 +178,7 @@
   (extends runtimeException))
 
 (type classNotFoundException java/lang/ClassNotFoundException
-  (extends runtimeException))
+  (extends exception))
 
 (type invocationTargetException java/lang/InvocationTargetException
   (extends exception))
@@ -204,8 +204,11 @@
 (type unsatisfiedLinkError java/lang/UnsatisfiedLinkError
   (extends linkageError))
 
+(type number java/lang/Number
+  (extends jobject))
+
 (type byte java/lang/Byte
-  (extends jobject)
+  (extends number)
   (int8_t value))
 
 (type boolean java/lang/Boolean
@@ -213,7 +216,7 @@
   (uint8_t value))
 
 (type short java/lang/Short
-  (extends jobject)
+  (extends number)
   (int16_t value))
 
 (type char java/lang/Character
@@ -221,19 +224,19 @@
   (uint16_t value))
 
 (type int java/lang/Integer
-  (extends jobject)
+  (extends number)
   (int32_t value))
 
 (type long java/lang/Long
-  (extends jobject)
+  (extends number)
   (int64_t value))
 
 (type float java/lang/Float
-  (extends jobject)
+  (extends number)
   (uint32_t value))
 
 (type double java/lang/Double
-  (extends jobject)
+  (extends number)
   (uint64_t value))
 
 (type referenceQueue java/lang/ref/ReferenceQueue