VM (new pixeltower): 类加载器

Author: MetsukiMio

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

@@ -15,11 +15,14 @@ class OMPixelTower
     ~OMPixelTower();
 
     void init(std::string basePath);
+    void load(std::string path);
     void init(std::vector<std::shared_ptr<std::istream>> &streams);
+    void testAppendMethod();
     OMKlassLoader *loader;
+    OMPixelTowerHeap *heap;
+    OMPixelTowerHeap *metaspace;
 
   private:
-    OMPixelTowerHeap *heap;
     log::OMLogger logger;
 };
 } // namespace openminecraft::vm::pixeltower::v0

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

@@ -0,0 +1,17 @@
+#ifndef OM_PIXELTOWER_FIELD_HPP
+#define OM_PIXELTOWER_FIELD_HPP
+
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_base.hpp"
+#include <string>
+namespace openminecraft::vm::pixeltower::v0
+{
+struct OMField
+{
+    std::string name;
+    std::string desc;
+    jint offset;
+    AccessFlags accessFlags;
+};
+} // namespace openminecraft::vm::pixeltower::v0
+
+#endif

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

@@ -25,7 +25,31 @@ class OMPixelTowerHeap
     void debug();
     void merge();
 
+    void *heapBase()
+    {
+        return heap->block;
+    }
+
+    bool enablePointerCompression()
+    {
+        return maxSize < 32ull * 1024 * 1024 * 1024 && (sizeof(void *) == 8);
+    }
+    uint64_t pointerSize()
+    {
+        return enablePointerCompression() ? 4 : sizeof(void *);
+    }
+
+    uint32_t compressPointer(void *p)
+    {
+        return ((size_t)p - (size_t)heap->block) >> 3;
+    }
+    void *decompressPointer(uint32_t p)
+    {
+        return (void *)((size_t)(p << 3) + (size_t)heap->block);
+    }
+
   private:
+    uint64_t maxSize;
     mem::OMHeap *heap;
     std::mutex emptyBlockMutex;
     std::vector<OMHeapEmptyBlock> emptyBlocks;

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

@@ -3,6 +3,10 @@
 
 #include "openminecraft/vm/classfile/om_class_file.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_base.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_field.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_oop.hpp"
+#include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -14,14 +18,30 @@ enum OMKlassKind : uint8_t
     Array
 };
 
+struct OMMethod;
+
 class OMKlass
 {
   public:
     OMKlassKind kind;
     std::string name;
     std::shared_ptr<classfile::OMClassFile> raw;
     OMKlass *superClass;
+    std::vector<OMKlass *> interfaces;
+    OMMethod *methods;
     AccessFlags accessFlags;
+    std::vector<OMField> fields;
+    uint64_t length;
+    void *staticBlock;
+    uint64_t staticLength;
+
+    OMPixelTowerHeap *heap;
+
+    void *allocateInstance()
+    {
+        assert(kind == OMKlassKind::Normal);
+        return heap->allocate(sizeof(OMOOPDesc) + length);
+    }
 };
 } // namespace openminecraft::vm::pixeltower::v0
 

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

@@ -3,6 +3,7 @@
 
 #include "openminecraft/log/om_log_common.hpp"
 #include "openminecraft/vm/classfile/om_class_file.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_klass.hpp"
 #include <memory>
 #include <vector>
@@ -11,17 +12,21 @@ namespace openminecraft::vm::pixeltower::v0
 class OMKlassLoader
 {
   public:
-    OMKlassLoader();
+    OMKlassLoader(OMPixelTowerHeap *heap, OMPixelTowerHeap *metaspace);
     ~OMKlassLoader();
 
     void stagClass(std::shared_ptr<classfile::OMClassFile> file)
     {
         files.push_back(file);
     }
     void loadClass(std::string name);
+    void loadSpecialClass(std::string name);
+    void classInit(OMKlass *klass);
     OMKlass *fetchClass(std::string name);
 
   private:
+    OMPixelTowerHeap *metaspace;
+    OMPixelTowerHeap *heap;
     log::OMLogger logger;
     std::vector<OMKlass *> classes;
     std::vector<std::shared_ptr<classfile::OMClassFile>> files;

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

@@ -5,13 +5,19 @@
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_klass.hpp"
 namespace openminecraft::vm::pixeltower::v0
 {
-class OMMethod
+struct OMMethod
 {
     OMKlass *klass;
-    jbyte *code;
-    jint codeSize;
+    const jbyte *name;
+    const jbyte *desc;
+    OMMethod *next;
     jint *lineNumberTable;
     AccessFlags accessFlags;
+    jint maxLocals;
+    jint maxStack;
+    jint codeSize;
+    uint8_t code[0];
+    // code space
 };
 } // namespace openminecraft::vm::pixeltower::v0
 

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

@@ -2,16 +2,25 @@
 #define OM_PIXELTOWER_OOP_HPP
 
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_base.hpp"
-#include "openminecraft/vm/pixeltower/v0/om_pixeltower_klass.hpp"
 
 namespace openminecraft::vm::pixeltower::v0
 {
-class OMOOPDesc
+class OMKlass;
+struct OMOOPDesc
 {
-    jint mark;
     OMKlass *klass;
+    jint mark;
+    jbyte data[0];
     // object data area
 };
+struct OMOOPArrDesc
+{
+    OMKlass *klass;
+    jint mark;
+    jint length;
+    jbyte data[0];
+    // array data area
+};
 } // namespace openminecraft::vm::pixeltower::v0
 
 #endif

src/boot/entrypoint.cpp

@@ -37,6 +37,8 @@
 #include "openminecraft/vfs/om_vfs_base.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_oop.hpp"
 #include <SDL3/SDL.h>
 #include <boost/stacktrace.hpp>
 #include <fmt/format.h>
@@ -153,9 +155,12 @@ int boot(std::vector<std::string> args)
                 if (commandBuffer.size() >= 3 && commandBuffer[1] == "init")
                 {
                     tower->init(commandBuffer[2]);
-                    tower->loader->loadClass("vmstd/internal/SystemPrintStream");
-                    logger->info("{}", (void *)tower->loader->fetchClass("vmstd/internal/SystemPrintStream"));
+                    tower->load("../Test.class");
+                    tower->loader->loadClass("openminecraft/Test");
+                    auto cls = tower->loader->fetchClass("openminecraft/Test");
+                    logger->info("{}", (void *)cls);
                     commandBuffer.clear();
+
                     break;
                 }
                 goto unk;

src/vm/pixeltower/v0/om_pixeltower.cpp

@@ -3,6 +3,7 @@
 #include "openminecraft/util/om_util_result.hpp"
 #include "openminecraft/vm/classfile/om_class_file.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp"
 #include <filesystem>
 #include <fstream>
 #include <memory>
@@ -12,12 +13,51 @@ namespace openminecraft::vm::pixeltower::v0
 OMPixelTower::OMPixelTower() : logger("OMPixelTower", this)
 {
     heap = new OMPixelTowerHeap(1ul * 1024 * 1024, 1ul * 1024 * 1024 * 1024);
-    loader = new OMKlassLoader();
+    metaspace = new OMPixelTowerHeap(1ul * 1024 * 1024, 8ul * 1024 * 1024);
+    loader = new OMKlassLoader(heap, metaspace);
 }
 OMPixelTower::~OMPixelTower()
 {
     delete loader;
     delete heap;
+    delete metaspace;
+}
+
+void OMPixelTower::testAppendMethod()
+{
+    auto alloc = (OMMethod *)metaspace->allocate(sizeof(OMMethod) + 128);
+    loader->loadClass("java/lang/Object");
+    alloc->klass = loader->fetchClass("java/lang/Object");
+    alloc->name = "equals";
+    alloc->desc = "(Ljava/lang/Object;)Z";
+    alloc->accessFlags = JVM_Acc_Public;
+    alloc->codeSize = 128;
+    alloc->lineNumberTable = nullptr;
+
+    for (auto i = 0; i < 128; i++)
+    {
+        alloc->code[i] = 0xcc;
+    }
+    logger.debug("function inserted at {}", (void *)alloc);
+
+    if (alloc == metaspace->heapBase())
+    {
+        return;
+    }
+
+    auto currentMet = (OMMethod *)metaspace->heapBase();
+    while (true)
+    {
+        if (currentMet->next == nullptr)
+        {
+            currentMet->next = alloc;
+            break;
+        }
+        else
+        {
+            currentMet = currentMet->next;
+        }
+    }
 }
 
 void OMPixelTower::init(std::string basePath)
@@ -35,6 +75,13 @@ void OMPixelTower::init(std::string basePath)
     init(target);
 }
 
+void OMPixelTower::load(std::string path)
+{
+    std::vector<std::shared_ptr<std::istream>> target;
+    target.push_back(std::make_shared<std::ifstream>(path, std::ios::binary));
+    init(target);
+}
+
 void OMPixelTower::init(std::vector<std::shared_ptr<std::istream>> &streams)
 {
     for (auto &s : streams)

src/vm/pixeltower/v0/om_pixeltower_heap.cpp

@@ -5,7 +5,8 @@
 
 namespace openminecraft::vm::pixeltower::v0
 {
-OMPixelTowerHeap::OMPixelTowerHeap(uint64_t minSize, uint64_t maxSize) : logger("OMPixelTowerHeap", this)
+OMPixelTowerHeap::OMPixelTowerHeap(uint64_t minSize, uint64_t maxSize)
+    : logger("OMPixelTowerHeap", this), maxSize(maxSize)
 {
     heap = new mem::OMHeap(minSize, maxSize);
     heap->init();