80b1604b0a
If there's a current Bytecode::Interpreter in action, ScriptFunction will now compile itself into bytecode and execute in that context. This patch also adds the Return bytecode instruction so that we can actually return values from called functions. :^) Return values are propagated from callee to caller via the caller's $0 register. Bytecode::Interpreter now keeps a stack of register "windows". These are not very efficient, but it should be pretty straightforward to convert them to e.g a sliding register window architecture later on. This is pretty dang cool! :^)
92 lines
2.6 KiB
C++
92 lines
2.6 KiB
C++
/*
|
|
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <LibJS/Bytecode/Block.h>
|
|
#include <LibJS/Bytecode/Instruction.h>
|
|
#include <LibJS/Bytecode/Interpreter.h>
|
|
#include <LibJS/Runtime/GlobalObject.h>
|
|
|
|
namespace JS::Bytecode {
|
|
|
|
static Interpreter* s_current;
|
|
|
|
Interpreter* Interpreter::current()
|
|
{
|
|
return s_current;
|
|
}
|
|
|
|
Interpreter::Interpreter(GlobalObject& global_object)
|
|
: m_vm(global_object.vm())
|
|
, m_global_object(global_object)
|
|
{
|
|
VERIFY(!s_current);
|
|
s_current = this;
|
|
}
|
|
|
|
Interpreter::~Interpreter()
|
|
{
|
|
VERIFY(s_current == this);
|
|
s_current = nullptr;
|
|
}
|
|
|
|
Value Interpreter::run(Bytecode::Block const& block)
|
|
{
|
|
dbgln("Bytecode::Interpreter will run block {:p}", &block);
|
|
|
|
if (vm().call_stack().is_empty()) {
|
|
CallFrame global_call_frame;
|
|
global_call_frame.this_value = &global_object();
|
|
static FlyString global_execution_context_name = "(*BC* global execution context)";
|
|
global_call_frame.function_name = global_execution_context_name;
|
|
global_call_frame.scope = &global_object();
|
|
VERIFY(!vm().exception());
|
|
// FIXME: How do we know if we're in strict mode? Maybe the Bytecode::Block should know this?
|
|
// global_call_frame.is_strict_mode = ???;
|
|
vm().push_call_frame(global_call_frame, global_object());
|
|
VERIFY(!vm().exception());
|
|
}
|
|
|
|
m_register_windows.append(make<RegisterWindow>());
|
|
registers().resize(block.register_count());
|
|
|
|
size_t pc = 0;
|
|
while (pc < block.instructions().size()) {
|
|
auto& instruction = block.instructions()[pc];
|
|
instruction.execute(*this);
|
|
if (m_pending_jump.has_value()) {
|
|
pc = m_pending_jump.release_value();
|
|
continue;
|
|
}
|
|
if (!m_return_value.is_empty())
|
|
break;
|
|
++pc;
|
|
}
|
|
|
|
dbgln("Bytecode::Interpreter did run block {:p}", &block);
|
|
for (size_t i = 0; i < registers().size(); ++i) {
|
|
String value_string;
|
|
if (registers()[i].is_empty())
|
|
value_string = "(empty)";
|
|
else
|
|
value_string = registers()[i].to_string_without_side_effects();
|
|
dbgln("[{:3}] {}", i, value_string);
|
|
}
|
|
|
|
m_register_windows.take_last();
|
|
|
|
m_return_value = m_return_value.value_or(js_undefined());
|
|
|
|
// NOTE: The return value from a called function is put into $0 in the caller context.
|
|
if (!m_register_windows.is_empty())
|
|
m_register_windows.last()[0] = m_return_value;
|
|
|
|
if (vm().call_stack().size() == 1)
|
|
vm().pop_call_frame();
|
|
|
|
return m_return_value;
|
|
}
|
|
|
|
}
|