mirror of
https://github.com/RGBCube/serenity
synced 2025-06-30 10:22:13 +00:00
LibJS/Bytecode: Move to a new bytecode format
This patch moves us away from the accumulator-based bytecode format to one with explicit source and destination registers. The new format has multiple benefits: - ~25% faster on the Kraken and Octane benchmarks :^) - Fewer instructions to accomplish the same thing - Much easier for humans to read(!) Because this change requires a fundamental shift in how bytecode is generated, it is quite comprehensive. Main implementation mechanism: generate_bytecode() virtual function now takes an optional "preferred dst" operand, which allows callers to communicate when they have an operand that would be optimal for the result to go into. It also returns an optional "actual dst" operand, which is where the completion value (if any) of the AST node is stored after the node has "executed". One thing of note that's new: because instructions can now take locals as operands, this means we got rid of the GetLocal instruction. A side-effect of that is we have to think about the temporal deadzone (TDZ) a bit differently for locals (GetLocal would previously check for empty values and interpret that as a TDZ access and throw). We now insert special ThrowIfTDZ instructions in places where a local access may be in the TDZ, to maintain the correct behavior. There are a number of progressions and regressions from this test: A number of async generator tests have been accidentally fixed while converting the implementation to the new bytecode format. It didn't seem useful to preserve bugs in the original code when converting it. Some "does eval() return the correct completion value" tests have regressed, in particular ones related to propagating the appropriate completion after control flow statements like continue and break. These are all fairly obscure issues, and I believe we can continue working on them separately. The net test262 result is a progression though. :^)
This commit is contained in:
Andreas Kling
parent
7f1a62a1d3
commit
e46b217e42
14 changed files with 2311 additions and 1642 deletions
|
|
@ -1,11 +1,9 @@
|
|||
/*
|
||||
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
|
||||
* Copyright (c) 2021-2024, Andreas Kling <kling@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#define FIXME_NEWBC (void)
|
||||
|
||||
#include <AK/TemporaryChange.h>
|
||||
#include <LibJS/AST.h>
|
||||
#include <LibJS/Bytecode/BasicBlock.h>
|
||||
|
|
@ -24,29 +22,42 @@ Generator::Generator()
|
|||
{
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::generate(VM& vm, ASTNode const& node, FunctionKind enclosing_function_kind)
|
||||
CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::generate(VM& vm, ASTNode const& node, ReadonlySpan<FunctionParameter> parameters, FunctionKind enclosing_function_kind)
|
||||
{
|
||||
Generator generator;
|
||||
|
||||
for (auto const& parameter : parameters) {
|
||||
if (auto const* identifier = parameter.binding.get_pointer<NonnullRefPtr<Identifier const>>();
|
||||
identifier && (*identifier)->is_local()) {
|
||||
generator.set_local_initialized((*identifier)->local_variable_index());
|
||||
}
|
||||
}
|
||||
|
||||
generator.switch_to_basic_block(generator.make_block());
|
||||
SourceLocationScope scope(generator, node);
|
||||
generator.m_enclosing_function_kind = enclosing_function_kind;
|
||||
if (generator.is_in_generator_or_async_function()) {
|
||||
// Immediately yield with no value.
|
||||
auto& start_block = generator.make_block();
|
||||
generator.emit<Bytecode::Op::Yield>(Label { start_block });
|
||||
generator.emit<Bytecode::Op::Yield>(Label { start_block }, generator.add_constant(js_undefined()));
|
||||
generator.switch_to_basic_block(start_block);
|
||||
// NOTE: This doesn't have to handle received throw/return completions, as GeneratorObject::resume_abrupt
|
||||
// will not enter the generator from the SuspendedStart state and immediately completes the generator.
|
||||
}
|
||||
FIXME_NEWBC TRY(node.generate_bytecode(generator));
|
||||
|
||||
auto last_value = TRY(node.generate_bytecode(generator));
|
||||
|
||||
if (!generator.current_block().is_terminated() && last_value.has_value()) {
|
||||
generator.emit<Bytecode::Op::End>(last_value.value());
|
||||
}
|
||||
|
||||
if (generator.is_in_generator_or_async_function()) {
|
||||
// Terminate all unterminated blocks with yield return
|
||||
for (auto& block : generator.m_root_basic_blocks) {
|
||||
if (block->is_terminated())
|
||||
continue;
|
||||
generator.switch_to_basic_block(*block);
|
||||
generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
|
||||
generator.emit<Bytecode::Op::Yield>(nullptr);
|
||||
generator.emit<Bytecode::Op::Yield>(nullptr, generator.add_constant(js_undefined()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -169,26 +180,23 @@ void Generator::end_breakable_scope()
|
|||
end_boundary(BlockBoundaryType::Break);
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<Generator::ReferenceRegisters> Generator::emit_super_reference(MemberExpression const& expression)
|
||||
CodeGenerationErrorOr<Generator::ReferenceOperands> Generator::emit_super_reference(MemberExpression const& expression)
|
||||
{
|
||||
VERIFY(is<SuperExpression>(expression.object()));
|
||||
|
||||
// https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
|
||||
// 1. Let env be GetThisEnvironment().
|
||||
// 2. Let actualThis be ? env.GetThisBinding().
|
||||
auto actual_this_register = allocate_register();
|
||||
emit<Bytecode::Op::ResolveThisBinding>();
|
||||
emit<Bytecode::Op::Store>(actual_this_register);
|
||||
auto actual_this = Operand(allocate_register());
|
||||
emit<Bytecode::Op::ResolveThisBinding>(actual_this);
|
||||
|
||||
Optional<Bytecode::Register> computed_property_value_register;
|
||||
Optional<Bytecode::Operand> computed_property_value;
|
||||
|
||||
if (expression.is_computed()) {
|
||||
// SuperProperty : super [ Expression ]
|
||||
// 3. Let propertyNameReference be ? Evaluation of Expression.
|
||||
// 4. Let propertyNameValue be ? GetValue(propertyNameReference).
|
||||
FIXME_NEWBC TRY(expression.property().generate_bytecode(*this));
|
||||
computed_property_value_register = allocate_register();
|
||||
emit<Bytecode::Op::Store>(*computed_property_value_register);
|
||||
computed_property_value = TRY(expression.property().generate_bytecode(*this)).value();
|
||||
}
|
||||
|
||||
// 5/7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
|
||||
|
|
@ -197,135 +205,128 @@ CodeGenerationErrorOr<Generator::ReferenceRegisters> Generator::emit_super_refer
|
|||
// 1. Let env be GetThisEnvironment().
|
||||
// 2. Assert: env.HasSuperBinding() is true.
|
||||
// 3. Let baseValue be ? env.GetSuperBase().
|
||||
auto super_base_register = allocate_register();
|
||||
emit<Bytecode::Op::ResolveSuperBase>();
|
||||
emit<Bytecode::Op::Store>(super_base_register);
|
||||
auto base_value = Operand(allocate_register());
|
||||
emit<Bytecode::Op::ResolveSuperBase>(base_value);
|
||||
|
||||
// 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }.
|
||||
return ReferenceRegisters {
|
||||
.base = super_base_register,
|
||||
.referenced_name = move(computed_property_value_register),
|
||||
.this_value = actual_this_register,
|
||||
return ReferenceOperands {
|
||||
.base = base_value,
|
||||
.referenced_name = computed_property_value,
|
||||
.this_value = actual_this,
|
||||
};
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<Optional<Generator::ReferenceRegisters>> Generator::emit_load_from_reference(JS::ASTNode const& node, CollectRegisters collect_registers)
|
||||
CodeGenerationErrorOr<Generator::ReferenceOperands> Generator::emit_load_from_reference(JS::ASTNode const& node, Optional<Operand> preferred_dst)
|
||||
{
|
||||
if (is<Identifier>(node)) {
|
||||
auto& identifier = static_cast<Identifier const&>(node);
|
||||
FIXME_NEWBC TRY(identifier.generate_bytecode(*this));
|
||||
return Optional<ReferenceRegisters> {};
|
||||
auto loaded_value = TRY(identifier.generate_bytecode(*this, preferred_dst)).value();
|
||||
return ReferenceOperands {
|
||||
.loaded_value = loaded_value,
|
||||
};
|
||||
}
|
||||
if (is<MemberExpression>(node)) {
|
||||
auto& expression = static_cast<MemberExpression const&>(node);
|
||||
if (!is<MemberExpression>(node)) {
|
||||
return CodeGenerationError {
|
||||
&node,
|
||||
"Unimplemented/invalid node used as a reference"sv
|
||||
};
|
||||
}
|
||||
auto& expression = static_cast<MemberExpression const&>(node);
|
||||
|
||||
// https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
|
||||
if (is<SuperExpression>(expression.object())) {
|
||||
auto super_reference = TRY(emit_super_reference(expression));
|
||||
// https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
|
||||
if (is<SuperExpression>(expression.object())) {
|
||||
auto super_reference = TRY(emit_super_reference(expression));
|
||||
auto dst = preferred_dst.has_value() ? preferred_dst.value() : Operand(allocate_register());
|
||||
|
||||
if (super_reference.referenced_name.has_value()) {
|
||||
// 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
|
||||
// FIXME: This does ToPropertyKey out of order, which is observable by Symbol.toPrimitive!
|
||||
emit<Bytecode::Op::Load>(*super_reference.referenced_name);
|
||||
emit<Bytecode::Op::GetByValueWithThis>(super_reference.base, super_reference.this_value);
|
||||
} else {
|
||||
// 3. Let propertyKey be StringValue of IdentifierName.
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit_get_by_id_with_this(identifier_table_ref, super_reference.this_value);
|
||||
}
|
||||
|
||||
return super_reference;
|
||||
if (super_reference.referenced_name.has_value()) {
|
||||
// 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
|
||||
// FIXME: This does ToPropertyKey out of order, which is observable by Symbol.toPrimitive!
|
||||
emit<Bytecode::Op::GetByValueWithThis>(dst, *super_reference.base, *super_reference.referenced_name, *super_reference.this_value);
|
||||
} else {
|
||||
FIXME_NEWBC TRY(expression.object().generate_bytecode(*this));
|
||||
if (expression.is_computed()) {
|
||||
auto object_reg = allocate_register();
|
||||
emit<Bytecode::Op::Store>(object_reg);
|
||||
|
||||
FIXME_NEWBC TRY(expression.property().generate_bytecode(*this));
|
||||
Optional<Register> property_reg {};
|
||||
if (collect_registers == CollectRegisters::Yes) {
|
||||
property_reg = allocate_register();
|
||||
emit<Bytecode::Op::Store>(property_reg.value());
|
||||
}
|
||||
|
||||
emit<Bytecode::Op::GetByValue>(object_reg);
|
||||
if (collect_registers == CollectRegisters::Yes)
|
||||
return ReferenceRegisters {
|
||||
.base = object_reg,
|
||||
.referenced_name = property_reg.value(),
|
||||
.this_value = object_reg,
|
||||
};
|
||||
return Optional<ReferenceRegisters> {};
|
||||
} else if (expression.property().is_identifier()) {
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit_get_by_id(identifier_table_ref);
|
||||
} else if (expression.property().is_private_identifier()) {
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<PrivateIdentifier>(expression.property()).string());
|
||||
emit<Bytecode::Op::GetPrivateById>(identifier_table_ref);
|
||||
} else {
|
||||
return CodeGenerationError {
|
||||
&expression,
|
||||
"Unimplemented non-computed member expression"sv
|
||||
};
|
||||
}
|
||||
// 3. Let propertyKey be StringValue of IdentifierName.
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit_get_by_id_with_this(dst, *super_reference.base, identifier_table_ref, *super_reference.this_value);
|
||||
}
|
||||
return Optional<ReferenceRegisters> {};
|
||||
|
||||
super_reference.loaded_value = dst;
|
||||
return super_reference;
|
||||
}
|
||||
auto base = TRY(expression.object().generate_bytecode(*this)).value();
|
||||
if (expression.is_computed()) {
|
||||
auto property = TRY(expression.property().generate_bytecode(*this)).value();
|
||||
auto dst = preferred_dst.has_value() ? preferred_dst.value() : Operand(allocate_register());
|
||||
emit<Bytecode::Op::GetByValue>(dst, base, property);
|
||||
return ReferenceOperands {
|
||||
.base = base,
|
||||
.referenced_name = property,
|
||||
.this_value = base,
|
||||
.loaded_value = dst,
|
||||
};
|
||||
}
|
||||
if (expression.property().is_identifier()) {
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
auto dst = preferred_dst.has_value() ? preferred_dst.value() : Operand(allocate_register());
|
||||
emit_get_by_id(dst, base, identifier_table_ref);
|
||||
return ReferenceOperands {
|
||||
.base = base,
|
||||
.referenced_identifier = identifier_table_ref,
|
||||
.this_value = base,
|
||||
.loaded_value = dst,
|
||||
};
|
||||
}
|
||||
if (expression.property().is_private_identifier()) {
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<PrivateIdentifier>(expression.property()).string());
|
||||
auto dst = preferred_dst.has_value() ? preferred_dst.value() : Operand(allocate_register());
|
||||
emit<Bytecode::Op::GetPrivateById>(dst, base, identifier_table_ref);
|
||||
return ReferenceOperands {
|
||||
.base = base,
|
||||
.referenced_private_identifier = identifier_table_ref,
|
||||
.this_value = base,
|
||||
.loaded_value = dst,
|
||||
};
|
||||
}
|
||||
return CodeGenerationError {
|
||||
&node,
|
||||
"Unimplemented/invalid node used a reference"sv
|
||||
&expression,
|
||||
"Unimplemented non-computed member expression"sv
|
||||
};
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<Optional<Operand>> Generator::emit_store_to_reference(JS::ASTNode const& node)
|
||||
CodeGenerationErrorOr<void> Generator::emit_store_to_reference(JS::ASTNode const& node, Operand value)
|
||||
{
|
||||
if (is<Identifier>(node)) {
|
||||
auto& identifier = static_cast<Identifier const&>(node);
|
||||
emit_set_variable(identifier);
|
||||
return Optional<Operand> {};
|
||||
emit_set_variable(identifier, value);
|
||||
return {};
|
||||
}
|
||||
if (is<MemberExpression>(node)) {
|
||||
// NOTE: The value is in the accumulator, so we have to store that away first.
|
||||
auto value_reg = allocate_register();
|
||||
emit<Bytecode::Op::Store>(value_reg);
|
||||
|
||||
auto& expression = static_cast<MemberExpression const&>(node);
|
||||
|
||||
// https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
|
||||
if (is<SuperExpression>(expression.object())) {
|
||||
auto super_reference = TRY(emit_super_reference(expression));
|
||||
emit<Bytecode::Op::Load>(value_reg);
|
||||
|
||||
// 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }.
|
||||
if (super_reference.referenced_name.has_value()) {
|
||||
// 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
|
||||
// FIXME: This does ToPropertyKey out of order, which is observable by Symbol.toPrimitive!
|
||||
emit<Bytecode::Op::PutByValueWithThis>(super_reference.base, *super_reference.referenced_name, super_reference.this_value);
|
||||
emit<Bytecode::Op::PutByValueWithThis>(*super_reference.base, *super_reference.referenced_name, *super_reference.this_value, value);
|
||||
} else {
|
||||
// 3. Let propertyKey be StringValue of IdentifierName.
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit<Bytecode::Op::PutByIdWithThis>(super_reference.base, super_reference.this_value, identifier_table_ref, Bytecode::Op::PropertyKind::KeyValue, next_property_lookup_cache());
|
||||
emit<Bytecode::Op::PutByIdWithThis>(*super_reference.base, *super_reference.this_value, identifier_table_ref, value, Bytecode::Op::PropertyKind::KeyValue, next_property_lookup_cache());
|
||||
}
|
||||
} else {
|
||||
FIXME_NEWBC TRY(expression.object().generate_bytecode(*this));
|
||||
|
||||
auto object_reg = allocate_register();
|
||||
emit<Bytecode::Op::Store>(object_reg);
|
||||
auto object = TRY(expression.object().generate_bytecode(*this)).value();
|
||||
|
||||
if (expression.is_computed()) {
|
||||
FIXME_NEWBC TRY(expression.property().generate_bytecode(*this));
|
||||
auto property_reg = allocate_register();
|
||||
emit<Bytecode::Op::Store>(property_reg);
|
||||
emit<Bytecode::Op::Load>(value_reg);
|
||||
emit<Bytecode::Op::PutByValue>(object_reg, property_reg);
|
||||
auto property = TRY(expression.property().generate_bytecode(*this)).value();
|
||||
emit<Bytecode::Op::PutByValue>(object, property, value);
|
||||
} else if (expression.property().is_identifier()) {
|
||||
emit<Bytecode::Op::Load>(value_reg);
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit<Bytecode::Op::PutById>(object_reg, identifier_table_ref, Bytecode::Op::PropertyKind::KeyValue, next_property_lookup_cache());
|
||||
emit<Bytecode::Op::PutById>(object, identifier_table_ref, value, Bytecode::Op::PropertyKind::KeyValue, next_property_lookup_cache());
|
||||
} else if (expression.property().is_private_identifier()) {
|
||||
emit<Bytecode::Op::Load>(value_reg);
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<PrivateIdentifier>(expression.property()).string());
|
||||
emit<Bytecode::Op::PutPrivateById>(object_reg, identifier_table_ref);
|
||||
emit<Bytecode::Op::PutPrivateById>(object, identifier_table_ref, value);
|
||||
} else {
|
||||
return CodeGenerationError {
|
||||
&expression,
|
||||
|
|
@ -334,7 +335,7 @@ CodeGenerationErrorOr<Optional<Operand>> Generator::emit_store_to_reference(JS::
|
|||
}
|
||||
}
|
||||
|
||||
return Optional<Operand> {};
|
||||
return {};
|
||||
}
|
||||
|
||||
return CodeGenerationError {
|
||||
|
|
@ -343,24 +344,36 @@ CodeGenerationErrorOr<Optional<Operand>> Generator::emit_store_to_reference(JS::
|
|||
};
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<Optional<Operand>> Generator::emit_store_to_reference(ReferenceRegisters const& reference_registers)
|
||||
CodeGenerationErrorOr<void> Generator::emit_store_to_reference(ReferenceOperands const& reference, Operand value)
|
||||
{
|
||||
if (reference_registers.base == reference_registers.this_value)
|
||||
emit<Bytecode::Op::PutByValue>(reference_registers.base, reference_registers.referenced_name.value());
|
||||
if (reference.referenced_private_identifier.has_value()) {
|
||||
emit<Bytecode::Op::PutPrivateById>(*reference.base, *reference.referenced_private_identifier, value);
|
||||
return {};
|
||||
}
|
||||
if (reference.referenced_identifier.has_value()) {
|
||||
if (reference.base == reference.this_value)
|
||||
emit<Bytecode::Op::PutById>(*reference.base, *reference.referenced_identifier, value, Bytecode::Op::PropertyKind::KeyValue, next_property_lookup_cache());
|
||||
else
|
||||
emit<Bytecode::Op::PutByIdWithThis>(*reference.base, *reference.this_value, *reference.referenced_identifier, value, Bytecode::Op::PropertyKind::KeyValue, next_property_lookup_cache());
|
||||
return {};
|
||||
}
|
||||
if (reference.base == reference.this_value)
|
||||
emit<Bytecode::Op::PutByValue>(*reference.base, *reference.referenced_name, value);
|
||||
else
|
||||
emit<Bytecode::Op::PutByValueWithThis>(reference_registers.base, reference_registers.referenced_name.value(), reference_registers.this_value);
|
||||
return Optional<Operand> {};
|
||||
emit<Bytecode::Op::PutByValueWithThis>(*reference.base, *reference.referenced_name, *reference.this_value, value);
|
||||
return {};
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<Optional<Operand>> Generator::emit_delete_reference(JS::ASTNode const& node)
|
||||
{
|
||||
if (is<Identifier>(node)) {
|
||||
auto& identifier = static_cast<Identifier const&>(node);
|
||||
if (identifier.is_local())
|
||||
emit<Bytecode::Op::LoadImmediate>(Value(false));
|
||||
else
|
||||
emit<Bytecode::Op::DeleteVariable>(intern_identifier(identifier.string()));
|
||||
return Optional<Operand> {};
|
||||
if (identifier.is_local()) {
|
||||
return add_constant(Value(false));
|
||||
}
|
||||
auto dst = Operand(allocate_register());
|
||||
emit<Bytecode::Op::DeleteVariable>(dst, intern_identifier(identifier.string()));
|
||||
return dst;
|
||||
}
|
||||
|
||||
if (is<MemberExpression>(node)) {
|
||||
|
|
@ -370,27 +383,26 @@ CodeGenerationErrorOr<Optional<Operand>> Generator::emit_delete_reference(JS::AS
|
|||
if (is<SuperExpression>(expression.object())) {
|
||||
auto super_reference = TRY(emit_super_reference(expression));
|
||||
|
||||
auto dst = Operand(allocate_register());
|
||||
if (super_reference.referenced_name.has_value()) {
|
||||
emit<Bytecode::Op::DeleteByValueWithThis>(super_reference.this_value, *super_reference.referenced_name);
|
||||
emit<Bytecode::Op::DeleteByValueWithThis>(dst, *super_reference.base, *super_reference.this_value, *super_reference.referenced_name);
|
||||
} else {
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit<Bytecode::Op::DeleteByIdWithThis>(super_reference.this_value, identifier_table_ref);
|
||||
emit<Bytecode::Op::DeleteByIdWithThis>(dst, *super_reference.base, *super_reference.this_value, identifier_table_ref);
|
||||
}
|
||||
|
||||
return Optional<Operand> {};
|
||||
}
|
||||
|
||||
FIXME_NEWBC TRY(expression.object().generate_bytecode(*this));
|
||||
auto object = TRY(expression.object().generate_bytecode(*this)).value();
|
||||
auto dst = Operand(allocate_register());
|
||||
|
||||
if (expression.is_computed()) {
|
||||
auto object_reg = allocate_register();
|
||||
emit<Bytecode::Op::Store>(object_reg);
|
||||
|
||||
FIXME_NEWBC TRY(expression.property().generate_bytecode(*this));
|
||||
emit<Bytecode::Op::DeleteByValue>(object_reg);
|
||||
auto property = TRY(expression.property().generate_bytecode(*this)).value();
|
||||
emit<Bytecode::Op::DeleteByValue>(dst, object, property);
|
||||
} else if (expression.property().is_identifier()) {
|
||||
auto identifier_table_ref = intern_identifier(verify_cast<Identifier>(expression.property()).string());
|
||||
emit<Bytecode::Op::DeleteById>(identifier_table_ref);
|
||||
emit<Bytecode::Op::DeleteById>(dst, object, identifier_table_ref);
|
||||
} else {
|
||||
// NOTE: Trying to delete a private field generates a SyntaxError in the parser.
|
||||
return CodeGenerationError {
|
||||
|
|
@ -398,7 +410,7 @@ CodeGenerationErrorOr<Optional<Operand>> Generator::emit_delete_reference(JS::AS
|
|||
"Unimplemented non-computed member expression"sv
|
||||
};
|
||||
}
|
||||
return Optional<Operand> {};
|
||||
return dst;
|
||||
}
|
||||
|
||||
// Though this will have no deletion effect, we still have to evaluate the node as it can have side effects.
|
||||
|
|
@ -407,21 +419,23 @@ CodeGenerationErrorOr<Optional<Operand>> Generator::emit_delete_reference(JS::AS
|
|||
// 13.5.1.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-delete-operator-runtime-semantics-evaluation
|
||||
// 1. Let ref be the result of evaluating UnaryExpression.
|
||||
// 2. ReturnIfAbrupt(ref).
|
||||
FIXME_NEWBC TRY(node.generate_bytecode(*this));
|
||||
(void)TRY(node.generate_bytecode(*this));
|
||||
|
||||
// 3. If ref is not a Reference Record, return true.
|
||||
emit<Bytecode::Op::LoadImmediate>(Value(true));
|
||||
|
||||
// NOTE: The rest of the steps are handled by Delete{Variable,ByValue,Id}.
|
||||
return Optional<Operand> {};
|
||||
return add_constant(Value(true));
|
||||
}
|
||||
|
||||
void Generator::emit_set_variable(JS::Identifier const& identifier, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Op::EnvironmentMode mode)
|
||||
void Generator::emit_set_variable(JS::Identifier const& identifier, Operand value, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Op::EnvironmentMode mode)
|
||||
{
|
||||
if (identifier.is_local()) {
|
||||
emit<Bytecode::Op::SetLocal>(identifier.local_variable_index());
|
||||
if (value.is_local() && value.index() == identifier.local_variable_index()) {
|
||||
// Moving a local to itself is a no-op.
|
||||
return;
|
||||
}
|
||||
emit<Bytecode::Op::SetLocal>(identifier.local_variable_index(), value);
|
||||
} else {
|
||||
emit<Bytecode::Op::SetVariable>(intern_identifier(identifier.string()), next_environment_variable_cache(), initialization_mode, mode);
|
||||
emit<Bytecode::Op::SetVariable>(intern_identifier(identifier.string()), value, next_environment_variable_cache(), initialization_mode, mode);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -540,9 +554,9 @@ void Generator::generate_continue(DeprecatedFlyString const& continue_label)
|
|||
generate_labelled_jump(JumpType::Continue, continue_label);
|
||||
}
|
||||
|
||||
void Generator::push_home_object(Register register_)
|
||||
void Generator::push_home_object(Operand object)
|
||||
{
|
||||
m_home_objects.append(register_);
|
||||
m_home_objects.append(object);
|
||||
}
|
||||
|
||||
void Generator::pop_home_object()
|
||||
|
|
@ -550,54 +564,62 @@ void Generator::pop_home_object()
|
|||
m_home_objects.take_last();
|
||||
}
|
||||
|
||||
void Generator::emit_new_function(FunctionExpression const& function_node, Optional<IdentifierTableIndex> lhs_name)
|
||||
void Generator::emit_new_function(Operand dst, FunctionExpression const& function_node, Optional<IdentifierTableIndex> lhs_name)
|
||||
{
|
||||
if (m_home_objects.is_empty())
|
||||
emit<Op::NewFunction>(function_node, lhs_name);
|
||||
else
|
||||
emit<Op::NewFunction>(function_node, lhs_name, m_home_objects.last());
|
||||
if (m_home_objects.is_empty()) {
|
||||
emit<Op::NewFunction>(dst, function_node, lhs_name);
|
||||
} else {
|
||||
emit<Op::NewFunction>(dst, function_node, lhs_name, m_home_objects.last());
|
||||
}
|
||||
}
|
||||
|
||||
CodeGenerationErrorOr<void> Generator::emit_named_evaluation_if_anonymous_function(Expression const& expression, Optional<IdentifierTableIndex> lhs_name)
|
||||
CodeGenerationErrorOr<Optional<Operand>> Generator::emit_named_evaluation_if_anonymous_function(Expression const& expression, Optional<IdentifierTableIndex> lhs_name, Optional<Operand> preferred_dst)
|
||||
{
|
||||
if (is<FunctionExpression>(expression)) {
|
||||
auto const& function_expression = static_cast<FunctionExpression const&>(expression);
|
||||
if (!function_expression.has_name()) {
|
||||
FIXME_NEWBC TRY(function_expression.generate_bytecode_with_lhs_name(*this, move(lhs_name)));
|
||||
return {};
|
||||
return TRY(function_expression.generate_bytecode_with_lhs_name(*this, move(lhs_name), preferred_dst)).value();
|
||||
}
|
||||
}
|
||||
|
||||
if (is<ClassExpression>(expression)) {
|
||||
auto const& class_expression = static_cast<ClassExpression const&>(expression);
|
||||
if (!class_expression.has_name()) {
|
||||
FIXME_NEWBC TRY(class_expression.generate_bytecode_with_lhs_name(*this, move(lhs_name)));
|
||||
return {};
|
||||
return TRY(class_expression.generate_bytecode_with_lhs_name(*this, move(lhs_name), preferred_dst)).value();
|
||||
}
|
||||
}
|
||||
|
||||
FIXME_NEWBC TRY(expression.generate_bytecode(*this));
|
||||
return {};
|
||||
return expression.generate_bytecode(*this, preferred_dst);
|
||||
}
|
||||
|
||||
void Generator::emit_get_by_id(IdentifierTableIndex id)
|
||||
void Generator::emit_get_by_id(Operand dst, Operand base, IdentifierTableIndex id)
|
||||
{
|
||||
emit<Op::GetById>(id, m_next_property_lookup_cache++);
|
||||
emit<Op::GetById>(dst, base, id, m_next_property_lookup_cache++);
|
||||
}
|
||||
|
||||
void Generator::emit_get_by_id_with_this(IdentifierTableIndex id, Register this_reg)
|
||||
void Generator::emit_get_by_id_with_this(Operand dst, Operand base, IdentifierTableIndex id, Operand this_value)
|
||||
{
|
||||
emit<Op::GetByIdWithThis>(id, this_reg, m_next_property_lookup_cache++);
|
||||
emit<Op::GetByIdWithThis>(dst, base, id, this_value, m_next_property_lookup_cache++);
|
||||
}
|
||||
|
||||
void Generator::emit_iterator_value()
|
||||
void Generator::emit_iterator_value(Operand dst, Operand result)
|
||||
{
|
||||
emit_get_by_id(intern_identifier("value"sv));
|
||||
emit_get_by_id(dst, result, intern_identifier("value"sv));
|
||||
}
|
||||
|
||||
void Generator::emit_iterator_complete()
|
||||
void Generator::emit_iterator_complete(Operand dst, Operand result)
|
||||
{
|
||||
emit_get_by_id(intern_identifier("done"sv));
|
||||
emit_get_by_id(dst, result, intern_identifier("done"sv));
|
||||
}
|
||||
|
||||
bool Generator::is_local_initialized(u32 local_index) const
|
||||
{
|
||||
return m_initialized_locals.find(local_index) != m_initialized_locals.end();
|
||||
}
|
||||
|
||||
void Generator::set_local_initialized(u32 local_index)
|
||||
{
|
||||
m_initialized_locals.set(local_index);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue