RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 21:17:44 +00:00
Code Issues Activity Actions

LibJS: Very basic support for "new" construction in bytecode VM

Browse source 
This patch adds a CallType to the Bytecode::Op::Call instruction,
which can be either Call or Construct. We then generate Construct
calls for the NewExpression AST node.

When executed, these get fed into VM::construct().
This commit is contained in:
Andreas Kling 2021-06-10 23:01:49 +02:00
parent c3c68399b5
commit f5feb1d2cd
3 changed files with 23 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

12
Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp
View file

@ -632,7 +632,15 @@ void CallExpression::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::Store>(arg_reg); generator.emit<Bytecode::Op::Store>(arg_reg);
argument_registers.append(arg_reg); argument_registers.append(arg_reg);
} }
generator.emit_with_extra_register_slots<Bytecode::Op::Call>(argument_registers.size(), callee_reg, this_reg, argument_registers);
Bytecode::Op::Call::CallType call_type;
if (is<NewExpression>(*this)) {
call_type = Bytecode::Op::Call::CallType::Construct;
} else {
call_type = Bytecode::Op::Call::CallType::Call;
}
generator.emit_with_extra_register_slots<Bytecode::Op::Call>(argument_registers.size(), call_type, callee_reg, this_reg, argument_registers);
} }
void ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const void ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const
@ -813,7 +821,7 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
auto this_reg = generator.allocate_register(); auto this_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(this_reg); generator.emit<Bytecode::Op::Store>(this_reg);
generator.emit_with_extra_register_slots<Bytecode::Op::Call>(argument_regs.size(), tag_reg, this_reg, move(argument_regs)); generator.emit_with_extra_register_slots<Bytecode::Op::Call>(argument_regs.size(), Bytecode::Op::Call::CallType::Call, tag_reg, this_reg, move(argument_regs));
} }
void UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const void UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const

7
Userland/Libraries/LibJS/Bytecode/Op.cpp
View file

@ -199,14 +199,17 @@ void Call::execute(Bytecode::Interpreter& interpreter) const
Value return_value; Value return_value;
if (m_argument_count == 0) { if (m_argument_count == 0 && m_type == CallType::Call) {
return_value = interpreter.vm().call(function, this_value); return_value = interpreter.vm().call(function, this_value);
} else { } else {
MarkedValueList argument_values { interpreter.vm().heap() }; MarkedValueList argument_values { interpreter.vm().heap() };
for (size_t i = 0; i < m_argument_count; ++i) { for (size_t i = 0; i < m_argument_count; ++i) {
argument_values.append(interpreter.reg(m_arguments[i])); argument_values.append(interpreter.reg(m_arguments[i]));
} }
return_value = interpreter.vm().call(function, this_value, move(argument_values)); if (m_type == CallType::Call)
return_value = interpreter.vm().call(function, this_value, move(argument_values));
else
return_value = interpreter.vm().construct(function, function, move(argument_values), interpreter.global_object());
} }
interpreter.accumulator() = return_value; interpreter.accumulator() = return_value;

9
Userland/Libraries/LibJS/Bytecode/Op.h
View file

@ -325,10 +325,16 @@ public:
// NOTE: This instruction is variable-width depending on the number of arguments! // NOTE: This instruction is variable-width depending on the number of arguments!
class Call final : public Instruction { class Call final : public Instruction {
public: public:
Call(Register callee, Register this_value, Vector<Register> const& arguments) enum class CallType {
Call,
Construct,
};
Call(CallType type, Register callee, Register this_value, Vector<Register> const& arguments)
: Instruction(Type::Call) : Instruction(Type::Call)
, m_callee(callee) , m_callee(callee)
, m_this_value(this_value) , m_this_value(this_value)
, m_type(type)
, m_argument_count(arguments.size()) , m_argument_count(arguments.size())
{ {
for (size_t i = 0; i < m_argument_count; ++i) for (size_t i = 0; i < m_argument_count; ++i)
@ -343,6 +349,7 @@ public:
private: private:
Register m_callee; Register m_callee;
Register m_this_value; Register m_this_value;
CallType m_type;
size_t m_argument_count { 0 }; size_t m_argument_count { 0 };
Register m_arguments[]; Register m_arguments[];
}; };