VM (new pixeltower): 异常堆栈追踪

Author: MetsukiMio

include/openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp

@@ -48,11 +48,19 @@ class OMPixelTowerHeap
     inline uint32_t compressPtr(void *p)
     {
         assert(sizeof(void *) == 8);
+        if (!p)
+        {
+            return 0x1;
+        }
         return ((size_t)p - (size_t)heap->block) >> 3;
     }
     inline void *decompressPtr(uint32_t p)
     {
         assert(sizeof(void *) == 8);
+        if (p == 0x1)
+        {
+            return nullptr;
+        }
         return (void *)((size_t)(p << 3) + (size_t)heap->block);
     }
 

include/openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp

@@ -22,7 +22,6 @@ struct OMMethod
     std::unordered_map<jint, OMKlass *> *argCheck;
     std::unordered_map<jint, jint> *sourceMap;
     OMMethod *next;
-    jint *lineNumberTable;
     AccessFlags accessFlags;
     jint maxLocals;
     jint maxStack;

src/vm/impl/om_impl_throwable.cpp

@@ -1,10 +1,82 @@
 #include "openminecraft/vm/impl/om_impl_throwable.hpp"
 
+using namespace openminecraft::vm::pixeltower::v0;
+
 namespace openminecraft::vm::impl
 {
-std::any java_lang_Throwable_fillInStackTrace(pixeltower::v0::OMPixelTower *tower, std::any *d)
+std::any java_lang_Throwable_fillInStackTrace(OMPixelTower *tower, std::any *d)
 {
-    std::cout << "filling for " << std::any_cast<void *>(d[0]) << std::endl;
+    auto arrcls = tower->loader->fetchClass({bytecode::descriptor::Array, "java/lang/StackTraceElement", 1, bytecode::descriptor::Reference});
+    auto cls = tower->loader->fetchClass({bytecode::descriptor::Reference, "java/lang/StackTraceElement"});
+    auto thr = tower->loader->fetchClass({bytecode::descriptor::Reference, "java/lang/Throwable"});
+    auto fr = currentThread.currentFrame;
+    auto pc = currentThread.pc;
+
+    std::vector<OMOOPDesc *> frames;
+    while (fr)
+    {
+        auto frame = cls->allocateInstance();
+        frames.push_back(frame);
+        for (auto &f : cls->fields)
+        {
+            if (f.name == "declaringClass")
+            {
+                stackPushAccess<void *>(frame);
+                stackPushAccess<void *>(fr->method->klass->oop);
+                accessField(&f);
+            }
+            else if (f.name == "name")
+            {
+                stackPushAccess<void *>(frame);
+                stackPushAccess<void *>(tower->createString(fr->method->name));
+                accessField(&f);
+            }
+            else if (f.name == "descriptor")
+            {
+                stackPushAccess<void *>(frame);
+                stackPushAccess<void *>(tower->createString(fr->method->desc));
+                accessField(&f);
+            }
+            else if (f.name == "sourceFile")
+            {
+                stackPushAccess<void *>(frame);
+                stackPushAccess<void *>(tower->createString(fr->method->klass->source));
+                accessField(&f);
+            }
+            else if (fr->method->sourceMap && f.name == "line")
+            {
+                stackPushAccess<void *>(frame);
+                stackPushAccess<jint>(fr->method->sourceMap->at(static_cast<jint>(static_cast<size_t>(pc - fr->method->code))));
+                accessField(&f);
+            }
+        }
+        pc = static_cast<uint8_t *>(fr->returnAddr);
+        fr = fr->prev;
+    }
+
+    auto result = arrcls->allocateArray(static_cast<jint>(frames.size()));
+    for (int i = 0; i < frames.size(); i++)
+    {
+        if (tower->heap->ptrCompEnabled())
+        {
+            result->array<uint32_t>()[i] = tower->heap->compressPtr(frames[i]);
+        }
+        else
+        {
+            result->array<void *>()[i] = frames[i];
+        }
+    }
+
+    for (auto &field : thr->fields)
+    {
+        if (field.name == "stacktrace")
+        {
+            stackPushAccess<void *>(std::any_cast<void *>(d[0]));
+            stackPushAccess<void *>(result);
+            accessField(&field);
+        }
+    }
+
     return nullptr;
 }
 } // namespace openminecraft::vm::impl

src/vm/pixeltower/v0/om_pixeltower_interpreter.cpp

@@ -1394,8 +1394,8 @@ jint OMInterpreter::execute()
 
 #define icmpcond(op, sign)                                                                                             \
     case op: {                                                                                                         \
-        auto item = stackTopAccess<jint>(true);                                                                        \
         auto item2 = stackTopAccess<jint>(true);                                                                       \
+        auto item = stackTopAccess<jint>(true);                                                                        \
         if (item sign item2)                                                                                           \
         {                                                                                                              \
             currentThread.pc += binary::be16SignedToNative(currentThread.pc[1], currentThread.pc[2]);                  \

src/vm/pixeltower/v0/om_pixeltower_klassloader.cpp

@@ -69,6 +69,7 @@ OMKlassLoader::~OMKlassLoader()
 
 void OMKlassLoader::initBase()
 {
+    loadClass({bytecode::descriptor::Reference, "java/lang/Class"});
     loadClass({bytecode::descriptor::Reference, "java/lang/String"});
 }
 
@@ -129,17 +130,17 @@ void OMKlassLoader::loadClass(OMTypeDesc name)
 
 void OMKlassLoader::klassOopCreate(OMKlass *klass)
 {
-    auto clsklass = fetchClass({bytecode::descriptor::Reference, "java/lang/String"});
+    auto clsklass = fetchClass({bytecode::descriptor::Reference, "java/lang/Class"});
     auto tgt = clsklass->allocateInstance();
+    tgt->mark |= mconst;
     klass->oop = tgt;
-    auto ii = interpreter->tower->createString(klass->name);
 
     for (auto &f : clsklass->fields)
     {
         if (f.name == "name")
         {
             stackPushAccess<void *>(tgt);
-            stackPushAccess<void *>(ii);
+            stackPushAccess<void *>(interpreter->tower->createString(klass->name));
             accessField(&f);
         }
         if (f.name == "nativePtr")
@@ -160,7 +161,8 @@ OMKlass *OMKlassLoader::klassConstruct(
     void *rawmap = metaspace->allocate(sizeof(std::unordered_map<std::string, OMMethod *>));
     klass->vtable = new (rawmap) std::unordered_map<std::string, OMMethod *>();
     klass->heap = heap;
-    klass->name = bytecode::descriptor::restore(desc);
+    auto nn = bytecode::descriptor::restore(desc);
+    klass->name = nn;
     klass->accessFlags = f->accessFlags;
     klass->raw = f;
     files.erase(fi);

vmstd/src/java/lang/StackTraceElement.java

@@ -2,12 +2,12 @@
 
 public class StackTraceElement
 {
-    private Class<?> declaringClass;
-    private String name;
-    private String descriptor;
+    Class<?> declaringClass;
+    String name;
+    String descriptor;
 
-    private String sourceFile;
-    private int line;
+    String sourceFile;
+    int line;
 
     private StackTraceElement()
     {

vmstd/src/java/lang/Throwable.java

@@ -34,4 +34,16 @@ public Throwable(Throwable cause)
     }
 
     private native void fillInStackTrace();
+
+    public void printStackTrace()
+    {
+        for (StackTraceElement e : stacktrace)
+        {
+            System.out.println(e.declaringClass.getName());
+            System.out.println(e.name);
+            System.out.println(e.descriptor);
+            System.out.println(e.sourceFile);
+            System.out.println(e.line);
+        }
+    }
 }