RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 14:47:35 +00:00
Code Issues Activity Actions

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
10 changed files with 378 additions and 233 deletions
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(); \ auto const& program = script->parse_node(); \
JS::Bytecode::Interpreter bytecode_interpreter(ast_interpreter->global_object(), ast_interpreter->realm()); JS::Bytecode::Interpreter bytecode_interpreter(ast_interpreter->global_object(), ast_interpreter->realm());
#define EXPECT_NO_EXCEPTION(executable) \ #define EXPECT_NO_EXCEPTION(executable) \
auto executable = JS::Bytecode::Generator::generate(program); \ auto executable = MUST(JS::Bytecode::Generator::generate(program)); \
auto result = bytecode_interpreter.run(*executable); \ auto result = bytecode_interpreter.run(*executable); \
EXPECT(!result.is_error()); EXPECT(!result.is_error());
#define EXPECT_NO_EXCEPTION_WITH_OPTIMIZATIONS(executable) \ #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');"); 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); auto result = bytecode_interpreter.run(*executable);
EXPECT(result.is_error()); 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 test_file_script = test_file_script_or_error.release_value();
auto const& test_file_program = test_file_script->parse_node(); 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); auto result = bytecode_interpreter.run(*executable);
EXPECT(!result.is_error()); EXPECT(!result.is_error());
} }

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

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

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

@ -18,13 +18,15 @@
namespace JS { 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()); return Bytecode::CodeGenerationError {
TODO(); 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 // FIXME: This is an ad-hoc fix but should be done as the spec says in
// {Global, Block, Function, Eval}DeclarationInstantiation. // {Global, Block, Function, Eval}DeclarationInstantiation.
@ -44,28 +46,31 @@ void ScopeNode::generate_bytecode(Bytecode::Generator& generator) const
// FIXME: Register lexical and variable scope declarations // FIXME: Register lexical and variable scope declarations
for (auto& child : children()) { for (auto& child : children()) {
child.generate_bytecode(generator); TRY(child.generate_bytecode(generator));
if (generator.is_current_block_terminated()) if (generator.is_current_block_terminated())
break; 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(); auto lhs_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(lhs_reg); generator.emit<Bytecode::Op::Store>(lhs_reg);
m_rhs->generate_bytecode(generator); TRY(m_rhs->generate_bytecode(generator));
switch (m_op) { switch (m_op) {
case BinaryOp::Addition: case BinaryOp::Addition:
@ -137,11 +142,12 @@ void BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const
default: default:
VERIFY_NOT_REACHED(); 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 // lhs
// jump op (true) end (false) rhs // 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); 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( generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { end_block }, Bytecode::Label { end_block },
{}); {});
generator.switch_to_basic_block(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) { switch (m_op) {
case UnaryOp::BitwiseNot: case UnaryOp::BitwiseNot:
@ -206,59 +213,70 @@ void UnaryExpression::generate_bytecode(Bytecode::Generator& generator) const
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined()); generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
break; break;
default: 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); 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)); 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()); 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))); 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)); 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 source_index = generator.intern_string(m_pattern);
auto flags_index = generator.intern_string(m_flags); auto flags_index = generator.intern_string(m_flags);
generator.emit<Bytecode::Op::NewRegExp>(source_index, flags_index); 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)); 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. // FIXME: Implement this for BindingPatterns too.
auto& lhs = m_lhs.get<NonnullRefPtr<Expression>>(); auto& lhs = m_lhs.get<NonnullRefPtr<Expression>>();
if (m_op == AssignmentOp::Assignment) { if (m_op == AssignmentOp::Assignment) {
m_rhs->generate_bytecode(generator); TRY(m_rhs->generate_bytecode(generator));
generator.emit_store_to_reference(lhs); return generator.emit_store_to_reference(lhs);
return;
} }
generator.emit_load_from_reference(lhs); TRY(generator.emit_load_from_reference(lhs));
Bytecode::BasicBlock* rhs_block_ptr { nullptr }; Bytecode::BasicBlock* rhs_block_ptr { nullptr };
Bytecode::BasicBlock* end_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. // if the logical assignment condition fails.
auto lhs_reg = generator.allocate_register(); auto lhs_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(lhs_reg); generator.emit<Bytecode::Op::Store>(lhs_reg);
m_rhs->generate_bytecode(generator); TRY(m_rhs->generate_bytecode(generator));
switch (m_op) { switch (m_op) {
case AssignmentOp::AdditionAssignment: case AssignmentOp::AdditionAssignment:
@ -338,10 +356,13 @@ void AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) con
case AssignmentOp::NullishAssignment: case AssignmentOp::NullishAssignment:
break; // These are handled above. break; // These are handled above.
default: 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) { if (end_block_ptr) {
generator.emit<Bytecode::Op::Jump>().set_targets( 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); 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 // test
// jump if_false (true) end (false) body // 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); 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( generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { body_block }, Bytecode::Label { body_block },
Bytecode::Label { end_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.switch_to_basic_block(body_block);
generator.begin_continuable_scope(Bytecode::Label { test_block }); generator.begin_continuable_scope(Bytecode::Label { test_block });
generator.begin_breakable_scope(Bytecode::Label { end_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()) { if (!generator.is_current_block_terminated()) {
generator.emit<Bytecode::Op::Jump>().set_targets( generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { test_block }, Bytecode::Label { test_block },
@ -392,9 +415,11 @@ void WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(end_block); generator.switch_to_basic_block(end_block);
generator.emit<Bytecode::Op::Load>(result_reg); 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 // jump always (true) body
// test // test
@ -417,7 +442,7 @@ void DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
{}); {});
generator.switch_to_basic_block(test_block); 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( generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { body_block }, Bytecode::Label { body_block },
Bytecode::Label { end_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.switch_to_basic_block(body_block);
generator.begin_continuable_scope(Bytecode::Label { test_block }); generator.begin_continuable_scope(Bytecode::Label { test_block });
generator.begin_breakable_scope(Bytecode::Label { end_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()) { if (!generator.is_current_block_terminated()) {
generator.emit<Bytecode::Op::Jump>().set_targets( generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { test_block }, Bytecode::Label { test_block },
@ -435,9 +460,11 @@ void DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.switch_to_basic_block(end_block); generator.switch_to_basic_block(end_block);
generator.emit<Bytecode::Op::Load>(result_reg); 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 // init
// jump always (true) test // jump always (true) test
@ -459,7 +486,7 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
auto& end_block = generator.make_block(); auto& end_block = generator.make_block();
if (m_init) if (m_init)
m_init->generate_bytecode(generator); TRY(m_init->generate_bytecode(generator));
body_block_ptr = &generator.make_block(); body_block_ptr = &generator.make_block();
@ -483,7 +510,7 @@ void ForStatement::generate_bytecode(Bytecode::Generator& generator) const
if (m_test) { if (m_test) {
generator.switch_to_basic_block(*test_block_ptr); 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( generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { *body_block_ptr }, Bytecode::Label { *body_block_ptr },
Bytecode::Label { end_block }); 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.switch_to_basic_block(*body_block_ptr);
generator.begin_continuable_scope(Bytecode::Label { *update_block_ptr }); generator.begin_continuable_scope(Bytecode::Label { *update_block_ptr });
generator.begin_breakable_scope(Bytecode::Label { end_block }); generator.begin_breakable_scope(Bytecode::Label { end_block });
m_body->generate_bytecode(generator); TRY(m_body->generate_bytecode(generator));
generator.end_continuable_scope(); generator.end_continuable_scope();
if (!generator.is_current_block_terminated()) { 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); 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( 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.switch_to_basic_block(end_block);
generator.emit<Bytecode::Op::Load>(result_reg); 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>(); generator.emit<Bytecode::Op::NewObject>();
if (m_properties.is_empty()) if (m_properties.is_empty())
return; return {};
auto object_reg = generator.allocate_register(); auto object_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(object_reg); generator.emit<Bytecode::Op::Store>(object_reg);
for (auto& property : m_properties) { for (auto& property : m_properties) {
if (property.type() != ObjectProperty::Type::KeyValue) if (property.type() != ObjectProperty::Type::KeyValue)
TODO(); return Bytecode::CodeGenerationError {
this,
"Unimplemented property kind"sv,
};
if (is<StringLiteral>(property.key())) { if (is<StringLiteral>(property.key())) {
auto& string_literal = static_cast<StringLiteral const&>(property.key()); auto& string_literal = static_cast<StringLiteral const&>(property.key());
Bytecode::IdentifierTableIndex key_name = generator.intern_identifier(string_literal.value()); 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); generator.emit<Bytecode::Op::PutById>(object_reg, key_name);
} else { } else {
property.key().generate_bytecode(generator); TRY(property.key().generate_bytecode(generator));
auto property_reg = generator.allocate_register(); auto property_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(property_reg); 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::PutByValue>(object_reg, property_reg);
} }
} }
generator.emit<Bytecode::Op::Load>(object_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; Vector<Bytecode::Register> element_regs;
for (auto& element : m_elements) { for (auto& element : m_elements) {
if (element) { if (element) {
element->generate_bytecode(generator); TRY(element->generate_bytecode(generator));
if (is<SpreadExpression>(*element)) { if (is<SpreadExpression>(*element)) {
TODO(); return Bytecode::CodeGenerationError {
continue; this,
"Unimplemented element kind: SpreadExpression"sv,
};
} }
} else { } else {
generator.emit<Bytecode::Op::LoadImmediate>(Value {}); generator.emit<Bytecode::Op::LoadImmediate>(Value {});
@ -566,25 +601,28 @@ void ArrayExpression::generate_bytecode(Bytecode::Generator& generator) const
element_regs.append(element_reg); element_regs.append(element_reg);
} }
generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(element_regs.size(), element_regs); 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); 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; Vector<Bytecode::Register> excluded_property_names;
auto has_rest = false; 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); 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_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; 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)); generator.emit<Bytecode::Op::GetById>(generator.intern_identifier(identifier));
} else { } else {
auto expression = name.get<NonnullRefPtr<Expression>>(); auto expression = name.get<NonnullRefPtr<Expression>>();
expression->generate_bytecode(generator); TRY(expression->generate_bytecode(generator));
if (has_rest) { if (has_rest) {
auto excluded_name_reg = generator.allocate_register(); 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 }); Bytecode::Label { if_not_undefined_block });
generator.switch_to_basic_block(if_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( generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { if_not_undefined_block }, 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& binding_pattern = *alias.get<NonnullRefPtr<BindingPattern>>();
auto nested_value_reg = generator.allocate_register(); auto nested_value_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(nested_value_reg); 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>()) { } else if (alias.has<Empty>()) {
if (name.has<NonnullRefPtr<Expression>>()) { if (name.has<NonnullRefPtr<Expression>>()) {
// This needs some sort of SetVariableByValue opcode, as it's a runtime binding // 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(); 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 { } else {
auto& identifier = alias.get<NonnullRefPtr<Identifier>>()->string(); 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: * 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 temp_iterator_result_reg = generator.allocate_register();
auto assign_accumulator_to_alias = [&](auto& alias) { auto assign_accumulator_to_alias = [&](auto& alias) {
alias.visit( return alias.visit(
[&](Empty) { [&](Empty) -> Bytecode::CodeGenerationErrorOr<void> {
// This element is an elision // 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()); 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 // Store the accumulator value in a permanent register
auto target_reg = generator.allocate_register(); auto target_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(target_reg); 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&) { [&](NonnullRefPtr<MemberExpression> const& expr) -> Bytecode::CodeGenerationErrorOr<void> {
TODO(); 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); generator.switch_to_basic_block(continuation_block);
} }
assign_accumulator_to_alias(alias); return assign_accumulator_to_alias(alias);
return;
} }
// In the first iteration of the loop, a few things are true which can save // 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. // pattern if necessary.
generator.switch_to_basic_block(create_binding_block); generator.switch_to_basic_block(create_binding_block);
assign_accumulator_to_alias(alias); TRY(assign_accumulator_to_alias(alias));
first = false; 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) { if (pattern.kind == BindingPattern::Kind::Object)
generate_object_binding_pattern_bytecode(generator, pattern, value_reg); return generate_object_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg);
} else {
generate_array_binding_pattern_bytecode(generator, pattern, 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) { for (auto& declarator : m_declarations) {
if (declarator.init()) if (declarator.init())
declarator.init()->generate_bytecode(generator); TRY(declarator.init()->generate_bytecode(generator));
else else
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined()); generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
declarator.target().visit(
[&](NonnullRefPtr<Identifier> const& id) { auto initialization_mode = is_lexical_declaration() ? Bytecode::Op::SetVariable::InitializationMode::Initialize : Bytecode::Op::SetVariable::InitializationMode::Set;
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(id->string()));
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(); auto value_register = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(value_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 callee_reg = generator.allocate_register();
auto this_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); generator.emit<Bytecode::Op::Store>(this_reg);
if (is<NewExpression>(this)) { if (is<NewExpression>(this)) {
m_callee->generate_bytecode(generator); TRY(m_callee->generate_bytecode(generator));
generator.emit<Bytecode::Op::Store>(callee_reg); generator.emit<Bytecode::Op::Store>(callee_reg);
} else if (is<SuperExpression>(*m_callee)) { } else if (is<SuperExpression>(*m_callee)) {
TODO(); return Bytecode::CodeGenerationError {
this,
"Unimplemented callee kind: SuperExpression"sv,
};
} else if (is<MemberExpression>(*m_callee)) { } else if (is<MemberExpression>(*m_callee)) {
auto& member_expression = static_cast<const MemberExpression&>(*m_callee); auto& member_expression = static_cast<const MemberExpression&>(*m_callee);
if (is<SuperExpression>(member_expression.object())) { if (is<SuperExpression>(member_expression.object())) {
TODO(); return Bytecode::CodeGenerationError {
} else { this,
member_expression.object().generate_bytecode(generator); "Unimplemented callee kind: MemberExpression on SuperExpression"sv,
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);
} }
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 { } else {
// FIXME: this = global object in sloppy mode. // 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); generator.emit<Bytecode::Op::Store>(callee_reg);
} }
Vector<Bytecode::Register> argument_registers; Vector<Bytecode::Register> argument_registers;
for (auto& arg : m_arguments) { for (auto& arg : m_arguments) {
arg.value->generate_bytecode(generator); TRY(arg.value->generate_bytecode(generator));
auto arg_reg = generator.allocate_register(); auto arg_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(arg_reg); generator.emit<Bytecode::Op::Store>(arg_reg);
argument_registers.append(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); 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) if (m_argument)
m_argument->generate_bytecode(generator); TRY(m_argument->generate_bytecode(generator));
if (generator.is_in_generator_or_async_function()) if (generator.is_in_generator_or_async_function())
generator.emit<Bytecode::Op::Yield>(nullptr); generator.emit<Bytecode::Op::Yield>(nullptr);
else else
generator.emit<Bytecode::Op::Return>(); 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()); VERIFY(generator.is_in_generator_function());
if (m_is_yield_from) if (m_is_yield_from) {
TODO(); return Bytecode::CodeGenerationError {
this,
"Unimplemented form: `yield*`"sv,
};
}
if (m_argument) if (m_argument)
m_argument->generate_bytecode(generator); TRY(m_argument->generate_bytecode(generator));
auto& continuation_block = generator.make_block(); auto& continuation_block = generator.make_block();
generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block }); generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
generator.switch_to_basic_block(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 // test
// jump if_true (true) true (false) false // 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& true_block = generator.make_block();
auto& false_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( generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { true_block }, Bytecode::Label { true_block },
Bytecode::Label { false_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.switch_to_basic_block(true_block);
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined()); generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
m_consequent->generate_bytecode(generator); TRY(m_consequent->generate_bytecode(generator));
if (!generator.is_current_block_terminated()) if (!generator.is_current_block_terminated())
true_block_jump = &generator.emit<Bytecode::Op::Jump>(); 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()); generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
if (m_alternate) if (m_alternate)
m_alternate->generate_bytecode(generator); TRY(m_alternate->generate_bytecode(generator));
if (!generator.is_current_block_terminated()) if (!generator.is_current_block_terminated())
generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { end_block }, {}); 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 }, {}); true_block_jump->set_targets(Bytecode::Label { end_block }, {});
generator.switch_to_basic_block(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.emit<Bytecode::Op::Jump>().set_targets(
generator.nearest_continuable_scope(), 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 // test
// jump if_true (true) true (false) false // 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& false_block = generator.make_block();
auto& end_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( generator.emit<Bytecode::Op::JumpConditional>().set_targets(
Bytecode::Label { true_block }, Bytecode::Label { true_block },
Bytecode::Label { false_block }); Bytecode::Label { false_block });
generator.switch_to_basic_block(true_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( generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { end_block }, Bytecode::Label { end_block },
{}); {});
generator.switch_to_basic_block(false_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( generator.emit<Bytecode::Op::Jump>().set_targets(
Bytecode::Label { end_block }, Bytecode::Label { end_block },
{}); {});
generator.switch_to_basic_block(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) 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(); auto string_reg = generator.allocate_register();
for (size_t i = 0; i < m_expressions.size(); i++) { 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) { if (i == 0) {
generator.emit<Bytecode::Op::Store>(string_reg); generator.emit<Bytecode::Op::Store>(string_reg);
} else { } else {
@ -1036,11 +1108,12 @@ void TemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
} }
generator.emit<Bytecode::Op::Load>(string_reg); 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(); auto tag_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(tag_reg); generator.emit<Bytecode::Op::Store>(tag_reg);
@ -1050,7 +1123,7 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
if (i % 2 != 0) if (i % 2 != 0)
continue; continue;
expressions[i].generate_bytecode(generator); TRY(expressions[i].generate_bytecode(generator));
auto string_reg = generator.allocate_register(); auto string_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(string_reg); generator.emit<Bytecode::Op::Store>(string_reg);
string_regs.append(string_reg); string_regs.append(string_reg);
@ -1066,7 +1139,7 @@ void TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) co
if (i % 2 == 0) if (i % 2 == 0)
continue; continue;
expressions[i].generate_bytecode(generator); TRY(expressions[i].generate_bytecode(generator));
auto string_reg = generator.allocate_register(); auto string_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(string_reg); generator.emit<Bytecode::Op::Store>(string_reg);
argument_regs.append(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; Vector<Bytecode::Register> raw_string_regs;
for (auto& raw_string : m_template_literal->raw_strings()) { 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(); auto raw_string_reg = generator.allocate_register();
generator.emit<Bytecode::Op::Store>(raw_string_reg); generator.emit<Bytecode::Op::Store>(raw_string_reg);
raw_string_regs.append(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<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)); 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; Optional<Bytecode::Register> previous_value_for_postfix_reg;
if (!m_prefixed) { if (!m_prefixed) {
@ -1109,26 +1183,29 @@ void UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const
else else
generator.emit<Bytecode::Op::Decrement>(); generator.emit<Bytecode::Op::Decrement>();
generator.emit_store_to_reference(*m_argument); TRY(generator.emit_store_to_reference(*m_argument));
if (!m_prefixed) if (!m_prefixed)
generator.emit<Bytecode::Op::Load>(*previous_value_for_postfix_reg); 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>(); 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.emit<Bytecode::Op::Jump>().set_targets(
generator.nearest_breakable_scope(), 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(); auto& saved_block = generator.current_block();
@ -1140,7 +1217,7 @@ void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
if (m_finalizer) { if (m_finalizer) {
auto& finalizer_block = generator.make_block(); auto& finalizer_block = generator.make_block();
generator.switch_to_basic_block(finalizer_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()) { if (!generator.is_current_block_terminated()) {
next_block = &generator.make_block(); next_block = &generator.make_block();
auto next_target = Bytecode::Label { *next_block }; auto next_target = Bytecode::Label { *next_block };
@ -1152,19 +1229,23 @@ void TryStatement::generate_bytecode(Bytecode::Generator& generator) const
if (m_handler) { if (m_handler) {
auto& handler_block = generator.make_block(); auto& handler_block = generator.make_block();
generator.switch_to_basic_block(handler_block); generator.switch_to_basic_block(handler_block);
m_handler->parameter().visit( TRY(m_handler->parameter().visit(
[&](FlyString const& parameter) { [&](FlyString const& parameter) -> Bytecode::CodeGenerationErrorOr<void> {
if (!parameter.is_empty()) { if (!parameter.is_empty()) {
// FIXME: We need a separate DeclarativeEnvironment here // FIXME: We need a separate DeclarativeEnvironment here
generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(parameter)); 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. // 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 }; handler_target = Bytecode::Label { handler_block };
if (!generator.is_current_block_terminated()) { if (!generator.is_current_block_terminated()) {
if (m_finalizer) { 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.emit<Bytecode::Op::EnterUnwindContext>(Bytecode::Label { target_block }, handler_target, finalizer_target);
generator.switch_to_basic_block(target_block); 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 (!generator.is_current_block_terminated()) {
if (m_finalizer) { if (m_finalizer) {
generator.emit<Bytecode::Op::Jump>(finalizer_target); 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); 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(); auto discriminant_reg = generator.allocate_register();
m_discriminant->generate_bytecode(generator); TRY(m_discriminant->generate_bytecode(generator));
generator.emit<Bytecode::Op::Store>(discriminant_reg); generator.emit<Bytecode::Op::Store>(discriminant_reg);
Vector<Bytecode::BasicBlock&> case_blocks; Vector<Bytecode::BasicBlock&> case_blocks;
Bytecode::BasicBlock* default_block { nullptr }; Bytecode::BasicBlock* default_block { nullptr };
@ -1211,7 +1293,7 @@ void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
auto& case_block = generator.make_block(); auto& case_block = generator.make_block();
if (switch_case.test()) { if (switch_case.test()) {
generator.switch_to_basic_block(*next_test_block); 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); generator.emit<Bytecode::Op::StrictlyEquals>(discriminant_reg);
next_test_block = &generator.make_block(); next_test_block = &generator.make_block();
generator.emit<Bytecode::Op::JumpConditional>().set_targets(Bytecode::Label { case_block }, Bytecode::Label { *next_test_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()); generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
for (auto& statement : switch_case.children()) { for (auto& statement : switch_case.children()) {
statement.generate_bytecode(generator); TRY(statement.generate_bytecode(generator));
} }
if (!generator.is_current_block_terminated()) { if (!generator.is_current_block_terminated()) {
auto next_block = current_block; auto next_block = current_block;
@ -1252,6 +1334,7 @@ void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
generator.end_breakable_scope(); generator.end_breakable_scope();
generator.switch_to_basic_block(end_block); generator.switch_to_basic_block(end_block);
return {};
} }
void ClassDeclaration::generate_bytecode(Bytecode::Generator& generator) const 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())); 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>(); 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()); VERIFY(generator.is_in_async_function());
// Transform `await expr` to `yield expr` // Transform `await expr` to `yield expr`
m_argument->generate_bytecode(generator); TRY(m_argument->generate_bytecode(generator));
auto& continuation_block = generator.make_block(); auto& continuation_block = generator.make_block();
generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block }); generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
generator.switch_to_basic_block(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 generator;
generator.switch_to_basic_block(generator.make_block()); 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.emit<Bytecode::Op::Yield>(Label { start_block });
generator.switch_to_basic_block(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()) { if (generator.is_in_generator_or_async_function()) {
// Terminate all unterminated blocks with yield return // Terminate all unterminated blocks with yield return
for (auto& block : generator.m_root_basic_blocks) { for (auto& block : generator.m_root_basic_blocks) {
@ -99,38 +99,43 @@ void Generator::end_breakable_scope()
m_breakable_scopes.take_last(); 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)) { if (is<Identifier>(node)) {
auto& identifier = static_cast<Identifier const&>(node); auto& identifier = static_cast<Identifier const&>(node);
emit<Bytecode::Op::GetVariable>(intern_identifier(identifier.string())); emit<Bytecode::Op::GetVariable>(intern_identifier(identifier.string()));
return; return {};
} }
if (is<MemberExpression>(node)) { if (is<MemberExpression>(node)) {
auto& expression = static_cast<MemberExpression const&>(node); auto& expression = static_cast<MemberExpression const&>(node);
expression.object().generate_bytecode(*this); TRY(expression.object().generate_bytecode(*this));
auto object_reg = allocate_register(); auto object_reg = allocate_register();
emit<Bytecode::Op::Store>(object_reg); emit<Bytecode::Op::Store>(object_reg);
if (expression.is_computed()) { if (expression.is_computed()) {
expression.property().generate_bytecode(*this); TRY(expression.property().generate_bytecode(*this));
emit<Bytecode::Op::GetByValue>(object_reg); 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()); auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
emit<Bytecode::Op::GetById>(identifier_table_ref); emit<Bytecode::Op::GetById>(identifier_table_ref);
} else {
return CodeGenerationError {
&expression,
"Unimplemented non-computed member expression"sv
};
} }
return; return {};
} }
VERIFY_NOT_REACHED(); 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)) { if (is<Identifier>(node)) {
auto& identifier = static_cast<Identifier const&>(node); auto& identifier = static_cast<Identifier const&>(node);
emit<Bytecode::Op::SetVariable>(intern_identifier(identifier.string())); emit<Bytecode::Op::SetVariable>(intern_identifier(identifier.string()));
return; return {};
} }
if (is<MemberExpression>(node)) { if (is<MemberExpression>(node)) {
// NOTE: The value is in the accumulator, so we have to store that away first. // 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); emit<Bytecode::Op::Store>(value_reg);
auto& expression = static_cast<MemberExpression const&>(node); auto& expression = static_cast<MemberExpression const&>(node);
expression.object().generate_bytecode(*this); TRY(expression.object().generate_bytecode(*this));
auto object_reg = allocate_register(); auto object_reg = allocate_register();
emit<Bytecode::Op::Store>(object_reg); emit<Bytecode::Op::Store>(object_reg);
if (expression.is_computed()) { if (expression.is_computed()) {
expression.property().generate_bytecode(*this); TRY(expression.property().generate_bytecode(*this));
auto property_reg = allocate_register(); auto property_reg = allocate_register();
emit<Bytecode::Op::Store>(property_reg); emit<Bytecode::Op::Store>(property_reg);
emit<Bytecode::Op::Load>(value_reg); emit<Bytecode::Op::Load>(value_reg);
emit<Bytecode::Op::PutByValue>(object_reg, property_reg); emit<Bytecode::Op::PutByValue>(object_reg, property_reg);
} else { } else if (expression.property().is_identifier()) {
emit<Bytecode::Op::Load>(value_reg); emit<Bytecode::Op::Load>(value_reg);
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string()); auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
emit<Bytecode::Op::PutById>(object_reg, identifier_table_ref); emit<Bytecode::Op::PutById>(object_reg, identifier_table_ref);
} else {
return CodeGenerationError {
&expression,
"Unimplemented non-computed member expression"sv
};
} }
return; return {};
} }
VERIFY_NOT_REACHED(); 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/OwnPtr.h>
#include <AK/SinglyLinkedList.h> #include <AK/SinglyLinkedList.h>
#include <LibJS/Bytecode/BasicBlock.h> #include <LibJS/Bytecode/BasicBlock.h>
#include <LibJS/Bytecode/CodeGenerationError.h>
#include <LibJS/Bytecode/Executable.h> #include <LibJS/Bytecode/Executable.h>
#include <LibJS/Bytecode/IdentifierTable.h> #include <LibJS/Bytecode/IdentifierTable.h>
#include <LibJS/Bytecode/Label.h> #include <LibJS/Bytecode/Label.h>
@ -23,7 +24,7 @@ namespace JS::Bytecode {
class Generator { class Generator {
public: public:
static NonnullOwnPtr<Executable> generate(ASTNode const&, FunctionKind = FunctionKind::Normal); static CodeGenerationErrorOr<NonnullOwnPtr<Executable>> generate(ASTNode const&, FunctionKind = FunctionKind::Normal);
Register allocate_register(); Register allocate_register();
@ -71,8 +72,8 @@ public:
return *static_cast<OpType*>(slot); return *static_cast<OpType*>(slot);
} }
void emit_load_from_reference(JS::ASTNode const&); CodeGenerationErrorOr<void> emit_load_from_reference(JS::ASTNode const&);
void emit_store_to_reference(JS::ASTNode const&); CodeGenerationErrorOr<void> emit_store_to_reference(JS::ASTNode const&);
void begin_continuable_scope(Label continue_target); void begin_continuable_scope(Label continue_target);
void end_continuable_scope(); 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; Optional<Value> eval_result;
if (auto* bytecode_interpreter = Bytecode::Interpreter::current()) { 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; executable->name = "eval"sv;
if (JS::Bytecode::g_dump_bytecode) if (JS::Bytecode::g_dump_bytecode)
executable->dump(); 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 // FIXME: pass something to evaluate default arguments with
TRY(function_declaration_instantiation(nullptr)); TRY(function_declaration_instantiation(nullptr));
if (!m_bytecode_executable) { 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; m_bytecode_executable->name = m_name;
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline(); auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
passes.perform(*m_bytecode_executable); 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(); auto test_script = result.release_value();
if (g_run_bytecode) { 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; executable->name = test_path;
if (JS::Bytecode::g_dump_bytecode) if (JS::Bytecode::g_dump_bytecode)
executable->dump(); executable->dump();
@ -362,12 +362,15 @@ inline JSFileResult TestRunner::run_file_test(const String& test_path)
if (file_script.is_error()) if (file_script.is_error())
return { test_path, file_script.error() }; return { test_path, file_script.error() };
if (g_run_bytecode) { if (g_run_bytecode) {
auto executable = JS::Bytecode::Generator::generate(file_script.value()->parse_node()); auto executable_result = JS::Bytecode::Generator::generate(file_script.value()->parse_node());
executable->name = test_path; if (!executable_result.is_error()) {
if (JS::Bytecode::g_dump_bytecode) auto executable = executable_result.release_value();
executable->dump(); executable->name = test_path;
JS::Bytecode::Interpreter bytecode_interpreter(interpreter->global_object(), interpreter->realm()); if (JS::Bytecode::g_dump_bytecode)
(void)bytecode_interpreter.run(*executable); executable->dump();
JS::Bytecode::Interpreter bytecode_interpreter(interpreter->global_object(), interpreter->realm());
(void)bytecode_interpreter.run(*executable);
}
} else { } else {
g_vm->push_execution_context(global_execution_context, interpreter->global_object()); g_vm->push_execution_context(global_execution_context, interpreter->global_object());
(void)interpreter->run(file_script.value()); (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); script_or_module->parse_node().dump(0);
if (JS::Bytecode::g_dump_bytecode || s_run_bytecode) { 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; executable->name = source_name;
if (s_opt_bytecode) { if (s_opt_bytecode) {
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline(); auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();