various bugfixes concerning Thread.getStackTrace

src/builtin.cpp

@@ -53,6 +53,7 @@ enumerateThreads(Thread* t, Thread* x, object array, unsigned* index,
 {
   if (*index < limit) {
     set(t, array, ArrayBody + (*index * BytesPerWord), x->javaThread);
+    ++ (*index);
 
     if (x->peer) enumerateThreads(t, x->peer, array, index, limit);
     
@@ -711,7 +712,7 @@ Java_java_lang_Thread_interrupt(Thread* t, jclass, jlong peer)
 }
 
 extern "C" JNIEXPORT jobject JNICALL
-Java_java_lang_Thread_getTrace(Thread* t, jclass, jlong peer)
+Java_java_lang_Thread_getStackTrace(Thread* t, jclass, jlong peer)
 {
   ENTER(t, Thread::ActiveState);
 

src/compile.cpp

@@ -172,7 +172,7 @@ class MyStackWalker: public Processor::StackWalker {
     base(t->base),
     stack(t->stack),
     trace(t->trace),
-    nativeMethod(trace->nativeMethod),
+    nativeMethod(trace ? trace->nativeMethod : 0),
     method_(ip_ ? methodForIp(t, ip_) : 0),
     protector(this)
   { }
@@ -208,7 +208,7 @@ class MyStackWalker: public Processor::StackWalker {
   bool next() {
     if (nativeMethod) {
       nativeMethod = 0;
-    } else {
+    } else if (stack) {
       stack = static_cast<void**>(base) + 1;
       base = *static_cast<void**>(base);
       ip_ = *static_cast<void**>(stack);
@@ -225,6 +225,8 @@ class MyStackWalker: public Processor::StackWalker {
           return false;
         }
       }
+    } else {
+      return false;
     }
     return true;
   }
@@ -4639,16 +4641,15 @@ traceSize(Thread* t)
 {
   class Counter: public Processor::StackVisitor {
    public:
-    Counter(Thread* t): t(t), count(0) { }
+    Counter(): count(0) { }
 
     virtual bool visit(Processor::StackWalker*) {
       ++ count;
       return true;
     }
 
-    Thread* t;
     unsigned count;
-  } counter(t);
+  } counter;
 
   t->m->processor->walkStack(t, &counter);
 
@@ -4673,7 +4674,9 @@ class SegFaultHandler: public System::SignalHandler {
 
         ensure(t, FixedSizeOfNullPointerException + traceSize(t));
 
+        t->tracing = true;
         t->exception = makeNullPointerException(t);
+        t->tracing = false;
 
         findUnwindTarget(t, ip, base, stack);
         *thread = t;
@@ -5002,10 +5005,10 @@ class MyProcessor: public Processor {
       Visitor(MyThread* t, MyThread* target): t(t), target(target) { }
 
       virtual void visit(void* ip, void* base, void* stack) {
-        ensure(t, traceSize(t));
+        ensure(t, traceSize(target));
 
         void* oldIp = target->ip;
-        void* oldBase = target->ip;
+        void* oldBase = target->base;
         void* oldStack = target->stack;
 
         if (methodForIp(t, ip)) {
@@ -5014,7 +5017,9 @@ class MyProcessor: public Processor {
           target->stack = stack;
         }
 
+        t->tracing = true;
         trace = makeTrace(t, target);
+        t->tracing = false;
 
         target->ip = oldIp;
         target->base = oldBase;
@@ -5026,6 +5031,8 @@ class MyProcessor: public Processor {
       object trace;
     } visitor(t, target);
 
+    t->m->system->visit(t->systemThread, target->systemThread, &visitor);
+
     if (t->backupHeap) {
       PROTECT(t, visitor.trace);
 

src/machine.cpp

@@ -490,6 +490,7 @@ postCollect(Thread* t)
   if (t->backupHeap) {
     t->m->heap->free
       (t->backupHeap, t->backupHeapSizeInWords * BytesPerWord);
+    t->backupHeap = 0;
     t->backupHeapIndex = 0;
     t->backupHeapSizeInWords = 0;
   }
@@ -1735,7 +1736,8 @@ Thread::Thread(Machine* m, object javaThread, Thread* parent):
   heap(defaultHeap),
   backupHeap(0),
   backupHeapIndex(0),
-  backupHeapSizeInWords(0)
+  backupHeapSizeInWords(0),
+  tracing(false)
 #ifdef VM_STRESS
   , stress(false)
 #endif // VM_STRESS
@@ -2046,6 +2048,10 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
     t->backupHeapIndex += ceiling(sizeInBytes, BytesPerWord);
     cast<object>(o, 0) = 0;
     return o;
+  } else if (t->tracing) {
+    expect(t, t->heapIndex + ceiling(sizeInBytes, BytesPerWord)
+           <= Thread::HeapSizeInWords);
+    return allocateSmall(t, sizeInBytes);
   }
 
   ACQUIRE_RAW(t, t->m->stateLock);

src/machine.h

@@ -1291,6 +1291,7 @@ class Thread {
   uintptr_t* backupHeap;
   unsigned backupHeapIndex;
   unsigned backupHeapSizeInWords;
+  bool tracing;
 #ifdef VM_STRESS
   bool stress;
 #endif // VM_STRESS

src/posix.cpp

@@ -793,6 +793,8 @@ handleSignal(int signal, siginfo_t* info, void* context)
 
     System::Thread* t = system->visitTarget;
     system->visitTarget = 0;
+
+    ACQUIRE_MONITOR(t, system->visitLock);
     system->visitLock->notifyAll(t);
   } break;
 
@@ -830,7 +832,13 @@ handleSignal(int signal, siginfo_t* info, void* context)
   } else if (system->oldHandlers[index].sa_handler) {
     system->oldHandlers[index].sa_handler(signal);
   } else {
-    abort();
+    switch (signal) {
+    case VisitSignal:
+      break;
+
+    default:
+      abort();
+    }
   }
 }
 

src/process.cpp

@@ -223,7 +223,11 @@ findLineNumber(Thread* t, object method, unsigned ip)
       }
     }
 
-    abort(t);
+    if (top < lineNumberTableLength(t, lnt)) {
+      return lineNumberLine(lineNumberTableBody(t, lnt, top));
+    } else {
+      return UnknownLine;
+    }
   } else {
     return UnknownLine;
   }