Skip to content

Commit 3f36f2d

Browse files
MetsukiMioMetsukiMio
committed
VM (new pixeltower): 函数调用测试 (无参数)
1 parent 5fff0e0 commit 3f36f2d

9 files changed

Lines changed: 171 additions & 20 deletions

File tree

‎include/openminecraft/vm/pixeltower/v0/om_pixeltower_frame.hpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ namespace openminecraft::vm::pixeltower::v0
77
struct OMFrame
88
{
99
OMMethod *method;
10+
OMFrame *prev;
1011
void *stackPointer;
1112
void *returnAddr;
1213
jbyte locals[0];

‎include/openminecraft/vm/pixeltower/v0/om_pixeltower_interpreter.hpp‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,18 +3,23 @@
33

44
#include "openminecraft/log/om_log_common.hpp"
55
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
6+
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp"
67
namespace openminecraft::vm::pixeltower::v0
78
{
9+
class OMPixelTower;
810
class OMInterpreter
911
{
1012
public:
11-
OMInterpreter(OMPixelTowerHeap *heap);
13+
OMInterpreter(OMPixelTowerHeap *heap, OMPixelTower *tower);
1214
~OMInterpreter();
1315

1416
bool execute();
1517

1618
private:
19+
void call(OMMethod *met);
20+
1721
log::OMLogger logger;
22+
OMPixelTower *tower;
1823
OMPixelTowerHeap *heap;
1924
};
2025
} // namespace openminecraft::vm::pixeltower::v0

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

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,8 @@ class OMKlass
3535
void *staticBlock;
3636
uint64_t staticLength;
3737

38+
uint64_t *constantPool;
39+
3840
OMPixelTowerHeap *heap;
3941

4042
OMOOPDesc *allocateInstance()

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ struct OMMethod
1616
jint maxLocals;
1717
jint maxStack;
1818
jint codeSize;
19-
jbyte code[0];
19+
uint8_t code[0];
2020
// code space
2121
};
2222
} // namespace openminecraft::vm::pixeltower::v0

‎include/openminecraft/vm/pixeltower/v0/om_pixeltower_threads.hpp‎

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,11 +14,23 @@ class OMPixelTowerThread
1414

1515
std::thread::id id;
1616
std::string name;
17-
jbyte *pc;
17+
uint8_t *pc;
1818
OMFrame *currentFrame;
1919
void *stack;
20+
void *stackEnd;
2021
};
2122

23+
#define stackBump \
24+
currentThread.currentFrame->stackPointer = (uint8_t *)currentThread.currentFrame->stackPointer - sizeof(void *);
25+
#define stackPushPointer(p) \
26+
*(void **)currentThread.currentFrame->stackPointer = p; \
27+
stackBump;
28+
#define stackPushInt(i) \
29+
*(jint **)currentThread.currentFrame->stackPointer = i; \
30+
stackBump;
31+
#define stackTopPointer (*((void **)currentThread.currentFrame->stackPointer + 1))
32+
#define stackTopInt (*(jint *)((void **)currentThread.currentFrame->stackPointer + 1))
33+
2234
extern thread_local OMPixelTowerThread currentThread;
2335
} // namespace openminecraft::vm::pixeltower::v0
2436

‎src/vm/pixeltower/v0/om_pixeltower.cpp‎

Lines changed: 11 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ OMPixelTower::OMPixelTower() : logger("OMPixelTower", this)
2020
heap = new OMPixelTowerHeap(1ul * 1024 * 1024, 1ul * 1024 * 1024 * 1024);
2121
metaspace = new OMPixelTowerHeap(1ul * 1024 * 1024, 8ul * 1024 * 1024);
2222
loader = new OMKlassLoader(heap, metaspace);
23-
interpreter = new OMInterpreter(heap);
23+
interpreter = new OMInterpreter(heap, this);
2424
}
2525
OMPixelTower::~OMPixelTower()
2626
{
@@ -32,21 +32,17 @@ OMPixelTower::~OMPixelTower()
3232

3333
void OMPixelTower::stackTest(OMMethod *method)
3434
{
35-
auto frame = (OMFrame *)(currentThread.currentFrame == nullptr ? currentThread.stack
36-
: currentThread.currentFrame->stackPointer);
37-
frame->stackPointer = (jbyte *)currentThread.stack + sizeof(OMFrame);
35+
auto frame = (OMFrame *)((uint8_t *)currentThread.stack - sizeof(OMFrame));
36+
frame->stackPointer = (jbyte *)currentThread.stack - sizeof(OMFrame) - method->maxLocals * sizeof(void *);
3837
frame->returnAddr = currentThread.pc;
3938
frame->method = method;
4039

41-
frame->stackPointer = (uint8_t *)frame->stackPointer + method->maxLocals * sizeof(void *);
42-
4340
currentThread.currentFrame = frame;
4441
currentThread.pc = method->code;
4542

46-
logger.debug("method {} code {}", (void *)method, (void *)method->code);
47-
logger.debug("stack: {}", currentThread.stack);
48-
49-
interpreter->execute();
43+
while (interpreter->execute())
44+
{
45+
}
5046
}
5147

5248
void OMPixelTower::init(std::string basePath)
@@ -89,19 +85,20 @@ void OMPixelTower::init(std::vector<std::shared_ptr<std::istream>> &streams)
8985

9086
void OMPixelTower::initCurrentThread(uint64_t tlsSize)
9187
{
92-
if (currentThread.stack)
88+
if (currentThread.stackEnd)
9389
{
9490
return;
9591
}
9692

97-
currentThread.stack = mem::allocator::tracedCallocVMData(1, tlsSize);
93+
currentThread.stackEnd = mem::allocator::tracedCallocVMData(1, tlsSize);
94+
currentThread.stack = (uint8_t *)currentThread.stackEnd + tlsSize;
9895
}
9996

10097
void OMPixelTower::destroyCurrentThread()
10198
{
102-
if (currentThread.stack)
99+
if (currentThread.stackEnd)
103100
{
104-
mem::allocator::tracedFreeVMData(currentThread.stack);
101+
mem::allocator::tracedFreeVMData(currentThread.stackEnd);
105102
}
106103
}
107104
} // namespace openminecraft::vm::pixeltower::v0

‎src/vm/pixeltower/v0/om_pixeltower_interpreter.cpp‎

Lines changed: 60 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,77 @@
11
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_interpreter.hpp"
2+
#include "openminecraft/binary/om_bin_endians.hpp"
23
#include "openminecraft/log/om_log_common.hpp"
4+
#include "openminecraft/vm/bytecode/om_bytecodes.hpp"
5+
#include "openminecraft/vm/pixeltower/v0/om_pixeltower.hpp"
6+
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_frame.hpp"
37
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
8+
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_klass.hpp"
49
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_threads.hpp"
510

611
namespace openminecraft::vm::pixeltower::v0
712
{
8-
OMInterpreter::OMInterpreter(OMPixelTowerHeap *heap) : heap(heap), logger("OMInterpreter", this)
13+
OMInterpreter::OMInterpreter(OMPixelTowerHeap *heap, OMPixelTower *tower)
14+
: heap(heap), logger("OMInterpreter", this), tower(tower)
915
{
1016
}
1117
OMInterpreter::~OMInterpreter()
1218
{
1319
}
20+
21+
void OMInterpreter::call(OMMethod *met)
22+
{
23+
auto frame = currentThread.currentFrame;
24+
25+
auto nextframe = (OMFrame *)((uint8_t *)frame->stackPointer - sizeof(OMFrame));
26+
nextframe->stackPointer = (jbyte *)frame->stackPointer - sizeof(OMFrame) - met->maxLocals * sizeof(void *);
27+
nextframe->returnAddr = currentThread.pc + 3;
28+
nextframe->method = met;
29+
nextframe->prev = frame;
30+
31+
currentThread.currentFrame = nextframe;
32+
currentThread.pc = met->code;
33+
}
34+
1435
bool OMInterpreter::execute()
1536
{
16-
logger.debug("pc pointed at {}", (void *)currentThread.pc);
17-
logger.debug("method metadata at {}", (void *)currentThread.currentFrame);
37+
auto frame = currentThread.currentFrame;
38+
switch (currentThread.pc[0])
39+
{
40+
case op_dup: {
41+
stackPushPointer(stackTopPointer);
42+
currentThread.pc++;
43+
return true;
44+
}
45+
case op_return: {
46+
currentThread.pc = (uint8_t *)currentThread.currentFrame->returnAddr;
47+
currentThread.currentFrame = currentThread.currentFrame->prev;
48+
49+
return true;
50+
}
51+
case op_invokespecial: {
52+
auto n = *static_cast<OMMethod **>(static_cast<void *>(
53+
frame->method->klass->constantPool + binary::be16ToNative(*(uint16_t *)(currentThread.pc + 1))));
54+
call(n);
55+
56+
return true;
57+
}
58+
case op_new: {
59+
auto n = *static_cast<OMKlass **>(static_cast<void *>(
60+
frame->method->klass->constantPool + binary::be16ToNative(*(uint16_t *)(currentThread.pc + 1))));
61+
stackPushPointer(n->allocateInstance());
62+
63+
currentThread.pc += 3;
64+
return true;
65+
}
66+
default: {
67+
logger.debug("unknown command at {}", (void *)currentThread.pc);
68+
logger.debug("thread {}", (void *)&currentThread.id);
69+
logger.debug("pc pointed at {}", (void *)currentThread.pc);
70+
logger.debug("sp pointed at {}", (void *)currentThread.currentFrame->stackPointer);
71+
logger.debug("method metadata at {}", (void *)frame);
72+
break;
73+
}
74+
}
1875
return false;
1976
}
2077
} // namespace openminecraft::vm::pixeltower::v0

‎src/vm/pixeltower/v0/om_pixeltower_klassloader.cpp‎

Lines changed: 72 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
#include "openminecraft/vm/bytecode/om_bytecode_descriptor.hpp"
66
#include "openminecraft/vm/classfile/om_class_file.hpp"
77
#include "openminecraft/vm/err/om_validation_error.hpp"
8+
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_base.hpp"
89
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_field.hpp"
910
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
1011
#include "openminecraft/vm/pixeltower/v0/om_pixeltower_klass.hpp"
@@ -27,6 +28,10 @@ OMKlassLoader::~OMKlassLoader()
2728
{
2829
mem::allocator::tracedFreeVMData(k->staticBlock);
2930
}
31+
if (k->constantPool)
32+
{
33+
mem::allocator::tracedFreeVMData(k->constantPool);
34+
}
3035
mem::allocator::tracedFreeVMData(k);
3136
}
3237
}
@@ -145,6 +150,73 @@ void OMKlassLoader::loadClass(std::string name)
145150
klass->raw->mapping[field->descIndex]->to<classfile::OMClassConstantUtf8>()->data, 0,
146151
field->accessFlags});
147152
}
153+
154+
klass->constantPool = (uint64_t *)mem::allocator::tracedCallocVMData(klass->raw->mapping.size(), sizeof(uint64_t));
155+
for (auto cppair : klass->raw->mapping)
156+
{
157+
#define acc (klass->constantPool + cppair.first)
158+
switch (cppair.second->type())
159+
{
160+
case classfile::OMClassConstantType::Long:
161+
*(jlong *)acc = cppair.second->to<classfile::OMClassConstantLong>()->data;
162+
break;
163+
case classfile::OMClassConstantType::Integer:
164+
*(jint *)acc = cppair.second->to<classfile::OMClassConstantInteger>()->data;
165+
break;
166+
case classfile::OMClassConstantType::Float:
167+
*(jfloat *)acc = cppair.second->to<classfile::OMClassConstantFloat>()->data;
168+
break;
169+
case classfile::OMClassConstantType::Double:
170+
*(jdouble *)acc = cppair.second->to<classfile::OMClassConstantDouble>()->data;
171+
break;
172+
case classfile::OMClassConstantType::Class: {
173+
auto &cls = klass->raw->mapping[cppair.second->to<classfile::OMClassConstantClass>()->nameIndex]
174+
->to<classfile::OMClassConstantUtf8>()
175+
->data;
176+
loadClass(cls);
177+
*(OMKlass **)acc = fetchClass(cls);
178+
break;
179+
}
180+
case classfile::OMClassConstantType::MethodRef: {
181+
auto temp = cppair.second->to<classfile::OMClassConstantMethodRef>();
182+
auto &clsname =
183+
klass->raw
184+
->mapping[klass->raw->mapping[temp->classIndex]->to<classfile::OMClassConstantClass>()->nameIndex]
185+
->to<classfile::OMClassConstantUtf8>()
186+
->data;
187+
loadClass(clsname);
188+
auto temp2 = klass->raw->mapping[temp->nameAndTypeIndex]->to<classfile::OMClassConstantNameAndType>();
189+
auto &name = klass->raw->mapping[temp2->nameIndex]->to<classfile::OMClassConstantUtf8>()->data;
190+
auto &desc = klass->raw->mapping[temp2->descIndex]->to<classfile::OMClassConstantUtf8>()->data;
191+
auto met = fetchClass(clsname)->methods;
192+
while (met != nullptr)
193+
{
194+
if (strcmp(met->name, name.c_str()) == 0 && strcmp(met->desc, desc.c_str()) == 0)
195+
{
196+
*(OMMethod **)acc = met;
197+
break;
198+
}
199+
200+
met = met->next;
201+
}
202+
break;
203+
}
204+
205+
case classfile::OMClassConstantType::Utf8:
206+
case classfile::OMClassConstantType::String:
207+
case classfile::OMClassConstantType::FieldRef:
208+
case classfile::OMClassConstantType::InterfaceMethodRef:
209+
case classfile::OMClassConstantType::NameAndType:
210+
case classfile::OMClassConstantType::MethodHandle:
211+
case classfile::OMClassConstantType::MethodType:
212+
case classfile::OMClassConstantType::Dynamic:
213+
case classfile::OMClassConstantType::InvokeDynamic:
214+
case classfile::OMClassConstantType::Module:
215+
case classfile::OMClassConstantType::Package:
216+
break;
217+
}
218+
}
219+
148220
classInit(klass);
149221
}
150222

‎vmstd/src/java/lang/Exception.java‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
package java.lang;
2+
3+
public class Exception
4+
{
5+
}

0 commit comments

Comments
 (0)