heap o' bugfixes

classpath/TestThreads.java

@@ -20,15 +20,15 @@ public class TestThreads implements Runnable {
     synchronized (this) {
       int i = 0;
       try {
-        System.out.println("I'm running in a seperate thread!");
+        System.out.println("I'm running in a separate thread!");
 
-        final int arrayCount = 8;
-        final int arraySize = 4;
-        System.out.println("Allocating and discarding " + arrayCount +
-                           " arrays of " + arraySize + "MB each");
-        for (; i < arrayCount; ++i) {
-          byte[] array = new byte[arraySize * 1024 * 1024];
-        }
+//         final int arrayCount = 8;
+//         final int arraySize = 4;
+//         System.out.println("Allocating and discarding " + arrayCount +
+//                            " arrays of " + arraySize + "MB each");
+//         for (; i < arrayCount; ++i) {
+//           byte[] array = new byte[arraySize * 1024 * 1024];
+//         }
 
         long nap = 5;
         System.out.println("sleeping for " + nap + " seconds");

classpath/java/lang/StringBuilder.java

@@ -27,7 +27,7 @@ public class StringBuilder {
       index -= c.value.length();
       c.value.getChars(0, c.value.length(), array, index);
     }
-    return new String(array, 0, array.length, false);
+    return new String(array, 0, length, false);
   }
 
   private static class Cell {

makefile

@@ -29,7 +29,7 @@ thread-cflags = -pthread
 thread-lflags = -lpthread
 
 cflags = $(warnings) -fPIC -fno-rtti -fno-exceptions -fvisibility=hidden \
-	-I$(src) -I$(bld) $(thread-cflags)
+	-I$(src) -I$(bld) $(thread-cflags) -D__STDC_LIMIT_MACROS
 lflags = $(thread-lflags) -ldl
 test-cflags = -DDEBUG_MEMORY
 stress-cflags = -DDEBUG_MEMORY -DDEBUG_MEMORY_MAJOR

src/builtin.cpp

@@ -34,6 +34,16 @@ notifyAll(Thread* t, jobject this_)
   vm::notifyAll(t, *this_);
 }
 
+void
+sleep(Thread* t, jlong milliseconds)
+{
+  if (milliseconds == 0) milliseconds = INT64_MAX;
+
+  ENTER(t, Thread::IdleState);
+
+  t->vm->system->sleep(milliseconds);
+}
+
 void
 loadLibrary(Thread* t, jstring nameString)
 {
@@ -68,7 +78,7 @@ arraycopy(Thread* t, jobject src, jint srcOffset, jobject dst, jint dstOffset,
       unsigned elementSize = classArrayElementSize(t, objectClass(t, s));
 
       if (LIKELY(elementSize)) {
-        unsigned offset = 0;
+        unsigned offset = 1;
 
         if (objectClass(t, s)
             == arrayBody(t, t->vm->types, Machine::ObjectArrayType))
@@ -76,7 +86,7 @@ arraycopy(Thread* t, jobject src, jint srcOffset, jobject dst, jint dstOffset,
           if (LIKELY(objectArrayElementClass(t, s)
                      == objectArrayElementClass(t, d)))
           {
-            offset = 1;
+            offset = 2;
           } else {
             t->exception = makeArrayStoreException(t);
             return;
@@ -86,12 +96,12 @@ arraycopy(Thread* t, jobject src, jint srcOffset, jobject dst, jint dstOffset,
         intptr_t sl = cast<uintptr_t>(s, offset * BytesPerWord);
         intptr_t dl = cast<uintptr_t>(d, offset * BytesPerWord);
         if (LIKELY(srcOffset >= 0 and srcOffset + length <= sl and
-                   dstOffset >= 0 and dstOffset + length < dl))
+                   dstOffset >= 0 and dstOffset + length <= dl))
         {
-          uint8_t* sbody = &cast<uint8_t>(s, (offset * BytesPerWord) + 4);
-          uint8_t* dbody = &cast<uint8_t>(s, (offset * BytesPerWord) + 4);
-          memcpy(sbody + (srcOffset * elementSize),
-                 dbody + (dstOffset * elementSize),
+          uint8_t* sbody = &cast<uint8_t>(s, (offset + 1) * BytesPerWord);
+          uint8_t* dbody = &cast<uint8_t>(d, (offset + 1) * BytesPerWord);
+          memcpy(dbody + (dstOffset * elementSize),
+                 sbody + (srcOffset * elementSize),
                  length * elementSize);
           return;
         }
@@ -143,7 +153,7 @@ start(Thread* t, jobject this_)
 
     class Runnable: public System::Runnable {
      public:
-      Runnable(Thread* t): t(t) { }
+      Runnable(System* s, Thread* t): s(s), t(t) { }
 
       virtual void run(System::Thread* st) {
         t->systemThread = st;
@@ -153,10 +163,16 @@ start(Thread* t, jobject this_)
         t->exit();
       }
 
-      Thread* t;
-    } r(p);
+      virtual void dispose() {
+        s->free(this);
+      }
 
-    if (not t->vm->system->success(t->vm->system->start(&r))) {
+      System* s;
+      Thread* t;
+    }* r = new (t->vm->system->allocate(sizeof(Runnable)))
+       Runnable(t->vm->system, p);
+
+    if (not t->vm->system->success(t->vm->system->start(r))) {
       p->exit();
 
       object message = makeString(t, "unable to start native thread");
@@ -179,6 +195,8 @@ populate(Thread* t, object map)
       reinterpret_cast<void*>(notify) },
     { "Java_java_lang_Object_notifyAll",
       reinterpret_cast<void*>(notifyAll) },
+    { "Java_java_lang_Thread_sleep",
+      reinterpret_cast<void*>(sleep) },
     { "Java_java_lang_System_loadLibrary",
       reinterpret_cast<void*>(loadLibrary) },
     { "Java_java_lang_System_arraycopy",

src/machine.cpp

@@ -431,8 +431,9 @@ collect(Thread* t, Heap::CollectionType type)
 void
 removeMonitor(Thread* t, object o)
 {
-  abort(t);
-  hashMapRemove(t, t->vm->monitorMap, o, objectHash, referenceEqual);
+  object p = hashMapRemove
+    (t, t->vm->monitorMap, o, objectHash, referenceEqual);
+  static_cast<System::Monitor*>(pointerValue(t, p))->dispose();
 }
 
 object
@@ -770,7 +771,7 @@ makeString(Thread* t, const char* format, ...)
   object s = ::makeByteArray(t, format, a);
   va_end(a);
 
-  return makeString(t, s, 0, byteArrayLength(t, s), 0);
+  return makeString(t, s, 0, byteArrayLength(t, s) - 1, 0);
 }
 
 void
@@ -882,7 +883,7 @@ hashMapRemove(Thread* t, object map, object key,
     object p = 0;
     while (n) {
       if (equal(t, key, tripleFirst(t, n))) {
-        o = tripleFirst(t, n);
+        o = tripleSecond(t, n);
         if (p) {
           set(t, tripleThird(t, p), tripleThird(t, n));
         } else {

src/machine.h

@@ -1439,7 +1439,7 @@ pushLong(Thread* t, uint64_t v)
   }
 
   pushInt(t, v >> 32);
-  pushInt(t, v & 0xFF);
+  pushInt(t, v & 0xFFFFFFFF);
 }
 
 inline object
@@ -1555,7 +1555,7 @@ pokeLong(Thread* t, unsigned index, uint64_t value)
   }
 
   pokeInt(t, index, value >> 32);
-  pokeInt(t, index + 1, value & 0xFF);
+  pokeInt(t, index + 1, value & 0xFFFFFFFF);
 }
 
 inline object*

src/main.cpp

@@ -139,6 +139,7 @@ class System: public vm::System {
     }
 
     virtual void dispose() {
+      r->dispose();
       s->free(this);
     }
 
@@ -357,6 +358,12 @@ class System: public vm::System {
     return 0;
   }
 
+  virtual void sleep(int64_t milliseconds) {
+    timespec ts = { milliseconds / 1000, (milliseconds % 1000) * 1000 * 1000 };
+
+    nanosleep(&ts, 0);
+  }
+
   virtual uint64_t call(void* function, uintptr_t* arguments, uint8_t* types,
                         unsigned count, unsigned size, unsigned returnType)
   {

src/run.cpp

@@ -87,14 +87,6 @@ make(Thread* t, object class_)
   memset(static_cast<object*>(instance) + 1, 0,
          sizeInBytes - sizeof(object));
 
-  fprintf(stderr, "new instance: %p\n", instance);
-
-  if (class_ == arrayBody(t, t->vm->types, Machine::ThreadType)) {
-    if (threadPeer(t, instance)) {
-      fprintf(stderr, "yo!\n");
-    }
-  }
-
   return instance;
 }
 
@@ -390,7 +382,8 @@ parsePool(Thread* t, Stream& s)
 
       case CONSTANT_String: {
         object bytes = arrayBody(t, pool, intArrayBody(t, o, 1) - 1);
-        object value = makeString(t, bytes, 0, byteArrayLength(t, bytes), 0);
+        object value = makeString
+          (t, bytes, 0, byteArrayLength(t, bytes) - 1, 0);
         set(t, arrayBody(t, pool, i), value);
       } break;
 
@@ -2377,7 +2370,7 @@ run(Thread* t)
       if (isSpecialMethod(t, method, class_)) {
         class_ = classSuper(t, class_);
 
-        if (UNLIKELY(classVirtualTable(t, class_) == 0)) {
+        if (classVirtualTable(t, class_) == 0) {
           PROTECT(t, class_);
 
           resolveClass(t, className(t, class_));
@@ -2435,7 +2428,7 @@ run(Thread* t)
     if (LIKELY(peekObject(t, sp - parameterFootprint))) {
       object class_ = objectClass(t, peekObject(t, sp - parameterFootprint));
 
-      if (UNLIKELY(classVirtualTable(t, class_) == 0)) {
+      if (classVirtualTable(t, class_) == 0) {
         PROTECT(t, class_);
 
         resolveClass(t, className(t, class_));

src/system.h

@@ -29,6 +29,7 @@ class System: public Allocator {
    public:
     virtual ~Runnable() { }
     virtual void run(Thread*) = 0;
+    virtual void dispose() = 0;
   };
 
   class Monitor {
@@ -58,6 +59,7 @@ class System: public Allocator {
   virtual Status attach(Thread**) = 0;
   virtual Status start(Runnable*) = 0;
   virtual Status make(Monitor**) = 0;
+  virtual void sleep(int64_t milliseconds) = 0;
   virtual uint64_t call(void* function, uintptr_t* arguments, uint8_t* types,
                         unsigned count, unsigned size,
                         unsigned returnType) = 0;

src/types.def

@@ -145,7 +145,7 @@
   java/lang/ArrayIndexOutOfBoundsException
   (extends runtimeException))
 
-(type arrayStoreException java/lang/arrayStoreException
+(type arrayStoreException java/lang/ArrayStoreException
   (extends runtimeException))
 
 (type negativeArraySizeException java/lang/NegativeArraySizeException