/* * Copyright (c) 2021-2023, Andreas Kling * Copyright (c) 2021, Linus Groh * Copyright (c) 2021, Gunnar Beutner * Copyright (c) 2021, Marcin Gasperowicz * * SPDX-License-Identifier: BSD-2-Clause */ #include #include #include #include #include #include #include #include #include namespace JS { Bytecode::CodeGenerationErrorOr ASTNode::generate_bytecode(Bytecode::Generator&) const { return Bytecode::CodeGenerationError { this, "Missing generate_bytecode()"sv, }; } Bytecode::CodeGenerationErrorOr ScopeNode::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); bool did_create_lexical_environment = false; if (is(*this)) { if (has_lexical_declarations()) { generator.block_declaration_instantiation(*this); did_create_lexical_environment = true; } } else if (is(*this)) { // GlobalDeclarationInstantiation is handled by the C++ AO. } else { // FunctionDeclarationInstantiation is handled by the C++ AO. } for (auto& child : children()) { TRY(child->generate_bytecode(generator)); if (generator.is_current_block_terminated()) break; } if (did_create_lexical_environment) generator.end_variable_scope(); return {}; } Bytecode::CodeGenerationErrorOr EmptyStatement::generate_bytecode(Bytecode::Generator&) const { return {}; } Bytecode::CodeGenerationErrorOr ExpressionStatement::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); return m_expression->generate_bytecode(generator); } Bytecode::CodeGenerationErrorOr BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (m_op == BinaryOp::In && is(*m_lhs)) { auto const& private_identifier = static_cast(*m_lhs).string(); TRY(m_rhs->generate_bytecode(generator)); generator.emit(generator.intern_identifier(private_identifier)); return {}; } TRY(m_lhs->generate_bytecode(generator)); auto lhs_reg = generator.allocate_register(); generator.emit(lhs_reg); TRY(m_rhs->generate_bytecode(generator)); switch (m_op) { case BinaryOp::Addition: generator.emit(lhs_reg); break; case BinaryOp::Subtraction: generator.emit(lhs_reg); break; case BinaryOp::Multiplication: generator.emit(lhs_reg); break; case BinaryOp::Division: generator.emit(lhs_reg); break; case BinaryOp::Modulo: generator.emit(lhs_reg); break; case BinaryOp::Exponentiation: generator.emit(lhs_reg); break; case BinaryOp::GreaterThan: generator.emit(lhs_reg); break; case BinaryOp::GreaterThanEquals: generator.emit(lhs_reg); break; case BinaryOp::LessThan: generator.emit(lhs_reg); break; case BinaryOp::LessThanEquals: generator.emit(lhs_reg); break; case BinaryOp::LooselyInequals: generator.emit(lhs_reg); break; case BinaryOp::LooselyEquals: generator.emit(lhs_reg); break; case BinaryOp::StrictlyInequals: generator.emit(lhs_reg); break; case BinaryOp::StrictlyEquals: generator.emit(lhs_reg); break; case BinaryOp::BitwiseAnd: generator.emit(lhs_reg); break; case BinaryOp::BitwiseOr: generator.emit(lhs_reg); break; case BinaryOp::BitwiseXor: generator.emit(lhs_reg); break; case BinaryOp::LeftShift: generator.emit(lhs_reg); break; case BinaryOp::RightShift: generator.emit(lhs_reg); break; case BinaryOp::UnsignedRightShift: generator.emit(lhs_reg); break; case BinaryOp::In: generator.emit(lhs_reg); break; case BinaryOp::InstanceOf: generator.emit(lhs_reg); break; default: VERIFY_NOT_REACHED(); } return {}; } Bytecode::CodeGenerationErrorOr LogicalExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); TRY(m_lhs->generate_bytecode(generator)); // lhs // jump op (true) end (false) rhs // rhs // jump always (true) end // end auto& rhs_block = generator.make_block(); auto& end_block = generator.make_block(); switch (m_op) { case LogicalOp::And: generator.emit( Bytecode::Label { rhs_block }, Bytecode::Label { end_block }); break; case LogicalOp::Or: generator.emit( Bytecode::Label { end_block }, Bytecode::Label { rhs_block }); break; case LogicalOp::NullishCoalescing: generator.emit( Bytecode::Label { rhs_block }, Bytecode::Label { end_block }); break; default: VERIFY_NOT_REACHED(); } generator.switch_to_basic_block(rhs_block); TRY(m_rhs->generate_bytecode(generator)); generator.emit(Bytecode::Label { end_block }); generator.switch_to_basic_block(end_block); return {}; } Bytecode::CodeGenerationErrorOr UnaryExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (m_op == UnaryOp::Delete) return generator.emit_delete_reference(m_lhs); // Typeof needs some special handling for when the LHS is an Identifier. Namely, it shouldn't throw on unresolvable references, but instead return "undefined". if (m_op != UnaryOp::Typeof) TRY(m_lhs->generate_bytecode(generator)); switch (m_op) { case UnaryOp::BitwiseNot: generator.emit(); break; case UnaryOp::Not: generator.emit(); break; case UnaryOp::Plus: generator.emit(); break; case UnaryOp::Minus: generator.emit(); break; case UnaryOp::Typeof: if (is(*m_lhs)) { auto& identifier = static_cast(*m_lhs); if (identifier.is_local()) { generator.emit(identifier.local_variable_index()); } else { generator.emit(generator.intern_identifier(identifier.string())); } break; } TRY(m_lhs->generate_bytecode(generator)); generator.emit(); break; case UnaryOp::Void: generator.emit(js_undefined()); break; case UnaryOp::Delete: // Delete is implemented above. default: VERIFY_NOT_REACHED(); } return {}; } Bytecode::CodeGenerationErrorOr NumericLiteral::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); generator.emit(m_value); return {}; } Bytecode::CodeGenerationErrorOr BooleanLiteral::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); generator.emit(Value(m_value)); return {}; } Bytecode::CodeGenerationErrorOr NullLiteral::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); generator.emit(js_null()); return {}; } Bytecode::CodeGenerationErrorOr BigIntLiteral::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // 1. Return the NumericValue of NumericLiteral as defined in 12.8.3. auto integer = [&] { if (m_value[0] == '0' && m_value.length() >= 3) if (m_value[1] == 'x' || m_value[1] == 'X') return MUST(Crypto::SignedBigInteger::from_base(16, m_value.substring(2, m_value.length() - 3))); if (m_value[1] == 'o' || m_value[1] == 'O') return MUST(Crypto::SignedBigInteger::from_base(8, m_value.substring(2, m_value.length() - 3))); if (m_value[1] == 'b' || m_value[1] == 'B') return MUST(Crypto::SignedBigInteger::from_base(2, m_value.substring(2, m_value.length() - 3))); return MUST(Crypto::SignedBigInteger::from_base(10, m_value.substring(0, m_value.length() - 1))); }(); generator.emit(integer); return {}; } Bytecode::CodeGenerationErrorOr StringLiteral::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); generator.emit(generator.intern_string(m_value)); return {}; } Bytecode::CodeGenerationErrorOr RegExpLiteral::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); auto source_index = generator.intern_string(m_pattern); auto flags_index = generator.intern_string(m_flags); auto regex_index = generator.intern_regex(Bytecode::ParsedRegex { .regex = m_parsed_regex, .pattern = m_parsed_pattern, .flags = m_parsed_flags, }); generator.emit(source_index, flags_index, regex_index); return {}; } Bytecode::CodeGenerationErrorOr Identifier::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (is_global()) { generator.emit(generator.intern_identifier(m_string), generator.next_global_variable_cache()); } else if (is_local()) { generator.emit(local_variable_index()); } else { generator.emit(generator.intern_identifier(m_string), generator.next_environment_variable_cache()); } return {}; } static Bytecode::CodeGenerationErrorOr arguments_to_array_for_call(Bytecode::Generator& generator, ReadonlySpan arguments) { if (arguments.is_empty()) { generator.emit(); return {}; } auto first_spread = find_if(arguments.begin(), arguments.end(), [](auto el) { return el.is_spread; }); Bytecode::Register args_start_reg { 0 }; for (auto it = arguments.begin(); it != first_spread; ++it) { auto reg = generator.allocate_register(); if (args_start_reg.index() == 0) args_start_reg = reg; } u32 i = 0; for (auto it = arguments.begin(); it != first_spread; ++it, ++i) { VERIFY(it->is_spread == false); Bytecode::Register reg { args_start_reg.index() + i }; TRY(it->value->generate_bytecode(generator)); generator.emit(reg); } if (first_spread.index() != 0) generator.emit_with_extra_register_slots(2u, AK::Array { args_start_reg, Bytecode::Register { args_start_reg.index() + static_cast(first_spread.index() - 1) } }); else generator.emit(); if (first_spread != arguments.end()) { auto array_reg = generator.allocate_register(); generator.emit(array_reg); for (auto it = first_spread; it != arguments.end(); ++it) { TRY(it->value->generate_bytecode(generator)); generator.emit(array_reg, it->is_spread); } generator.emit(array_reg); } return {}; } Bytecode::CodeGenerationErrorOr SuperCall::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (m_is_synthetic == IsPartOfSyntheticConstructor::Yes) { // NOTE: This is the case where we have a fake constructor(...args) { super(...args); } which // shouldn't call @@iterator of %Array.prototype%. VERIFY(m_arguments.size() == 1); VERIFY(m_arguments[0].is_spread); auto const& argument = m_arguments[0]; // This generates a single argument, which will be implicitly passed in accumulator MUST(argument.value->generate_bytecode(generator)); } else { TRY(arguments_to_array_for_call(generator, m_arguments)); } generator.emit(m_is_synthetic == IsPartOfSyntheticConstructor::Yes); return {}; } static Bytecode::CodeGenerationErrorOr generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode, Bytecode::Register const& value_reg, bool create_variables); Bytecode::CodeGenerationErrorOr AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (m_op == AssignmentOp::Assignment) { // AssignmentExpression : LeftHandSideExpression = AssignmentExpression return m_lhs.visit( // 1. If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then [&](NonnullRefPtr const& lhs) -> Bytecode::CodeGenerationErrorOr { // a. Let lref be the result of evaluating LeftHandSideExpression. // b. ReturnIfAbrupt(lref). Optional base_object_register; Optional computed_property_register; Optional this_value_register; bool lhs_is_super_expression = false; if (is(*lhs)) { auto& expression = static_cast(*lhs); lhs_is_super_expression = is(expression.object()); base_object_register = generator.allocate_register(); if (!lhs_is_super_expression) { TRY(expression.object().generate_bytecode(generator)); generator.emit(*base_object_register); } else { // https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation // 1. Let env be GetThisEnvironment(). // 2. Let actualThis be ? env.GetThisBinding(). this_value_register = generator.allocate_register(); generator.emit(); generator.emit(*this_value_register); // SuperProperty : super [ Expression ] // 3. Let propertyNameReference be ? Evaluation of Expression. // 4. Let propertyNameValue be ? GetValue(propertyNameReference). } if (expression.is_computed()) { TRY(expression.property().generate_bytecode(generator)); computed_property_register = generator.allocate_register(); generator.emit(*computed_property_register); // To be continued later with PutByValue. } else if (expression.property().is_identifier()) { // Do nothing, this will be handled by PutById later. } else if (expression.property().is_private_identifier()) { // Do nothing, this will be handled by PutPrivateById later. } else { return Bytecode::CodeGenerationError { &expression, "Unimplemented non-computed member expression"sv }; } if (lhs_is_super_expression) { // 5/7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict). // https://tc39.es/ecma262/#sec-makesuperpropertyreference // 1. Let env be GetThisEnvironment(). // 2. Assert: env.HasSuperBinding() is true. // 3. Let baseValue be ? env.GetSuperBase(). // 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }. generator.emit(); generator.emit(*base_object_register); } } else if (is(*lhs)) { // NOTE: For Identifiers, we cannot perform GetVariable and then write into the reference it retrieves, only SetVariable can do this. // FIXME: However, this breaks spec as we are doing variable lookup after evaluating the RHS. This is observable in an object environment, where we visibly perform HasOwnProperty and Get(@@unscopables) on the binded object. } else { TRY(lhs->generate_bytecode(generator)); } // FIXME: c. If IsAnonymousFunctionDefinition(AssignmentExpression) and IsIdentifierRef of LeftHandSideExpression are both true, then // i. Let rval be ? NamedEvaluation of AssignmentExpression with argument lref.[[ReferencedName]]. // d. Else, // i. Let rref be the result of evaluating AssignmentExpression. // ii. Let rval be ? GetValue(rref). if (lhs->is_identifier()) { TRY(generator.emit_named_evaluation_if_anonymous_function(*m_rhs, generator.intern_identifier(static_cast(*lhs).string()))); } else { TRY(m_rhs->generate_bytecode(generator)); } // e. Perform ? PutValue(lref, rval). if (is(*lhs)) { auto& identifier = static_cast(*lhs); generator.emit_set_variable(identifier); } else if (is(*lhs)) { auto& expression = static_cast(*lhs); if (expression.is_computed()) { if (!lhs_is_super_expression) generator.emit(*base_object_register, *computed_property_register); else generator.emit(*base_object_register, *computed_property_register, *this_value_register); } else if (expression.property().is_identifier()) { auto identifier_table_ref = generator.intern_identifier(verify_cast(expression.property()).string()); if (!lhs_is_super_expression) generator.emit(*base_object_register, identifier_table_ref, Bytecode::Op::PropertyKind::KeyValue, generator.next_property_lookup_cache()); else generator.emit(*base_object_register, *this_value_register, identifier_table_ref, Bytecode::Op::PropertyKind::KeyValue, generator.next_property_lookup_cache()); } else if (expression.property().is_private_identifier()) { auto identifier_table_ref = generator.intern_identifier(verify_cast(expression.property()).string()); generator.emit(*base_object_register, identifier_table_ref); } else { return Bytecode::CodeGenerationError { &expression, "Unimplemented non-computed member expression"sv }; } } else { return Bytecode::CodeGenerationError { lhs, "Unimplemented/invalid node used a reference"sv }; } // f. Return rval. // NOTE: This is already in the accumulator. return {}; }, // 2. Let assignmentPattern be the AssignmentPattern that is covered by LeftHandSideExpression. [&](NonnullRefPtr const& pattern) -> Bytecode::CodeGenerationErrorOr { // 3. Let rref be the result of evaluating AssignmentExpression. // 4. Let rval be ? GetValue(rref). TRY(m_rhs->generate_bytecode(generator)); auto value_register = generator.allocate_register(); generator.emit(value_register); // 5. Perform ? DestructuringAssignmentEvaluation of assignmentPattern with argument rval. TRY(generate_binding_pattern_bytecode(generator, pattern, Bytecode::Op::SetVariable::InitializationMode::Set, value_register, false)); // 6. Return rval. generator.emit(value_register); return {}; }); } VERIFY(m_lhs.has>()); auto& lhs = m_lhs.get>(); auto reference_registers = TRY(generator.emit_load_from_reference(lhs, Bytecode::Generator::CollectRegisters::Yes)); Bytecode::BasicBlock* rhs_block_ptr { nullptr }; Bytecode::BasicBlock* end_block_ptr { nullptr }; // Logical assignments short circuit. if (m_op == AssignmentOp::AndAssignment) { // &&= rhs_block_ptr = &generator.make_block(); end_block_ptr = &generator.make_block(); generator.emit( Bytecode::Label { *rhs_block_ptr }, Bytecode::Label { *end_block_ptr }); } else if (m_op == AssignmentOp::OrAssignment) { // ||= rhs_block_ptr = &generator.make_block(); end_block_ptr = &generator.make_block(); generator.emit( Bytecode::Label { *end_block_ptr }, Bytecode::Label { *rhs_block_ptr }); } else if (m_op == AssignmentOp::NullishAssignment) { // ??= rhs_block_ptr = &generator.make_block(); end_block_ptr = &generator.make_block(); generator.emit( Bytecode::Label { *rhs_block_ptr }, Bytecode::Label { *end_block_ptr }); } if (rhs_block_ptr) generator.switch_to_basic_block(*rhs_block_ptr); // lhs_reg is a part of the rhs_block because the store isn't necessary // if the logical assignment condition fails. auto lhs_reg = generator.allocate_register(); generator.emit(lhs_reg); if (lhs->is_identifier()) TRY(generator.emit_named_evaluation_if_anonymous_function(*m_rhs, generator.intern_identifier(static_cast(*lhs).string()))); else TRY(m_rhs->generate_bytecode(generator)); switch (m_op) { case AssignmentOp::AdditionAssignment: generator.emit(lhs_reg); break; case AssignmentOp::SubtractionAssignment: generator.emit(lhs_reg); break; case AssignmentOp::MultiplicationAssignment: generator.emit(lhs_reg); break; case AssignmentOp::DivisionAssignment: generator.emit(lhs_reg); break; case AssignmentOp::ModuloAssignment: generator.emit(lhs_reg); break; case AssignmentOp::ExponentiationAssignment: generator.emit(lhs_reg); break; case AssignmentOp::BitwiseAndAssignment: generator.emit(lhs_reg); break; case AssignmentOp::BitwiseOrAssignment: generator.emit(lhs_reg); break; case AssignmentOp::BitwiseXorAssignment: generator.emit(lhs_reg); break; case AssignmentOp::LeftShiftAssignment: generator.emit(lhs_reg); break; case AssignmentOp::RightShiftAssignment: generator.emit(lhs_reg); break; case AssignmentOp::UnsignedRightShiftAssignment: generator.emit(lhs_reg); break; case AssignmentOp::AndAssignment: case AssignmentOp::OrAssignment: case AssignmentOp::NullishAssignment: break; // These are handled above. default: return Bytecode::CodeGenerationError { this, "Unimplemented operation"sv, }; } if (reference_registers.has_value()) TRY(generator.emit_store_to_reference(*reference_registers)); else TRY(generator.emit_store_to_reference(lhs)); if (end_block_ptr) { generator.emit(Bytecode::Label { *end_block_ptr }); generator.switch_to_basic_block(*end_block_ptr); } return {}; } // 14.13.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation // LabelledStatement : LabelIdentifier : LabelledItem Bytecode::CodeGenerationErrorOr LabelledStatement::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // Return ? LabelledEvaluation of this LabelledStatement with argument « ». return generate_labelled_evaluation(generator, {}); } // 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation // LabelledStatement : LabelIdentifier : LabelledItem Bytecode::CodeGenerationErrorOr LabelledStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector const& label_set) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // Convert the m_labelled_item NNRP to a reference early so we don't have to do it every single time we want to use it. auto const& labelled_item = *m_labelled_item; // 1. Let label be the StringValue of LabelIdentifier. // NOTE: Not necessary, this is m_label. // 2. Let newLabelSet be the list-concatenation of labelSet and « label ». // FIXME: Avoid copy here. auto new_label_set = label_set; new_label_set.append(m_label); // 3. Let stmtResult be LabelledEvaluation of LabelledItem with argument newLabelSet. // NOTE: stmtResult will be in the accumulator after running the generated bytecode. if (is(labelled_item)) { auto const& iteration_statement = static_cast(labelled_item); TRY(iteration_statement.generate_labelled_evaluation(generator, new_label_set)); } else if (is(labelled_item)) { auto const& switch_statement = static_cast(labelled_item); TRY(switch_statement.generate_labelled_evaluation(generator, new_label_set)); } else if (is(labelled_item)) { auto const& labelled_statement = static_cast(labelled_item); TRY(labelled_statement.generate_labelled_evaluation(generator, new_label_set)); } else { auto& labelled_break_block = generator.make_block(); // NOTE: We do not need a continuable scope as `continue;` is not allowed outside of iteration statements, throwing a SyntaxError in the parser. generator.begin_breakable_scope(Bytecode::Label { labelled_break_block }, new_label_set); TRY(labelled_item.generate_bytecode(generator)); generator.end_breakable_scope(); if (!generator.is_current_block_terminated()) { generator.emit(Bytecode::Label { labelled_break_block }); } generator.switch_to_basic_block(labelled_break_block); } // 4. If stmtResult.[[Type]] is break and SameValue(stmtResult.[[Target]], label) is true, then // a. Set stmtResult to NormalCompletion(stmtResult.[[Value]]). // NOTE: These steps are performed by making labelled break jump straight to the appropriate break block, which preserves the statement result's value in the accumulator. // 5. Return Completion(stmtResult). // NOTE: This is in the accumulator. return {}; } Bytecode::CodeGenerationErrorOr IterationStatement::generate_labelled_evaluation(Bytecode::Generator&, Vector const&) const { return Bytecode::CodeGenerationError { this, "Missing generate_labelled_evaluation()"sv, }; } Bytecode::CodeGenerationErrorOr WhileStatement::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); return generate_labelled_evaluation(generator, {}); } Bytecode::CodeGenerationErrorOr WhileStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector const& label_set) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // test // jump if_false (true) end (false) body // body // jump always (true) test // end auto& test_block = generator.make_block(); auto& body_block = generator.make_block(); auto& load_result_and_jump_to_end_block = generator.make_block(); auto& end_block = generator.make_block(); // Init result register generator.emit(js_undefined()); auto result_reg = generator.allocate_register(); // jump to the test block generator.emit(Bytecode::Label { test_block }); generator.switch_to_basic_block(test_block); generator.emit(result_reg); TRY(m_test->generate_bytecode(generator)); generator.emit( Bytecode::Label { body_block }, Bytecode::Label { load_result_and_jump_to_end_block }); generator.switch_to_basic_block(body_block); generator.begin_continuable_scope(Bytecode::Label { test_block }, label_set); generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set); generator.emit(js_undefined()); TRY(m_body->generate_bytecode(generator)); generator.end_breakable_scope(); generator.end_continuable_scope(); if (!generator.is_current_block_terminated()) { generator.emit(Bytecode::Label { test_block }); } generator.switch_to_basic_block(load_result_and_jump_to_end_block); generator.emit(result_reg); generator.emit(Bytecode::Label { end_block }); generator.switch_to_basic_block(end_block); return {}; } Bytecode::CodeGenerationErrorOr DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); return generate_labelled_evaluation(generator, {}); } Bytecode::CodeGenerationErrorOr DoWhileStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector const& label_set) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // jump always (true) body // test // jump if_false (true) end (false) body // body // jump always (true) test // end auto& test_block = generator.make_block(); auto& body_block = generator.make_block(); auto& load_result_and_jump_to_end_block = generator.make_block(); auto& end_block = generator.make_block(); // Init result register generator.emit(js_undefined()); auto result_reg = generator.allocate_register(); generator.emit(result_reg); // jump to the body block generator.emit(Bytecode::Label { body_block }); generator.switch_to_basic_block(test_block); generator.emit(result_reg); TRY(m_test->generate_bytecode(generator)); generator.emit( Bytecode::Label { body_block }, Bytecode::Label { load_result_and_jump_to_end_block }); generator.switch_to_basic_block(body_block); generator.begin_continuable_scope(Bytecode::Label { test_block }, label_set); generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set); TRY(m_body->generate_bytecode(generator)); generator.end_breakable_scope(); generator.end_continuable_scope(); if (!generator.is_current_block_terminated()) { generator.emit(Bytecode::Label { test_block }); } generator.switch_to_basic_block(load_result_and_jump_to_end_block); generator.emit(result_reg); generator.emit(Bytecode::Label { end_block }); generator.switch_to_basic_block(end_block); return {}; } Bytecode::CodeGenerationErrorOr ForStatement::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); return generate_labelled_evaluation(generator, {}); } Bytecode::CodeGenerationErrorOr ForStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector const& label_set) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // init // jump always (true) test // test // jump if_true (true) body (false) end // body // jump always (true) update // update // jump always (true) test // end // If 'test' is missing, fuse the 'test' and 'body' basic blocks // If 'update' is missing, fuse the 'body' and 'update' basic blocks Bytecode::BasicBlock* test_block_ptr { nullptr }; Bytecode::BasicBlock* body_block_ptr { nullptr }; Bytecode::BasicBlock* update_block_ptr { nullptr }; Bytecode::BasicBlock* load_result_and_jump_to_end_block_ptr { nullptr }; auto& end_block = generator.make_block(); bool has_lexical_environment = false; if (m_init) { if (m_init->is_variable_declaration()) { auto& variable_declaration = verify_cast(*m_init); auto has_non_local_variables = false; MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) { if (!identifier.is_local()) has_non_local_variables = true; })); if (variable_declaration.is_lexical_declaration() && has_non_local_variables) { has_lexical_environment = true; // FIXME: Is Block correct? generator.begin_variable_scope(); bool is_const = variable_declaration.is_constant_declaration(); // NOTE: Nothing in the callback throws an exception. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) { if (identifier.is_local()) return; auto index = generator.intern_identifier(identifier.string()); generator.emit(index, Bytecode::Op::EnvironmentMode::Lexical, is_const); })); } } TRY(m_init->generate_bytecode(generator)); } body_block_ptr = &generator.make_block(); if (m_test) test_block_ptr = &generator.make_block(); else test_block_ptr = body_block_ptr; if (m_update) update_block_ptr = &generator.make_block(); else update_block_ptr = body_block_ptr; generator.emit(js_undefined()); auto result_reg = generator.allocate_register(); if (m_test && m_update) generator.emit(result_reg); generator.emit(Bytecode::Label { *test_block_ptr }); if (m_test) { load_result_and_jump_to_end_block_ptr = &generator.make_block(); generator.switch_to_basic_block(*test_block_ptr); if (!m_update) generator.emit(result_reg); TRY(m_test->generate_bytecode(generator)); generator.emit( Bytecode::Label { *body_block_ptr }, Bytecode::Label { *load_result_and_jump_to_end_block_ptr }); } if (m_update) { generator.switch_to_basic_block(*update_block_ptr); if (m_test) generator.emit(result_reg); TRY(m_update->generate_bytecode(generator)); generator.emit(Bytecode::Label { *test_block_ptr }); } generator.switch_to_basic_block(*body_block_ptr); generator.begin_continuable_scope(Bytecode::Label { m_update ? *update_block_ptr : *test_block_ptr }, label_set); generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set); generator.emit(js_undefined()); TRY(m_body->generate_bytecode(generator)); generator.end_breakable_scope(); generator.end_continuable_scope(); if (!generator.is_current_block_terminated()) { if (m_update) { generator.emit(Bytecode::Label { *update_block_ptr }); } else { generator.emit(Bytecode::Label { *test_block_ptr }); } } if (load_result_and_jump_to_end_block_ptr) { generator.switch_to_basic_block(*load_result_and_jump_to_end_block_ptr); generator.emit(result_reg); generator.emit(Bytecode::Label { end_block }); } generator.switch_to_basic_block(end_block); if (has_lexical_environment) generator.end_variable_scope(); return {}; } Bytecode::CodeGenerationErrorOr ObjectExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); generator.emit(); if (m_properties.is_empty()) return {}; auto object_reg = generator.allocate_register(); generator.emit(object_reg); generator.push_home_object(object_reg); for (auto& property : m_properties) { Bytecode::Op::PropertyKind property_kind; switch (property->type()) { case ObjectProperty::Type::KeyValue: property_kind = Bytecode::Op::PropertyKind::DirectKeyValue; break; case ObjectProperty::Type::Getter: property_kind = Bytecode::Op::PropertyKind::Getter; break; case ObjectProperty::Type::Setter: property_kind = Bytecode::Op::PropertyKind::Setter; break; case ObjectProperty::Type::Spread: property_kind = Bytecode::Op::PropertyKind::Spread; break; case ObjectProperty::Type::ProtoSetter: property_kind = Bytecode::Op::PropertyKind::ProtoSetter; break; } if (is(property->key())) { auto& string_literal = static_cast(property->key()); Bytecode::IdentifierTableIndex key_name = generator.intern_identifier(string_literal.value()); if (property_kind == Bytecode::Op::PropertyKind::ProtoSetter) { TRY(property->value().generate_bytecode(generator)); } else if (property_kind != Bytecode::Op::PropertyKind::Spread) { ByteString identifier = string_literal.value(); if (property_kind == Bytecode::Op::PropertyKind::Getter) identifier = ByteString::formatted("get {}", identifier); else if (property_kind == Bytecode::Op::PropertyKind::Setter) identifier = ByteString::formatted("set {}", identifier); auto name = generator.intern_identifier(identifier); TRY(generator.emit_named_evaluation_if_anonymous_function(property->value(), name)); } generator.emit(object_reg, key_name, property_kind, generator.next_property_lookup_cache()); } else { TRY(property->key().generate_bytecode(generator)); auto property_reg = generator.allocate_register(); generator.emit(property_reg); if (property_kind != Bytecode::Op::PropertyKind::Spread) TRY(property->value().generate_bytecode(generator)); generator.emit(object_reg, property_reg, property_kind); } } generator.emit(object_reg); generator.pop_home_object(); return {}; } Bytecode::CodeGenerationErrorOr ArrayExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (m_elements.is_empty()) { generator.emit(); return {}; } if (all_of(m_elements, [](auto element) { return !element || is(*element); })) { // If all elements are constant primitives, we can just emit a single instruction to initialize the array, // instead of emitting instructions to manually evaluate them one-by-one auto values = MUST(FixedArray::create(m_elements.size())); for (auto i = 0u; i < m_elements.size(); ++i) { if (!m_elements[i]) continue; values[i] = static_cast(*m_elements[i]).value(); } generator.emit(move(values)); return {}; } auto first_spread = find_if(m_elements.begin(), m_elements.end(), [](auto el) { return el && is(*el); }); Bytecode::Register args_start_reg { 0 }; for (auto it = m_elements.begin(); it != first_spread; ++it) { auto reg = generator.allocate_register(); if (args_start_reg.index() == 0) args_start_reg = reg; } u32 i = 0; for (auto it = m_elements.begin(); it != first_spread; ++it, ++i) { Bytecode::Register reg { args_start_reg.index() + i }; if (!*it) generator.emit(Value {}); else { TRY((*it)->generate_bytecode(generator)); } generator.emit(reg); } if (first_spread.index() != 0) generator.emit_with_extra_register_slots(2u, AK::Array { args_start_reg, Bytecode::Register { args_start_reg.index() + static_cast(first_spread.index() - 1) } }); else generator.emit(); if (first_spread != m_elements.end()) { auto array_reg = generator.allocate_register(); generator.emit(array_reg); for (auto it = first_spread; it != m_elements.end(); ++it) { if (!*it) { generator.emit(Value {}); generator.emit(array_reg, false); } else { TRY((*it)->generate_bytecode(generator)); generator.emit(array_reg, *it && is(**it)); } } generator.emit(array_reg); } return {}; } Bytecode::CodeGenerationErrorOr MemberExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); (void)TRY(generator.emit_load_from_reference(*this, Bytecode::Generator::CollectRegisters::No)); return {}; } Bytecode::CodeGenerationErrorOr FunctionDeclaration::generate_bytecode(Bytecode::Generator& generator) const { if (m_is_hoisted) { Bytecode::Generator::SourceLocationScope scope(generator, *this); auto index = generator.intern_identifier(name()); generator.emit(index, generator.next_environment_variable_cache()); generator.emit(index, generator.next_environment_variable_cache(), Bytecode::Op::SetVariable::InitializationMode::Set, Bytecode::Op::EnvironmentMode::Var); } return {}; } Bytecode::CodeGenerationErrorOr FunctionExpression::generate_bytecode_with_lhs_name(Bytecode::Generator& generator, Optional lhs_name) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); bool has_name = !name().is_empty(); Optional name_identifier; if (has_name) { generator.begin_variable_scope(); name_identifier = generator.intern_identifier(name()); generator.emit(*name_identifier, Bytecode::Op::EnvironmentMode::Lexical, true); } generator.emit_new_function(*this, lhs_name); if (has_name) { generator.emit(*name_identifier, generator.next_environment_variable_cache(), Bytecode::Op::SetVariable::InitializationMode::Initialize, Bytecode::Op::EnvironmentMode::Lexical); generator.end_variable_scope(); } return {}; } Bytecode::CodeGenerationErrorOr FunctionExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); return generate_bytecode_with_lhs_name(generator, {}); } static Bytecode::CodeGenerationErrorOr generate_object_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg, bool create_variables) { generator.emit(); Vector excluded_property_names; auto has_rest = false; if (pattern.entries.size() > 0) has_rest = pattern.entries[pattern.entries.size() - 1].is_rest; for (auto& [name, alias, initializer, is_rest] : pattern.entries) { if (is_rest) { VERIFY(!initializer); if (name.has>()) { auto identifier = name.get>(); auto interned_identifier = generator.intern_identifier(identifier->string()); generator.emit_with_extra_register_slots(excluded_property_names.size(), value_reg, excluded_property_names); if (create_variables) { VERIFY(!identifier->is_local()); generator.emit(interned_identifier, Bytecode::Op::EnvironmentMode::Lexical, false); } generator.emit_set_variable(*identifier, initialization_mode); return {}; } if (alias.has>()) { generator.emit_with_extra_register_slots(excluded_property_names.size(), value_reg, excluded_property_names); TRY(generator.emit_store_to_reference(alias.get>())); return {}; } VERIFY_NOT_REACHED(); } Bytecode::StringTableIndex name_index; if (name.has>()) { auto identifier = name.get>()->string(); name_index = generator.intern_string(identifier); if (has_rest) { auto excluded_name_reg = generator.allocate_register(); excluded_property_names.append(excluded_name_reg); generator.emit(name_index); generator.emit(excluded_name_reg); } generator.emit(value_reg); generator.emit_get_by_id(generator.intern_identifier(identifier)); } else { auto expression = name.get>(); TRY(expression->generate_bytecode(generator)); if (has_rest) { auto excluded_name_reg = generator.allocate_register(); excluded_property_names.append(excluded_name_reg); generator.emit(excluded_name_reg); } generator.emit(value_reg); } if (initializer) { auto& if_undefined_block = generator.make_block(); auto& if_not_undefined_block = generator.make_block(); generator.emit( Bytecode::Label { if_undefined_block }, Bytecode::Label { if_not_undefined_block }); generator.switch_to_basic_block(if_undefined_block); if (auto const* alias_identifier = alias.get_pointer>()) { TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*alias_identifier)->string()))); } else if (auto const* lhs = name.get_pointer>()) { TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*lhs)->string()))); } else { TRY(initializer->generate_bytecode(generator)); } generator.emit(Bytecode::Label { if_not_undefined_block }); generator.switch_to_basic_block(if_not_undefined_block); } if (alias.has>()) { auto& binding_pattern = *alias.get>(); auto nested_value_reg = generator.allocate_register(); generator.emit(nested_value_reg); TRY(generate_binding_pattern_bytecode(generator, binding_pattern, initialization_mode, nested_value_reg, create_variables)); } else if (alias.has()) { if (name.has>()) { // This needs some sort of SetVariableByValue opcode, as it's a runtime binding return Bytecode::CodeGenerationError { name.get>().ptr(), "Unimplemented name/alias pair: Empty/Expression"sv, }; } auto const& identifier = *name.get>(); auto identifier_ref = generator.intern_identifier(identifier.string()); if (create_variables) generator.emit(identifier_ref, Bytecode::Op::EnvironmentMode::Lexical, false); generator.emit_set_variable(identifier, initialization_mode); } else if (alias.has>()) { TRY(generator.emit_store_to_reference(alias.get>())); } else { auto const& identifier = *alias.get>(); auto identifier_ref = generator.intern_identifier(identifier.string()); if (create_variables) generator.emit(identifier_ref, Bytecode::Op::EnvironmentMode::Lexical, false); generator.emit_set_variable(identifier, initialization_mode); } } return {}; } static Bytecode::CodeGenerationErrorOr generate_array_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg, bool create_variables) { /* * Consider the following destructuring assignment: * * let [a, b, c, d, e] = o; * * It would be fairly trivial to just loop through this iterator, getting the value * at each step and assigning them to the binding sequentially. However, this is not * correct: once an iterator is exhausted, it must not be called again. This complicates * the bytecode. In order to accomplish this, we do the following: * * - Reserve a special boolean register which holds 'true' if the iterator is exhausted, * and false otherwise * - When we are retrieving the value which should be bound, we first check this register. * If it is 'true', we load undefined into the accumulator. Otherwise, we grab the next * value from the iterator and store it into the accumulator. * * Note that the is_exhausted register does not need to be loaded with false because the * first IteratorNext bytecode is _not_ proceeded by an exhausted check, as it is * unnecessary. */ auto is_iterator_exhausted_register = generator.allocate_register(); generator.emit(Value(false)); generator.emit(is_iterator_exhausted_register); auto iterator_reg = generator.allocate_register(); generator.emit(value_reg); generator.emit(); generator.emit(iterator_reg); bool first = true; auto temp_iterator_result_reg = generator.allocate_register(); auto assign_accumulator_to_alias = [&](auto& alias) { return alias.visit( [&](Empty) -> Bytecode::CodeGenerationErrorOr { // This element is an elision return {}; }, [&](NonnullRefPtr const& identifier) -> Bytecode::CodeGenerationErrorOr { auto interned_index = generator.intern_identifier(identifier->string()); if (create_variables) generator.emit(interned_index, Bytecode::Op::EnvironmentMode::Lexical, false); generator.emit_set_variable(*identifier, initialization_mode); return {}; }, [&](NonnullRefPtr const& pattern) -> Bytecode::CodeGenerationErrorOr { // Store the accumulator value in a permanent register auto target_reg = generator.allocate_register(); generator.emit(target_reg); return generate_binding_pattern_bytecode(generator, pattern, initialization_mode, target_reg, create_variables); }, [&](NonnullRefPtr const& expr) -> Bytecode::CodeGenerationErrorOr { return generator.emit_store_to_reference(*expr); }); }; for (auto& [name, alias, initializer, is_rest] : pattern.entries) { VERIFY(name.has()); if (is_rest) { VERIFY(!initializer); if (first) { // The iterator has not been called, and is thus known to be not exhausted generator.emit(iterator_reg); generator.emit(); } else { auto& if_exhausted_block = generator.make_block(); auto& if_not_exhausted_block = generator.make_block(); auto& continuation_block = generator.make_block(); generator.emit(is_iterator_exhausted_register); generator.emit( Bytecode::Label { if_exhausted_block }, Bytecode::Label { if_not_exhausted_block }); generator.switch_to_basic_block(if_exhausted_block); generator.emit(); generator.emit(Bytecode::Label { continuation_block }); generator.switch_to_basic_block(if_not_exhausted_block); generator.emit(iterator_reg); generator.emit(); generator.emit(Bytecode::Label { continuation_block }); generator.switch_to_basic_block(continuation_block); } return assign_accumulator_to_alias(alias); } // In the first iteration of the loop, a few things are true which can save // us some bytecode: // - the iterator result is still in the accumulator, so we can avoid a load // - the iterator is not yet exhausted, which can save us a jump and some // creation auto& iterator_is_exhausted_block = generator.make_block(); if (!first) { auto& iterator_is_not_exhausted_block = generator.make_block(); generator.emit(is_iterator_exhausted_register); generator.emit( Bytecode::Label { iterator_is_exhausted_block }, Bytecode::Label { iterator_is_not_exhausted_block }); generator.switch_to_basic_block(iterator_is_not_exhausted_block); generator.emit(iterator_reg); } generator.emit(); generator.emit(temp_iterator_result_reg); generator.emit_iterator_complete(); generator.emit(is_iterator_exhausted_register); // We still have to check for exhaustion here. If the iterator is exhausted, // we need to bail before trying to get the value auto& no_bail_block = generator.make_block(); generator.emit( Bytecode::Label { iterator_is_exhausted_block }, Bytecode::Label { no_bail_block }); generator.switch_to_basic_block(no_bail_block); // Get the next value in the iterator generator.emit(temp_iterator_result_reg); generator.emit_iterator_value(); auto& create_binding_block = generator.make_block(); generator.emit(Bytecode::Label { create_binding_block }); // The iterator is exhausted, so we just load undefined and continue binding generator.switch_to_basic_block(iterator_is_exhausted_block); generator.emit(js_undefined()); generator.emit(Bytecode::Label { create_binding_block }); // Create the actual binding. The value which this entry must bind is now in the // accumulator. We can proceed, processing the alias as a nested destructuring // pattern if necessary. generator.switch_to_basic_block(create_binding_block); if (initializer) { auto& value_is_undefined_block = generator.make_block(); auto& value_is_not_undefined_block = generator.make_block(); generator.emit( Bytecode::Label { value_is_undefined_block }, Bytecode::Label { value_is_not_undefined_block }); generator.switch_to_basic_block(value_is_undefined_block); if (auto const* alias_identifier = alias.get_pointer>()) { TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*alias_identifier)->string()))); } else if (auto const* name_identifier = name.get_pointer>()) { TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, generator.intern_identifier((*name_identifier)->string()))); } else { TRY(initializer->generate_bytecode(generator)); } generator.emit(Bytecode::Label { value_is_not_undefined_block }); generator.switch_to_basic_block(value_is_not_undefined_block); } TRY(assign_accumulator_to_alias(alias)); first = false; } auto& done_block = generator.make_block(); auto& not_done_block = generator.make_block(); generator.emit(is_iterator_exhausted_register); generator.emit( Bytecode::Label { done_block }, Bytecode::Label { not_done_block }); generator.switch_to_basic_block(not_done_block); generator.emit(iterator_reg); generator.emit(Completion::Type::Normal, Optional {}); generator.emit(Bytecode::Label { done_block }); generator.switch_to_basic_block(done_block); return {}; } static Bytecode::CodeGenerationErrorOr generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg, bool create_variables) { if (pattern.kind == BindingPattern::Kind::Object) return generate_object_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg, create_variables); return generate_array_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg, create_variables); } static Bytecode::CodeGenerationErrorOr assign_accumulator_to_variable_declarator(Bytecode::Generator& generator, VariableDeclarator const& declarator, VariableDeclaration const& declaration) { auto initialization_mode = declaration.is_lexical_declaration() ? Bytecode::Op::SetVariable::InitializationMode::Initialize : Bytecode::Op::SetVariable::InitializationMode::Set; return declarator.target().visit( [&](NonnullRefPtr const& id) -> Bytecode::CodeGenerationErrorOr { generator.emit_set_variable(*id, initialization_mode); return {}; }, [&](NonnullRefPtr const& pattern) -> Bytecode::CodeGenerationErrorOr { auto value_register = generator.allocate_register(); generator.emit(value_register); return generate_binding_pattern_bytecode(generator, pattern, initialization_mode, value_register, false); }); } Bytecode::CodeGenerationErrorOr VariableDeclaration::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); // The completion value of a VariableDeclaration is empty, but there might already be a non-empty // completion value in the accumulator. We need to save it and restore it after the declaration executed. auto saved_accumulator = generator.allocate_register(); generator.emit(saved_accumulator); for (auto& declarator : m_declarations) { if (declarator->init()) { if (auto const* lhs = declarator->target().get_pointer>()) { TRY(generator.emit_named_evaluation_if_anonymous_function(*declarator->init(), generator.intern_identifier((*lhs)->string()))); } else { TRY(declarator->init()->generate_bytecode(generator)); } TRY(assign_accumulator_to_variable_declarator(generator, declarator, *this)); } else if (m_declaration_kind != DeclarationKind::Var) { generator.emit(js_undefined()); TRY(assign_accumulator_to_variable_declarator(generator, declarator, *this)); } } generator.emit(saved_accumulator); return {}; } static Bytecode::CodeGenerationErrorOr get_base_and_value_from_member_expression(Bytecode::Generator& generator, MemberExpression const& member_expression, Bytecode::Register this_reg) { // https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation if (is(member_expression.object())) { // 1. Let env be GetThisEnvironment(). // 2. Let actualThis be ? env.GetThisBinding(). generator.emit(); generator.emit(this_reg); Optional computed_property_value_register; if (member_expression.is_computed()) { // SuperProperty : super [ Expression ] // 3. Let propertyNameReference be ? Evaluation of Expression. // 4. Let propertyNameValue be ? GetValue(propertyNameReference). TRY(member_expression.property().generate_bytecode(generator)); computed_property_value_register = generator.allocate_register(); generator.emit(*computed_property_value_register); } // 5/7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict). // https://tc39.es/ecma262/#sec-makesuperpropertyreference // 1. Let env be GetThisEnvironment(). // 2. Assert: env.HasSuperBinding() is true. // 3. Let baseValue be ? env.GetSuperBase(). generator.emit(); // 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }. if (computed_property_value_register.has_value()) { // 5. Let propertyKey be ? ToPropertyKey(propertyNameValue). // FIXME: This does ToPropertyKey out of order, which is observable by Symbol.toPrimitive! auto super_base_register = generator.allocate_register(); generator.emit(super_base_register); generator.emit(*computed_property_value_register); generator.emit(super_base_register, this_reg); } else { // 3. Let propertyKey be StringValue of IdentifierName. auto identifier_table_ref = generator.intern_identifier(verify_cast(member_expression.property()).string()); generator.emit_get_by_id_with_this(identifier_table_ref, this_reg); } } else { TRY(member_expression.object().generate_bytecode(generator)); generator.emit(this_reg); if (member_expression.is_computed()) { TRY(member_expression.property().generate_bytecode(generator)); generator.emit(this_reg); } else if (is(member_expression.property())) { generator.emit(generator.intern_identifier(verify_cast(member_expression.property()).string())); } else { generator.emit_get_by_id(generator.intern_identifier(verify_cast(member_expression.property()).string())); } } return {}; } static Bytecode::CodeGenerationErrorOr generate_optional_chain(Bytecode::Generator& generator, OptionalChain const& optional_chain, Bytecode::Register current_value_register, Bytecode::Register current_base_register); Bytecode::CodeGenerationErrorOr CallExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); auto callee_reg = generator.allocate_register(); auto this_reg = generator.allocate_register(); generator.emit(js_undefined()); generator.emit(this_reg); Optional builtin; if (is(this)) { TRY(m_callee->generate_bytecode(generator)); generator.emit(callee_reg); } else if (is(*m_callee)) { auto& member_expression = static_cast(*m_callee); TRY(get_base_and_value_from_member_expression(generator, member_expression, this_reg)); generator.emit(callee_reg); builtin = Bytecode::get_builtin(member_expression); } else if (is(*m_callee)) { auto& optional_chain = static_cast(*m_callee); TRY(generate_optional_chain(generator, optional_chain, callee_reg, this_reg)); } else if (is(*m_callee)) { // If the callee is an identifier, we may need to extract a `this` value. // This is important when we're inside a `with` statement and calling a method on // the environment's binding object. // NOTE: If the identifier refers to a known "local" or "global", we know it can't be // a `with` binding, so we can skip this. auto& identifier = static_cast(*m_callee); if (!identifier.is_local() && !identifier.is_global()) { generator.emit(generator.intern_identifier(identifier.string()), callee_reg, this_reg, generator.next_environment_variable_cache()); } else { TRY(m_callee->generate_bytecode(generator)); generator.emit(callee_reg); } } else { // FIXME: this = global object in sloppy mode. TRY(m_callee->generate_bytecode(generator)); generator.emit(callee_reg); } Bytecode::Op::CallType call_type; if (is(*this)) { call_type = Bytecode::Op::CallType::Construct; } else if (m_callee->is_identifier() && static_cast(*m_callee).string() == "eval"sv) { call_type = Bytecode::Op::CallType::DirectEval; } else { call_type = Bytecode::Op::CallType::Call; } Optional expression_string_index; if (auto expression_string = this->expression_string(); expression_string.has_value()) expression_string_index = generator.intern_string(expression_string.release_value()); bool has_spread = any_of(arguments(), [](auto& argument) { return argument.is_spread; }); if (has_spread) { TRY(arguments_to_array_for_call(generator, arguments())); generator.emit(call_type, callee_reg, this_reg, expression_string_index); } else { Optional first_argument_reg {}; for (size_t i = 0; i < arguments().size(); ++i) { auto reg = generator.allocate_register(); if (!first_argument_reg.has_value()) first_argument_reg = reg; } u32 register_offset = 0; for (auto const& argument : arguments()) { TRY(argument.value->generate_bytecode(generator)); generator.emit(Bytecode::Register { first_argument_reg.value().index() + register_offset }); register_offset += 1; } generator.emit(call_type, callee_reg, this_reg, first_argument_reg.value_or(Bytecode::Register { 0 }), arguments().size(), expression_string_index, builtin); } return {}; } static void generate_await(Bytecode::Generator& generator, Bytecode::Register received_completion_register, Bytecode::Register received_completion_type_register, Bytecode::Register received_completion_value_register, Bytecode::IdentifierTableIndex type_identifier, Bytecode::IdentifierTableIndex value_identifier); // https://tc39.es/ecma262/#sec-return-statement-runtime-semantics-evaluation Bytecode::CodeGenerationErrorOr ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); if (m_argument) { // ReturnStatement : return Expression ; // 1. Let exprRef be ? Evaluation of Expression. // 2. Let exprValue be ? GetValue(exprRef). TRY(m_argument->generate_bytecode(generator)); // 3. If GetGeneratorKind() is async, set exprValue to ? Await(exprValue). // Spec Issue?: The spec doesn't seem to do implicit await on explicit return for async functions, but does for // async generators. However, the major engines do so, and this is observable via constructor lookups // on Promise objects and custom thenables. // See: https://tc39.es/ecma262/#sec-asyncblockstart // c. Assert: If we return here, the async function either threw an exception or performed an implicit or explicit return; all awaiting is done. if (generator.is_in_async_function()) { auto received_completion_register = generator.allocate_register(); auto received_completion_type_register = generator.allocate_register(); auto received_completion_value_register = generator.allocate_register(); auto type_identifier = generator.intern_identifier("type"); auto value_identifier = generator.intern_identifier("value"); generate_await(generator, received_completion_register, received_completion_type_register, received_completion_value_register, type_identifier, value_identifier); } // 4. Return Completion Record { [[Type]]: return, [[Value]]: exprValue, [[Target]]: empty }. } else { // ReturnStatement : return ; // 1. Return Completion Record { [[Type]]: return, [[Value]]: undefined, [[Target]]: empty }. generator.emit(js_undefined()); } if (generator.is_in_generator_or_async_function()) { generator.perform_needed_unwinds(); generator.emit(nullptr); } else { generator.perform_needed_unwinds(); generator.emit(); } return {}; } static void get_received_completion_type_and_value(Bytecode::Generator& generator, Bytecode::Register received_completion_register, Bytecode::Register received_completion_type_register, Bytecode::Register received_completion_value_register, Bytecode::IdentifierTableIndex type_identifier, Bytecode::IdentifierTableIndex value_identifier) { // The accumulator is set to an object, for example: { "type": 1 (normal), value: 1337 } generator.emit(received_completion_register); generator.emit_get_by_id(type_identifier); generator.emit(received_completion_type_register); generator.emit(received_completion_register); generator.emit_get_by_id(value_identifier); generator.emit(received_completion_value_register); } enum class AwaitBeforeYield { No, Yes, }; static void generate_yield(Bytecode::Generator& generator, Bytecode::Label continuation_label, Bytecode::Register received_completion_register, Bytecode::Register received_completion_type_register, Bytecode::Register received_completion_value_register, Bytecode::IdentifierTableIndex type_identifier, Bytecode::IdentifierTableIndex value_identifier, AwaitBeforeYield await_before_yield) { if (!generator.is_in_async_generator_function()) { generator.emit(Bytecode::Label { continuation_label }); return; } if (await_before_yield == AwaitBeforeYield::Yes) generate_await(generator, received_completion_register, received_completion_type_register, received_completion_value_register, type_identifier, value_identifier); auto& unwrap_yield_resumption_block = generator.make_block(); generator.emit(Bytecode::Label { unwrap_yield_resumption_block }); generator.switch_to_basic_block(unwrap_yield_resumption_block); get_received_completion_type_and_value(generator, received_completion_register, received_completion_type_register, received_completion_value_register, type_identifier, value_identifier); // 27.6.3.7 AsyncGeneratorUnwrapYieldResumption ( resumptionValue ), https://tc39.es/ecma262/#sec-asyncgeneratorunwrapyieldresumption // 1. If resumptionValue.[[Type]] is not return, return ? resumptionValue. auto& load_completion_and_jump_to_continuation_label_block = generator.make_block(); auto& resumption_value_type_is_return_block = generator.make_block(); generator.emit(Value(to_underlying(Completion::Type::Return))); generator.emit(received_completion_type_register); generator.emit( Bytecode::Label { load_completion_and_jump_to_continuation_label_block }, Bytecode::Label { resumption_value_type_is_return_block }); generator.switch_to_basic_block(resumption_value_type_is_return_block); // 2. Let awaited be Completion(Await(resumptionValue.[[Value]])). generator.emit(received_completion_value_register); generate_await(generator, received_completion_register, received_completion_type_register, received_completion_value_register, type_identifier, value_identifier); // 3. If awaited.[[Type]] is throw, return ? awaited. auto& awaited_type_is_normal_block = generator.make_block(); generator.emit(Value(to_underlying(Completion::Type::Throw))); generator.emit(received_completion_type_register); generator.emit( Bytecode::Label { load_completion_and_jump_to_continuation_label_block }, Bytecode::Label { awaited_type_is_normal_block }); // 4. Assert: awaited.[[Type]] is normal. generator.switch_to_basic_block(awaited_type_is_normal_block); // 5. Return Completion Record { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }. generator.emit(Value(to_underlying(Completion::Type::Return))); generator.emit(received_completion_register, type_identifier, Bytecode::Op::PropertyKind::KeyValue, generator.next_property_lookup_cache()); generator.emit(Bytecode::Label { load_completion_and_jump_to_continuation_label_block }); generator.switch_to_basic_block(load_completion_and_jump_to_continuation_label_block); generator.emit(received_completion_register); generator.emit(continuation_label); } Bytecode::CodeGenerationErrorOr YieldExpression::generate_bytecode(Bytecode::Generator& generator) const { Bytecode::Generator::SourceLocationScope scope(generator, *this); VERIFY(generator.is_in_generator_function()); auto received_completion_register = generator.allocate_register(); auto received_completion_type_register = generator.allocate_register(); auto received_completion_value_register = generator.allocate_register(); auto type_identifier = generator.intern_identifier("type"); auto value_identifier = generator.intern_identifier("value"); if (m_is_yield_from) { // 15.5.5 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation // 1. Let generatorKind be GetGeneratorKind(). // NOTE: is_in_async_generator_function differentiates the generator kind. // 2. Let exprRef be ? Evaluation of AssignmentExpression. // 3. Let value be ? GetValue(exprRef). VERIFY(m_argument); TRY(m_argument->generate_bytecode(generator)); // 4. Let iteratorRecord be ? GetIterator(value, generatorKind). auto iterator_record_register = generator.allocate_register(); auto iterator_hint = generator.is_in_async_generator_function() ? IteratorHint::Async : IteratorHint::Sync; generator.emit(iterator_hint); generator.emit(iterator_record_register); // 5. Let iterator be iteratorRecord.[[Iterator]]. auto iterator_register = generator.allocate_register(); generator.emit(iterator_register, iterator_record_register); // Cache iteratorRecord.[[NextMethod]] for use in step 7.a.i. auto next_method_register = generator.allocate_register(); generator.emit(next_method_register, iterator_record_register); // 6. Let received be NormalCompletion(undefined). // See get_received_completion_type_and_value above. generator.emit(Value(to_underlying(Completion::Type::Normal))); generator.emit(received_completion_type_register); generator.emit(js_undefined()); generator.emit(received_completion_value_register); // 7. Repeat, auto& loop_block = generator.make_block(); auto& continuation_block = generator.make_block(); auto& loop_end_block = generator.make_block(); generator.emit(Bytecode::Label { loop_block }); generator.switch_to_basic_block(loop_block); // a. If received.[[Type]] is normal, then auto& type_is_normal_block = generator.make_block(); auto& is_type_throw_block = generator.make_block(); generator.emit(Value(to_underlying(Completion::Type::Normal))); generator.emit(received_completion_type_register); generator.emit