1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 19:57:35 +00:00

LibJS: Make ASTNode::generate_bytecode() fallible

Instead of crashing on the spot, return a descriptive error that will
eventually continue its days as a javascript "InternalError" exception.
This should make random crashes with BC less likely.
This commit is contained in:
Ali Mohammad Pur 2022-02-12 19:54:08 +03:30 committed by Linus Groh
parent 3a5f7cb524
commit 75aa900b83
10 changed files with 378 additions and 233 deletions

View file

@ -18,13 +18,15 @@
namespace JS {
void ASTNode::generate_bytecode(Bytecode::Generator&) const
Bytecode::CodeGenerationErrorOr<void> ASTNode::generate_bytecode(Bytecode::Generator&) const
{
dbgln("Missing generate_bytecode() in {}", class_name());
TODO();
return Bytecode::CodeGenerationError {
this,
"Missing generate_bytecode()"sv,
};
}
void ScopeNode::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ScopeNode::generate_bytecode(Bytecode::Generator& generator) const
{
// FIXME: This is an ad-hoc fix but should be done as the spec says in
// {Global, Block, Function, Eval}DeclarationInstantiation.
@ -44,28 +46,31 @@ void ScopeNode::generate_bytecode(Bytecode::Generator& generator) const
// FIXME: Register lexical and variable scope declarations
for (auto& child : children()) {
child.generate_bytecode(generator);
TRY(child.generate_bytecode(generator));
if (generator.is_current_block_terminated())
break;
}
return {};
}
void EmptyStatement::generate_bytecode(Bytecode::Generator&) const
Bytecode::CodeGenerationErrorOr<void> EmptyStatement::generate_bytecode(Bytecode::Generator&) const
{
return {};
}
void ExpressionStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ExpressionStatement::generate_bytecode(Bytecode::Generator& generator) const
{
m_expression->generate_bytecode(generator);
return m_expression->generate_bytecode(generator);
}
void BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const
{
m_lhs->generate_bytecode(generator);
TRY(m_lhs->generate_bytecode(generator));
auto lhs_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(lhs_reg);
m_rhs->generate_bytecode(generator);
TRY(m_rhs->generate_bytecode(generator));
switch (m_op) {
case BinaryOp::Addition:
@ -137,11 +142,12 @@ void BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const
default:
VERIFY_NOT_REACHED();
}
return {};
}
void LogicalExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> LogicalExpression::generate_bytecode(Bytecode::Generator& generator) const
{
m_lhs->generate_bytecode(generator);
TRY(m_lhs->generate_bytecode(generator));
// lhs
// jump op (true) end (false) rhs
@ -173,18 +179,19 @@ void LogicalExpression::generate_bytecode(Bytecode::Generator& generator) const
}
generator.switch_to_basic_block(rhs_block);
m_rhs->generate_bytecode(generator);
TRY(m_rhs->generate_bytecode(generator));
generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { end_block },
{});
generator.switch_to_basic_block(end_block);
return {};
}
void UnaryExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> UnaryExpression::generate_bytecode(Bytecode::Generator& generator) const
{
m_lhs->generate_bytecode(generator);
TRY(m_lhs->generate_bytecode(generator));
switch (m_op) {
case UnaryOp::BitwiseNot:
@ -206,59 +213,70 @@ void UnaryExpression::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
break;
default:
TODO();
return Bytecode::CodeGenerationError {
this,
"Unimplemented operation"sv,
};
}
return {};
}
void NumericLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> NumericLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::LoadImmediate>(m_value);
return {};
}
void BooleanLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> BooleanLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::LoadImmediate>(Value(m_value));
return {};
}
void NullLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> NullLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::LoadImmediate>(js_null());
return {};
}
void BigIntLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> BigIntLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::NewBigInt>(Crypto::SignedBigInteger::from_base(10, m_value.substring(0, m_value.length() - 1)));
return {};
}
void StringLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> StringLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::NewString>(generator.intern_string(m_value));
return {};
}
void RegExpLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> RegExpLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
auto source_index = generator.intern_string(m_pattern);
auto flags_index = generator.intern_string(m_flags);
generator.emit<Bytecode::Op::NewRegExp>(source_index, flags_index);
return {};
}
void Identifier::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> Identifier::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::GetVariable>(generator.intern_identifier(m_string));
return {};
}
void AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) const
{
// FIXME: Implement this for BindingPatterns too.
auto& lhs = m_lhs.get<NonnullRefPtr<Expression>>();
if (m_op == AssignmentOp::Assignment) {
m_rhs->generate_bytecode(generator);
generator.emit_store_to_reference(lhs);
return;
TRY(m_rhs->generate_bytecode(generator));
return generator.emit_store_to_reference(lhs);
}
generator.emit_load_from_reference(lhs);
TRY(generator.emit_load_from_reference(lhs));
Bytecode::BasicBlock* rhs_block_ptr { nullptr };
Bytecode::BasicBlock* end_block_ptr { nullptr };
@ -294,7 +312,7 @@ void AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) con
// if the logical assignment condition fails.
auto lhs_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(lhs_reg);
m_rhs->generate_bytecode(generator);
TRY(m_rhs->generate_bytecode(generator));
switch (m_op) {
case AssignmentOp::AdditionAssignment:
@ -338,10 +356,13 @@ void AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) con
case AssignmentOp::NullishAssignment:
break; // These are handled above.
default:
TODO();
return Bytecode::CodeGenerationError {
this,
"Unimplemented operation"sv,
};
}
generator.emit_store_to_reference(lhs);
TRY(generator.emit_store_to_reference(lhs));
if (end_block_ptr) {
generator.emit<Bytecode::Op::Jump>().set_targets(
@ -350,9 +371,11 @@ void AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) con
generator.switch_to_basic_block(*end_block_ptr);
}
return {};
}
void WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
{
// test
// jump if_false (true) end (false) body
@ -374,7 +397,7 @@ void WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
{});
generator.switch_to_basic_block(test_block);
m_test->generate_bytecode(generator);
TRY(m_test->generate_bytecode(generator));
generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { body_block },
Bytecode::Label { end_block });
@ -382,7 +405,7 @@ void WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(body_block);
generator.begin_continuable_scope(Bytecode::Label { test_block });
generator.begin_breakable_scope(Bytecode::Label { end_block });
m_body->generate_bytecode(generator);
TRY(m_body->generate_bytecode(generator));
if (!generator.is_current_block_terminated()) {
generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { test_block },
@ -392,9 +415,11 @@ void WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(end_block);
generator.emit<Bytecode::Op::Load>(result_reg);
}
return {};
}
void DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
{
// jump always (true) body
// test
@ -417,7 +442,7 @@ void DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
{});
generator.switch_to_basic_block(test_block);
m_test->generate_bytecode(generator);
TRY(m_test->generate_bytecode(generator));
generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { body_block },
Bytecode::Label { end_block });
@ -425,7 +450,7 @@ void DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(body_block);
generator.begin_continuable_scope(Bytecode::Label { test_block });
generator.begin_breakable_scope(Bytecode::Label { end_block });
m_body->generate_bytecode(generator);
TRY(m_body->generate_bytecode(generator));
if (!generator.is_current_block_terminated()) {
generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { test_block },
@ -435,9 +460,11 @@ void DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(end_block);
generator.emit<Bytecode::Op::Load>(result_reg);
}
return {};
}
void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ForStatement::generate_bytecode(Bytecode::Generator& generator) const
{
// init
// jump always (true) test
@ -459,7 +486,7 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
auto& end_block = generator.make_block();
if (m_init)
m_init->generate_bytecode(generator);
TRY(m_init->generate_bytecode(generator));
body_block_ptr = &generator.make_block();
@ -483,7 +510,7 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
if (m_test) {
generator.switch_to_basic_block(*test_block_ptr);
m_test->generate_bytecode(generator);
TRY(m_test->generate_bytecode(generator));
generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { *body_block_ptr },
Bytecode::Label { end_block });
@ -492,7 +519,7 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(*body_block_ptr);
generator.begin_continuable_scope(Bytecode::Label { *update_block_ptr });
generator.begin_breakable_scope(Bytecode::Label { end_block });
m_body->generate_bytecode(generator);
TRY(m_body->generate_bytecode(generator));
generator.end_continuable_scope();
if (!generator.is_current_block_terminated()) {
@ -502,7 +529,7 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
{});
generator.switch_to_basic_block(*update_block_ptr);
m_update->generate_bytecode(generator);
TRY(m_update->generate_bytecode(generator));
}
generator.emit<Bytecode::Op::Jump>().set_targets(
@ -513,50 +540,58 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(end_block);
generator.emit<Bytecode::Op::Load>(result_reg);
}
return {};
}
void ObjectExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ObjectExpression::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::NewObject>();
if (m_properties.is_empty())
return;
return {};
auto object_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(object_reg);
for (auto& property : m_properties) {
if (property.type() != ObjectProperty::Type::KeyValue)
TODO();
return Bytecode::CodeGenerationError {
this,
"Unimplemented property kind"sv,
};
if (is<StringLiteral>(property.key())) {
auto& string_literal = static_cast<StringLiteral const&>(property.key());
Bytecode::IdentifierTableIndex key_name = generator.intern_identifier(string_literal.value());
property.value().generate_bytecode(generator);
TRY(property.value().generate_bytecode(generator));
generator.emit<Bytecode::Op::PutById>(object_reg, key_name);
} else {
property.key().generate_bytecode(generator);
TRY(property.key().generate_bytecode(generator));
auto property_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(property_reg);
property.value().generate_bytecode(generator);
TRY(property.value().generate_bytecode(generator));
generator.emit<Bytecode::Op::PutByValue>(object_reg, property_reg);
}
}
generator.emit<Bytecode::Op::Load>(object_reg);
return {};
}
void ArrayExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ArrayExpression::generate_bytecode(Bytecode::Generator& generator) const
{
Vector<Bytecode::Register> element_regs;
for (auto& element : m_elements) {
if (element) {
element->generate_bytecode(generator);
TRY(element->generate_bytecode(generator));
if (is<SpreadExpression>(*element)) {
TODO();
continue;
return Bytecode::CodeGenerationError {
this,
"Unimplemented element kind: SpreadExpression"sv,
};
}
} else {
generator.emit<Bytecode::Op::LoadImmediate>(Value {});
@ -566,25 +601,28 @@ void ArrayExpression::generate_bytecode(Bytecode::Generator& generator) const
element_regs.append(element_reg);
}
generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(element_regs.size(), element_regs);
return {};
}
void MemberExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> MemberExpression::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit_load_from_reference(*this);
return generator.emit_load_from_reference(*this);
}
void FunctionDeclaration::generate_bytecode(Bytecode::Generator&) const
Bytecode::CodeGenerationErrorOr<void> FunctionDeclaration::generate_bytecode(Bytecode::Generator&) const
{
return {};
}
void FunctionExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> FunctionExpression::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::NewFunction>(*this);
return {};
}
static void generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Register const& value_reg);
static Bytecode::CodeGenerationErrorOr<void> generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode, Bytecode::Register const& value_reg);
static void generate_object_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Register const& value_reg)
static Bytecode::CodeGenerationErrorOr<void> generate_object_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg)
{
Vector<Bytecode::Register> excluded_property_names;
auto has_rest = false;
@ -601,9 +639,9 @@ static void generate_object_binding_pattern_bytecode(Bytecode::Generator& genera
auto interned_identifier = generator.intern_identifier(identifier);
generator.emit_with_extra_register_slots<Bytecode::Op::CopyObjectExcludingProperties>(excluded_property_names.size(), value_reg, excluded_property_names);
generator.emit<Bytecode::Op::SetVariable>(interned_identifier);
generator.emit<Bytecode::Op::SetVariable>(interned_identifier, initialization_mode);
return;
return {};
}
Bytecode::StringTableIndex name_index;
@ -623,7 +661,7 @@ static void generate_object_binding_pattern_bytecode(Bytecode::Generator& genera
generator.emit<Bytecode::Op::GetById>(generator.intern_identifier(identifier));
} else {
auto expression = name.get<NonnullRefPtr<Expression>>();
expression->generate_bytecode(generator);
TRY(expression->generate_bytecode(generator));
if (has_rest) {
auto excluded_name_reg = generator.allocate_register();
@ -643,7 +681,7 @@ static void generate_object_binding_pattern_bytecode(Bytecode::Generator& genera
Bytecode::Label { if_not_undefined_block });
generator.switch_to_basic_block(if_undefined_block);
initializer->generate_bytecode(generator);
TRY(initializer->generate_bytecode(generator));
generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { if_not_undefined_block },
{});
@ -655,23 +693,27 @@ static void generate_object_binding_pattern_bytecode(Bytecode::Generator& genera
auto& binding_pattern = *alias.get<NonnullRefPtr<BindingPattern>>();
auto nested_value_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(nested_value_reg);
generate_binding_pattern_bytecode(generator, binding_pattern, nested_value_reg);
TRY(generate_binding_pattern_bytecode(generator, binding_pattern, initialization_mode, nested_value_reg));
} else if (alias.has<Empty>()) {
if (name.has<NonnullRefPtr<Expression>>()) {
// This needs some sort of SetVariableByValue opcode, as it's a runtime binding
TODO();
return Bytecode::CodeGenerationError {
name.get<NonnullRefPtr<Expression>>().ptr(),
"Unimplemented name/alias pair: Empty/Expression"sv,
};
}
auto& identifier = alias.get<NonnullRefPtr<Identifier>>()->string();
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(identifier));
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(identifier), initialization_mode);
} else {
auto& identifier = alias.get<NonnullRefPtr<Identifier>>()->string();
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(identifier));
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(identifier), initialization_mode);
}
}
return {};
}
static void generate_array_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Register const& value_reg)
static Bytecode::CodeGenerationErrorOr<void> generate_array_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg)
{
/*
* Consider the following destructuring assignment:
@ -705,22 +747,27 @@ static void generate_array_binding_pattern_bytecode(Bytecode::Generator& generat
auto temp_iterator_result_reg = generator.allocate_register();
auto assign_accumulator_to_alias = [&](auto& alias) {
alias.visit(
[&](Empty) {
return alias.visit(
[&](Empty) -> Bytecode::CodeGenerationErrorOr<void> {
// This element is an elision
return {};
},
[&](NonnullRefPtr<Identifier> const& identifier) {
[&](NonnullRefPtr<Identifier> const& identifier) -> Bytecode::CodeGenerationErrorOr<void> {
auto interned_index = generator.intern_identifier(identifier->string());
generator.emit<Bytecode::Op::SetVariable>(interned_index);
generator.emit<Bytecode::Op::SetVariable>(interned_index, initialization_mode);
return {};
},
[&](NonnullRefPtr<BindingPattern> const& pattern) {
[&](NonnullRefPtr<BindingPattern> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
// Store the accumulator value in a permanent register
auto target_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(target_reg);
generate_binding_pattern_bytecode(generator, pattern, target_reg);
return generate_binding_pattern_bytecode(generator, pattern, initialization_mode, target_reg);
},
[&](NonnullRefPtr<MemberExpression> const&) {
TODO();
[&](NonnullRefPtr<MemberExpression> const& expr) -> Bytecode::CodeGenerationErrorOr<void> {
return Bytecode::CodeGenerationError {
expr.ptr(),
"Unimplemented alias mode: MemberExpression"sv,
};
});
};
@ -758,9 +805,7 @@ static void generate_array_binding_pattern_bytecode(Bytecode::Generator& generat
generator.switch_to_basic_block(continuation_block);
}
assign_accumulator_to_alias(alias);
return;
return assign_accumulator_to_alias(alias);
}
// In the first iteration of the loop, a few things are true which can save
@ -818,41 +863,48 @@ static void generate_array_binding_pattern_bytecode(Bytecode::Generator& generat
// pattern if necessary.
generator.switch_to_basic_block(create_binding_block);
assign_accumulator_to_alias(alias);
TRY(assign_accumulator_to_alias(alias));
first = false;
}
return {};
}
static void generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Register const& value_reg)
static Bytecode::CodeGenerationErrorOr<void> generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg)
{
if (pattern.kind == BindingPattern::Kind::Object) {
generate_object_binding_pattern_bytecode(generator, pattern, value_reg);
} else {
generate_array_binding_pattern_bytecode(generator, pattern, value_reg);
}
};
if (pattern.kind == BindingPattern::Kind::Object)
return generate_object_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg);
void VariableDeclaration::generate_bytecode(Bytecode::Generator& generator) const
return generate_array_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg);
}
Bytecode::CodeGenerationErrorOr<void> VariableDeclaration::generate_bytecode(Bytecode::Generator& generator) const
{
for (auto& declarator : m_declarations) {
if (declarator.init())
declarator.init()->generate_bytecode(generator);
TRY(declarator.init()->generate_bytecode(generator));
else
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
declarator.target().visit(
[&](NonnullRefPtr<Identifier> const& id) {
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(id->string()));
auto initialization_mode = is_lexical_declaration() ? Bytecode::Op::SetVariable::InitializationMode::Initialize : Bytecode::Op::SetVariable::InitializationMode::Set;
TRY(declarator.target().visit(
[&](NonnullRefPtr<Identifier> const& id) -> Bytecode::CodeGenerationErrorOr<void> {
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(id->string()), initialization_mode);
return {};
},
[&](NonnullRefPtr<BindingPattern> const& pattern) {
[&](NonnullRefPtr<BindingPattern> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
auto value_register = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(value_register);
generate_binding_pattern_bytecode(generator, pattern, value_register);
});
return generate_binding_pattern_bytecode(generator, pattern, initialization_mode, value_register);
}));
}
return {};
}
void CallExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> CallExpression::generate_bytecode(Bytecode::Generator& generator) const
{
auto callee_reg = generator.allocate_register();
auto this_reg = generator.allocate_register();
@ -860,35 +912,41 @@ void CallExpression::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::Store>(this_reg);
if (is<NewExpression>(this)) {
m_callee->generate_bytecode(generator);
TRY(m_callee->generate_bytecode(generator));
generator.emit<Bytecode::Op::Store>(callee_reg);
} else if (is<SuperExpression>(*m_callee)) {
TODO();
return Bytecode::CodeGenerationError {
this,
"Unimplemented callee kind: SuperExpression"sv,
};
} else if (is<MemberExpression>(*m_callee)) {
auto& member_expression = static_cast<const MemberExpression&>(*m_callee);
if (is<SuperExpression>(member_expression.object())) {
TODO();
} else {
member_expression.object().generate_bytecode(generator);
generator.emit<Bytecode::Op::Store>(this_reg);
if (member_expression.is_computed()) {
member_expression.property().generate_bytecode(generator);
generator.emit<Bytecode::Op::GetByValue>(this_reg);
} else {
auto identifier_table_ref = generator.intern_identifier(verify_cast<Identifier>(member_expression.property()).string());
generator.emit<Bytecode::Op::GetById>(identifier_table_ref);
}
generator.emit<Bytecode::Op::Store>(callee_reg);
return Bytecode::CodeGenerationError {
this,
"Unimplemented callee kind: MemberExpression on SuperExpression"sv,
};
}
TRY(member_expression.object().generate_bytecode(generator));
generator.emit<Bytecode::Op::Store>(this_reg);
if (member_expression.is_computed()) {
TRY(member_expression.property().generate_bytecode(generator));
generator.emit<Bytecode::Op::GetByValue>(this_reg);
} else {
auto identifier_table_ref = generator.intern_identifier(verify_cast<Identifier>(member_expression.property()).string());
generator.emit<Bytecode::Op::GetById>(identifier_table_ref);
}
generator.emit<Bytecode::Op::Store>(callee_reg);
} else {
// FIXME: this = global object in sloppy mode.
m_callee->generate_bytecode(generator);
TRY(m_callee->generate_bytecode(generator));
generator.emit<Bytecode::Op::Store>(callee_reg);
}
Vector<Bytecode::Register> argument_registers;
for (auto& arg : m_arguments) {
arg.value->generate_bytecode(generator);
TRY(arg.value->generate_bytecode(generator));
auto arg_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(arg_reg);
argument_registers.append(arg_reg);
@ -902,35 +960,43 @@ void CallExpression::generate_bytecode(Bytecode::Generator& generator) const
}
generator.emit_with_extra_register_slots<Bytecode::Op::Call>(argument_registers.size(), call_type, callee_reg, this_reg, argument_registers);
return {};
}
void ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const
{
if (m_argument)
m_argument->generate_bytecode(generator);
TRY(m_argument->generate_bytecode(generator));
if (generator.is_in_generator_or_async_function())
generator.emit<Bytecode::Op::Yield>(nullptr);
else
generator.emit<Bytecode::Op::Return>();
return {};
}
void YieldExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> YieldExpression::generate_bytecode(Bytecode::Generator& generator) const
{
VERIFY(generator.is_in_generator_function());
if (m_is_yield_from)
TODO();
if (m_is_yield_from) {
return Bytecode::CodeGenerationError {
this,
"Unimplemented form: `yield*`"sv,
};
}
if (m_argument)
m_argument->generate_bytecode(generator);
TRY(m_argument->generate_bytecode(generator));
auto& continuation_block = generator.make_block();
generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
generator.switch_to_basic_block(continuation_block);
return {};
}
void IfStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> IfStatement::generate_bytecode(Bytecode::Generator& generator) const
{
// test
// jump if_true (true) true (false) false
@ -943,7 +1009,7 @@ void IfStatement::generate_bytecode(Bytecode::Generator& generator) const
auto& true_block = generator.make_block();
auto& false_block = generator.make_block();
m_predicate->generate_bytecode(generator);
TRY(m_predicate->generate_bytecode(generator));
generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { true_block },
Bytecode::Label { false_block });
@ -952,7 +1018,7 @@ void IfStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(true_block);
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
m_consequent->generate_bytecode(generator);
TRY(m_consequent->generate_bytecode(generator));
if (!generator.is_current_block_terminated())
true_block_jump = &generator.emit<Bytecode::Op::Jump>();
@ -961,7 +1027,7 @@ void IfStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
if (m_alternate)
m_alternate->generate_bytecode(generator);
TRY(m_alternate->generate_bytecode(generator));
if (!generator.is_current_block_terminated())
generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { end_block }, {});
@ -969,20 +1035,23 @@ void IfStatement::generate_bytecode(Bytecode::Generator& generator) const
true_block_jump->set_targets(Bytecode::Label { end_block }, {});
generator.switch_to_basic_block(end_block);
return {};
}
void ContinueStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ContinueStatement::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::Jump>().set_targets(
generator.nearest_continuable_scope(),
{});
return {};
}
void DebuggerStatement::generate_bytecode(Bytecode::Generator&) const
Bytecode::CodeGenerationErrorOr<void> DebuggerStatement::generate_bytecode(Bytecode::Generator&) const
{
return {};
}
void ConditionalExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ConditionalExpression::generate_bytecode(Bytecode::Generator& generator) const
{
// test
// jump if_true (true) true (false) false
@ -996,38 +1065,41 @@ void ConditionalExpression::generate_bytecode(Bytecode::Generator& generator) co
auto& false_block = generator.make_block();
auto& end_block = generator.make_block();
m_test->generate_bytecode(generator);
TRY(m_test->generate_bytecode(generator));
generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { true_block },
Bytecode::Label { false_block });
generator.switch_to_basic_block(true_block);
m_consequent->generate_bytecode(generator);
TRY(m_consequent->generate_bytecode(generator));
generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { end_block },
{});
generator.switch_to_basic_block(false_block);
m_alternate->generate_bytecode(generator);
TRY(m_alternate->generate_bytecode(generator));
generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { end_block },
{});
generator.switch_to_basic_block(end_block);
return {};
}
void SequenceExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> SequenceExpression::generate_bytecode(Bytecode::Generator& generator) const
{
for (auto& expression : m_expressions)
expression.generate_bytecode(generator);
TRY(expression.generate_bytecode(generator));
return {};
}
void TemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> TemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
auto string_reg = generator.allocate_register();
for (size_t i = 0; i < m_expressions.size(); i++) {
m_expressions[i].generate_bytecode(generator);
TRY(m_expressions[i].generate_bytecode(generator));
if (i == 0) {
generator.emit<Bytecode::Op::Store>(string_reg);
} else {
@ -1036,11 +1108,12 @@ void TemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
}
generator.emit<Bytecode::Op::Load>(string_reg);
return {};
}
void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
{
m_tag->generate_bytecode(generator);
TRY(m_tag->generate_bytecode(generator));
auto tag_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(tag_reg);
@ -1050,7 +1123,7 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
if (i % 2 != 0)
continue;
expressions[i].generate_bytecode(generator);
TRY(expressions[i].generate_bytecode(generator));
auto string_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(string_reg);
string_regs.append(string_reg);
@ -1066,7 +1139,7 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
if (i % 2 == 0)
continue;
expressions[i].generate_bytecode(generator);
TRY(expressions[i].generate_bytecode(generator));
auto string_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(string_reg);
argument_regs.append(string_reg);
@ -1074,7 +1147,7 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
Vector<Bytecode::Register> raw_string_regs;
for (auto& raw_string : m_template_literal->raw_strings()) {
raw_string.generate_bytecode(generator);
TRY(raw_string.generate_bytecode(generator));
auto raw_string_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(raw_string_reg);
raw_string_regs.append(raw_string_reg);
@ -1092,11 +1165,12 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
generator.emit<Bytecode::Op::Store>(this_reg);
generator.emit_with_extra_register_slots<Bytecode::Op::Call>(argument_regs.size(), Bytecode::Op::Call::CallType::Call, tag_reg, this_reg, move(argument_regs));
return {};
}
void UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit_load_from_reference(*m_argument);
TRY(generator.emit_load_from_reference(*m_argument));
Optional<Bytecode::Register> previous_value_for_postfix_reg;
if (!m_prefixed) {
@ -1109,26 +1183,29 @@ void UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const
else
generator.emit<Bytecode::Op::Decrement>();
generator.emit_store_to_reference(*m_argument);
TRY(generator.emit_store_to_reference(*m_argument));
if (!m_prefixed)
generator.emit<Bytecode::Op::Load>(*previous_value_for_postfix_reg);
return {};
}
void ThrowStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ThrowStatement::generate_bytecode(Bytecode::Generator& generator) const
{
m_argument->generate_bytecode(generator);
TRY(m_argument->generate_bytecode(generator));
generator.emit<Bytecode::Op::Throw>();
return {};
}
void BreakStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> BreakStatement::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::Jump>().set_targets(
generator.nearest_breakable_scope(),
{});
return {};
}
void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> TryStatement::generate_bytecode(Bytecode::Generator& generator) const
{
auto& saved_block = generator.current_block();
@ -1140,7 +1217,7 @@ void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
if (m_finalizer) {
auto& finalizer_block = generator.make_block();
generator.switch_to_basic_block(finalizer_block);
m_finalizer->generate_bytecode(generator);
TRY(m_finalizer->generate_bytecode(generator));
if (!generator.is_current_block_terminated()) {
next_block = &generator.make_block();
auto next_target = Bytecode::Label { *next_block };
@ -1152,19 +1229,23 @@ void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
if (m_handler) {
auto& handler_block = generator.make_block();
generator.switch_to_basic_block(handler_block);
m_handler->parameter().visit(
[&](FlyString const& parameter) {
TRY(m_handler->parameter().visit(
[&](FlyString const& parameter) -> Bytecode::CodeGenerationErrorOr<void> {
if (!parameter.is_empty()) {
// FIXME: We need a separate DeclarativeEnvironment here
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(parameter));
}
return {};
},
[&](NonnullRefPtr<BindingPattern> const&) {
[&](NonnullRefPtr<BindingPattern> const&) -> Bytecode::CodeGenerationErrorOr<void> {
// FIXME: Implement this path when the above DeclarativeEnvironment issue is dealt with.
TODO();
});
return Bytecode::CodeGenerationError {
this,
"Unimplemented catch argument: BindingPattern"sv,
};
}));
m_handler->body().generate_bytecode(generator);
TRY(m_handler->body().generate_bytecode(generator));
handler_target = Bytecode::Label { handler_block };
if (!generator.is_current_block_terminated()) {
if (m_finalizer) {
@ -1184,7 +1265,7 @@ void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::EnterUnwindContext>(Bytecode::Label { target_block }, handler_target, finalizer_target);
generator.switch_to_basic_block(target_block);
m_block->generate_bytecode(generator);
TRY(m_block->generate_bytecode(generator));
if (!generator.is_current_block_terminated()) {
if (m_finalizer) {
generator.emit<Bytecode::Op::Jump>(finalizer_target);
@ -1196,12 +1277,13 @@ void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
}
generator.switch_to_basic_block(next_block ? *next_block : saved_block);
return {};
}
void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
{
auto discriminant_reg = generator.allocate_register();
m_discriminant->generate_bytecode(generator);
TRY(m_discriminant->generate_bytecode(generator));
generator.emit<Bytecode::Op::Store>(discriminant_reg);
Vector<Bytecode::BasicBlock&> case_blocks;
Bytecode::BasicBlock* default_block { nullptr };
@ -1211,7 +1293,7 @@ void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
auto& case_block = generator.make_block();
if (switch_case.test()) {
generator.switch_to_basic_block(*next_test_block);
switch_case.test()->generate_bytecode(generator);
TRY(switch_case.test()->generate_bytecode(generator));
generator.emit<Bytecode::Op::StrictlyEquals>(discriminant_reg);
next_test_block = &generator.make_block();
generator.emit<Bytecode::Op::JumpConditional>().set_targets(Bytecode::Label { case_block }, Bytecode::Label { *next_test_block });
@ -1236,7 +1318,7 @@ void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
for (auto& statement : switch_case.children()) {
statement.generate_bytecode(generator);
TRY(statement.generate_bytecode(generator));
}
if (!generator.is_current_block_terminated()) {
auto next_block = current_block;
@ -1252,6 +1334,7 @@ void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.end_breakable_scope();
generator.switch_to_basic_block(end_block);
return {};
}
void ClassDeclaration::generate_bytecode(Bytecode::Generator& generator) const
@ -1260,21 +1343,23 @@ void ClassDeclaration::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(m_class_expression.ptr()->name()));
}
void ThisExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> ThisExpression::generate_bytecode(Bytecode::Generator& generator) const
{
generator.emit<Bytecode::Op::ResolveThisBinding>();
return {};
}
void AwaitExpression::generate_bytecode(Bytecode::Generator& generator) const
Bytecode::CodeGenerationErrorOr<void> AwaitExpression::generate_bytecode(Bytecode::Generator& generator) const
{
VERIFY(generator.is_in_async_function());
// Transform `await expr` to `yield expr`
m_argument->generate_bytecode(generator);
TRY(m_argument->generate_bytecode(generator));
auto& continuation_block = generator.make_block();
generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
generator.switch_to_basic_block(continuation_block);
return {};
}
}