LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-11 13:36:13 +03:00
Code Issues Packages Projects Releases Wiki Activity

LibJS: Make ASTNode::generate_bytecode() fallible

Browse Source 
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
Notes: sideshowbarker 2024-07-17 18:55:17 +09:00 
Author: https://github.com/alimpfard
Commit: https://github.com/SerenityOS/serenity/commit/75aa900b83
Pull-request: https://github.com/SerenityOS/serenity/pull/12468
Reviewed-by: https://github.com/linusg ✅
10 changed files with 378 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Tests/LibJS/test-bytecode-js.cpp
View File

@ -22,9 +22,9 @@
auto const& program = script->parse_node(); \
JS::Bytecode::Interpreter bytecode_interpreter(ast_interpreter->global_object(), ast_interpreter->realm());
#define EXPECT_NO_EXCEPTION(executable) \
auto executable = JS::Bytecode::Generator::generate(program); \
auto result = bytecode_interpreter.run(*executable); \
#define EXPECT_NO_EXCEPTION(executable) \
auto executable = MUST(JS::Bytecode::Generator::generate(program)); \
auto result = bytecode_interpreter.run(*executable); \
EXPECT(!result.is_error());
#define EXPECT_NO_EXCEPTION_WITH_OPTIMIZATIONS(executable) \
@ -54,7 +54,7 @@ TEST_CASE(if_statement_fail)
{
SETUP_AND_PARSE("if (true) throw new Exception('failed');");
auto executable = JS::Bytecode::Generator::generate(program);
auto executable = MUST(JS::Bytecode::Generator::generate(program));
auto result = bytecode_interpreter.run(*executable);
EXPECT(result.is_error());
}
@ -112,7 +112,7 @@ TEST_CASE(loading_multiple_files)
auto test_file_script = test_file_script_or_error.release_value();
auto const& test_file_program = test_file_script->parse_node();
auto executable = JS::Bytecode::Generator::generate(test_file_program);
auto executable = MUST(JS::Bytecode::Generator::generate(test_file_program));
auto result = bytecode_interpreter.run(*executable);
EXPECT(!result.is_error());
}

85
Userland/Libraries/LibJS/AST.h
View File

@ -16,6 +16,7 @@
#include <AK/String.h>
#include <AK/Variant.h>
#include <AK/Vector.h>
#include <LibJS/Bytecode/CodeGenerationError.h>
#include <LibJS/Forward.h>
#include <LibJS/Heap/Handle.h>
#include <LibJS/Runtime/Completion.h>
@ -47,7 +48,7 @@ class ASTNode : public RefCounted<ASTNode> {
public:
virtual ~ASTNode() { }
virtual Completion execute(Interpreter&, GlobalObject&) const = 0;
virtual void generate_bytecode(Bytecode::Generator&) const;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const;
virtual void dump(int indent) const;
SourceRange const& source_range() const { return m_source_range; }
@ -151,7 +152,7 @@ public:
{
}
Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
};
class ErrorStatement final : public Statement {
@ -173,7 +174,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
Expression const& expression() const { return m_expression; };
@ -227,7 +228,7 @@ public:
NonnullRefPtrVector<Statement> const& children() const { return m_children; }
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
Completion evaluate_statements(Interpreter& interpreter, GlobalObject& global_object) const;
@ -665,7 +666,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
virtual ThrowCompletionOr<void> for_each_bound_name(ThrowCompletionOrVoidCallback<FlyString const&>&& callback) const override;
@ -692,7 +693,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
bool has_name() const { return !name().is_empty(); }
@ -726,7 +727,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
RefPtr<Expression> m_argument;
@ -743,7 +744,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> m_argument;
@ -761,7 +762,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
RefPtr<Expression> m_argument;
@ -783,7 +784,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> m_predicate;
@ -806,7 +807,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual Completion loop_evaluation(Interpreter&, GlobalObject&, Vector<FlyString> const&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> m_test;
@ -828,7 +829,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual Completion loop_evaluation(Interpreter&, GlobalObject&, Vector<FlyString> const&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> m_test;
@ -874,7 +875,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual Completion loop_evaluation(Interpreter&, GlobalObject&, Vector<FlyString> const&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
RefPtr<ASTNode> m_init;
@ -988,7 +989,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
BinaryOp m_op;
@ -1014,7 +1015,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
LogicalOp m_op;
@ -1043,7 +1044,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
UnaryOp m_op;
@ -1061,7 +1062,7 @@ public:
virtual void dump(int indent) const override;
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtrVector<Expression> m_expressions;
@ -1085,7 +1086,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
bool m_value { false };
@ -1101,7 +1102,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
Value m_value;
@ -1117,7 +1118,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
String m_value;
@ -1134,7 +1135,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
StringView value() const { return m_value; }
bool is_use_strict_directive() const { return m_is_use_strict_directive; };
@ -1155,7 +1156,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
};
class RegExpLiteral final : public Literal {
@ -1172,7 +1173,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
regex::Parser::Result const& parsed_regex() const { return m_parsed_regex; }
String const& parsed_pattern() const { return m_parsed_pattern; }
@ -1202,7 +1203,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual ThrowCompletionOr<Reference> to_reference(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
virtual bool is_identifier() const override { return true; }
@ -1397,7 +1398,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
virtual ThrowCompletionOr<void> for_each_bound_name(ThrowCompletionOrVoidCallback<FlyString const&>&& callback) const override;
@ -1436,7 +1437,7 @@ public:
}
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
};
class CallExpression : public Expression {
@ -1455,7 +1456,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
Expression const& callee() const { return m_callee; }
@ -1541,7 +1542,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
AssignmentOp m_op;
@ -1566,7 +1567,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
virtual bool is_update_expression() const override { return true; }
@ -1628,7 +1629,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
NonnullRefPtrVector<VariableDeclarator> const& declarations() const { return m_declarations; }
@ -1694,7 +1695,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
Optional<SourceRange> const& invalid_property_range() const { return m_first_invalid_property_range; }
@ -1717,7 +1718,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
virtual bool is_array_expression() const override { return true; }
@ -1742,7 +1743,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
NonnullRefPtrVector<Expression> const& expressions() const { return m_expressions; }
NonnullRefPtrVector<Expression> const& raw_strings() const { return m_raw_strings; }
@ -1763,7 +1764,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> const m_tag;
@ -1783,7 +1784,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void dump(int indent) const override;
virtual ThrowCompletionOr<Reference> to_reference(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
bool is_computed() const { return m_computed; }
Expression const& object() const { return *m_object; }
@ -1900,7 +1901,7 @@ public:
virtual void dump(int indent) const override;
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> m_test;
@ -1951,7 +1952,7 @@ public:
virtual void dump(int indent) const override;
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<BlockStatement> m_block;
@ -1971,7 +1972,7 @@ public:
virtual void dump(int indent) const override;
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
NonnullRefPtr<Expression> m_argument;
@ -2004,7 +2005,7 @@ public:
virtual void dump(int indent) const override;
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
Completion execute_impl(Interpreter&, GlobalObject&) const;
void add_case(NonnullRefPtr<SwitchCase> switch_case) { m_cases.append(move(switch_case)); }
@ -2025,7 +2026,7 @@ public:
virtual Completion execute(Interpreter&, GlobalObject&) const override;
FlyString const& target_label() const { return m_target_label; }
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
private:
FlyString m_target_label;
@ -2040,7 +2041,7 @@ public:
}
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
FlyString const& target_label() const { return m_target_label; }
@ -2056,7 +2057,7 @@ public:
}
virtual Completion execute(Interpreter&, GlobalObject&) const override;
virtual void generate_bytecode(Bytecode::Generator&) const override;
virtual Bytecode::CodeGenerationErrorOr<void> generate_bytecode(Bytecode::Generator&) const override;
};
class SyntheticReferenceExpression final : public Expression {

403
Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp
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 {};
}
}

25
Userland/Libraries/LibJS/Bytecode/CodeGenerationError.h Normal file
View File

@ -0,0 +1,25 @@
/*
* Copyright (c) 2022, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Error.h>
#include <AK/StringView.h>
#include <LibJS/Forward.h>
namespace JS::Bytecode {
struct CodeGenerationError {
ASTNode const* failing_node { nullptr };
StringView reason_literal;
String to_string();
};
template<typename T>
using CodeGenerationErrorOr = ErrorOr<T, CodeGenerationError>;
}

44
Userland/Libraries/LibJS/Bytecode/Generator.cpp
View File

@ -23,7 +23,7 @@ Generator::~Generator()
{
}
NonnullOwnPtr<Executable> Generator::generate(ASTNode const& node, FunctionKind enclosing_function_kind)
CodeGenerationErrorOr<NonnullOwnPtr<Executable>> Generator::generate(ASTNode const& node, FunctionKind enclosing_function_kind)
{
Generator generator;
generator.switch_to_basic_block(generator.make_block());
@ -34,7 +34,7 @@ NonnullOwnPtr<Executable> Generator::generate(ASTNode const& node, FunctionKind
generator.emit<Bytecode::Op::Yield>(Label { start_block });
generator.switch_to_basic_block(start_block);
}
node.generate_bytecode(generator);
TRY(node.generate_bytecode(generator));
if (generator.is_in_generator_or_async_function()) {
// Terminate all unterminated blocks with yield return
for (auto& block : generator.m_root_basic_blocks) {
@ -99,38 +99,43 @@ void Generator::end_breakable_scope()
m_breakable_scopes.take_last();
}
void Generator::emit_load_from_reference(JS::ASTNode const& node)
CodeGenerationErrorOr<void> Generator::emit_load_from_reference(JS::ASTNode const& node)
{
if (is<Identifier>(node)) {
auto& identifier = static_cast<Identifier const&>(node);
emit<Bytecode::Op::GetVariable>(intern_identifier(identifier.string()));
return;
return {};
}
if (is<MemberExpression>(node)) {
auto& expression = static_cast<MemberExpression const&>(node);
expression.object().generate_bytecode(*this);
TRY(expression.object().generate_bytecode(*this));
auto object_reg = allocate_register();
emit<Bytecode::Op::Store>(object_reg);
if (expression.is_computed()) {
expression.property().generate_bytecode(*this);
TRY(expression.property().generate_bytecode(*this));
emit<Bytecode::Op::GetByValue>(object_reg);
} else {
} else if (expression.property().is_identifier()) {
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
emit<Bytecode::Op::GetById>(identifier_table_ref);
} else {
return CodeGenerationError {
&expression,
"Unimplemented non-computed member expression"sv
};
}
return;
return {};
}
VERIFY_NOT_REACHED();
}
void Generator::emit_store_to_reference(JS::ASTNode const& node)
CodeGenerationErrorOr<void> Generator::emit_store_to_reference(JS::ASTNode const& node)
{
if (is<Identifier>(node)) {
auto& identifier = static_cast<Identifier const&>(node);
emit<Bytecode::Op::SetVariable>(intern_identifier(identifier.string()));
return;
return {};
}
if (is<MemberExpression>(node)) {
// NOTE: The value is in the accumulator, so we have to store that away first.
@ -138,25 +143,36 @@ void Generator::emit_store_to_reference(JS::ASTNode const& node)
emit<Bytecode::Op::Store>(value_reg);
auto& expression = static_cast<MemberExpression const&>(node);
expression.object().generate_bytecode(*this);
TRY(expression.object().generate_bytecode(*this));
auto object_reg = allocate_register();
emit<Bytecode::Op::Store>(object_reg);
if (expression.is_computed()) {
expression.property().generate_bytecode(*this);
TRY(expression.property().generate_bytecode(*this));
auto property_reg = allocate_register();
emit<Bytecode::Op::Store>(property_reg);
emit<Bytecode::Op::Load>(value_reg);
emit<Bytecode::Op::PutByValue>(object_reg, property_reg);
} else {
} else if (expression.property().is_identifier()) {
emit<Bytecode::Op::Load>(value_reg);
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
emit<Bytecode::Op::PutById>(object_reg, identifier_table_ref);
} else {
return CodeGenerationError {
&expression,
"Unimplemented non-computed member expression"sv
};
}
return;
return {};
}
VERIFY_NOT_REACHED();
}
String CodeGenerationError::to_string()
{
return String::formatted("CodeGenerationError in {}: {}", failing_node ? failing_node->class_name() : "<unknown node>", reason_literal);
}
}

7
Userland/Libraries/LibJS/Bytecode/Generator.h
View File

@ -10,6 +10,7 @@
#include <AK/OwnPtr.h>
#include <AK/SinglyLinkedList.h>
#include <LibJS/Bytecode/BasicBlock.h>
#include <LibJS/Bytecode/CodeGenerationError.h>
#include <LibJS/Bytecode/Executable.h>
#include <LibJS/Bytecode/IdentifierTable.h>
#include <LibJS/Bytecode/Label.h>
@ -23,7 +24,7 @@ namespace JS::Bytecode {
class Generator {
public:
static NonnullOwnPtr<Executable> generate(ASTNode const&, FunctionKind = FunctionKind::Normal);
static CodeGenerationErrorOr<NonnullOwnPtr<Executable>> generate(ASTNode const&, FunctionKind = FunctionKind::Normal);
Register allocate_register();
@ -71,8 +72,8 @@ public:
return *static_cast<OpType*>(slot);
}
void emit_load_from_reference(JS::ASTNode const&);
void emit_store_to_reference(JS::ASTNode const&);
CodeGenerationErrorOr<void> emit_load_from_reference(JS::ASTNode const&);
CodeGenerationErrorOr<void> emit_store_to_reference(JS::ASTNode const&);
void begin_continuable_scope(Label continue_target);
void end_continuable_scope();

6
Userland/Libraries/LibJS/Runtime/AbstractOperations.cpp
View File

@ -579,7 +579,11 @@ ThrowCompletionOr<Value> perform_eval(Value x, GlobalObject& caller_realm, Calle
Optional<Value> eval_result;
if (auto* bytecode_interpreter = Bytecode::Interpreter::current()) {
auto executable = JS::Bytecode::Generator::generate(program);
auto executable_result = JS::Bytecode::Generator::generate(program);
if (executable_result.is_error())
return vm.throw_completion<InternalError>(bytecode_interpreter->global_object(), ErrorType::NotImplemented, executable_result.error().to_string());
auto executable = executable_result.release_value();
executable->name = "eval"sv;
if (JS::Bytecode::g_dump_bytecode)
executable->dump();

6
Userland/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
View File

@ -767,7 +767,11 @@ Completion ECMAScriptFunctionObject::ordinary_call_evaluate_body()
// FIXME: pass something to evaluate default arguments with
TRY(function_declaration_instantiation(nullptr));
if (!m_bytecode_executable) {
m_bytecode_executable = Bytecode::Generator::generate(m_ecmascript_code, m_kind);
auto executable_result = JS::Bytecode::Generator::generate(m_ecmascript_code, m_kind);
if (executable_result.is_error())
return vm.throw_completion<InternalError>(bytecode_interpreter->global_object(), ErrorType::NotImplemented, executable_result.error().to_string());
m_bytecode_executable = executable_result.release_value();
m_bytecode_executable->name = m_name;
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
passes.perform(*m_bytecode_executable);

17
Userland/Libraries/LibTest/JavaScriptTestRunner.h
View File

@ -346,7 +346,7 @@ inline JSFileResult TestRunner::run_file_test(const String& test_path)
auto test_script = result.release_value();
if (g_run_bytecode) {
auto executable = JS::Bytecode::Generator::generate(test_script->parse_node());
auto executable = MUST(JS::Bytecode::Generator::generate(test_script->parse_node()));
executable->name = test_path;
if (JS::Bytecode::g_dump_bytecode)
executable->dump();
@ -362,12 +362,15 @@ inline JSFileResult TestRunner::run_file_test(const String& test_path)
if (file_script.is_error())
return { test_path, file_script.error() };
if (g_run_bytecode) {
auto executable = JS::Bytecode::Generator::generate(file_script.value()->parse_node());
executable->name = test_path;
if (JS::Bytecode::g_dump_bytecode)
executable->dump();
JS::Bytecode::Interpreter bytecode_interpreter(interpreter->global_object(), interpreter->realm());
(void)bytecode_interpreter.run(*executable);
auto executable_result = JS::Bytecode::Generator::generate(file_script.value()->parse_node());
if (!executable_result.is_error()) {
auto executable = executable_result.release_value();
executable->name = test_path;
if (JS::Bytecode::g_dump_bytecode)
executable->dump();
JS::Bytecode::Interpreter bytecode_interpreter(interpreter->global_object(), interpreter->realm());
(void)bytecode_interpreter.run(*executable);
}
} else {
g_vm->push_execution_context(global_execution_context, interpreter->global_object());
(void)interpreter->run(file_script.value());

8
Userland/Utilities/js.cpp
View File

@ -1024,7 +1024,13 @@ static bool parse_and_run(JS::Interpreter& interpreter, StringView source, Strin
script_or_module->parse_node().dump(0);
if (JS::Bytecode::g_dump_bytecode || s_run_bytecode) {
auto executable = JS::Bytecode::Generator::generate(script_or_module->parse_node());
auto executable_result = JS::Bytecode::Generator::generate(script_or_module->parse_node());
if (executable_result.is_error()) {
result = vm->throw_completion<JS::InternalError>(interpreter.global_object(), executable_result.error().to_string());
return ReturnEarly::No;
}
auto executable = executable_result.release_value();
executable->name = source_name;
if (s_opt_bytecode) {
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();