Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2026-04-19 10:20:22 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Runtime/SharedFunctionInstanceData.cpp

106 lines
3 KiB
C++
Raw Permalink Normal View History

LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
/*
* Copyright (c) 2025, Andreas Kling <andreas@ladybird.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibJS/Runtime/SharedFunctionInstanceData.h>
LibJS: Add alternative source-to-bytecode pipeline in Rust Implement a complete Rust reimplementation of the LibJS frontend: lexer, parser, AST, scope collector, and bytecode code generator. The Rust pipeline is built via Corrosion (CMake-Cargo bridge) and linked into LibJS as a static library. It is gated behind a build flag (ENABLE_RUST, on by default except on Windows) and two runtime environment variables: - LIBJS_CPP: Use the C++ pipeline instead of Rust - LIBJS_COMPARE_PIPELINES=1: Run both pipelines in lockstep, aborting on any difference in AST or bytecode generated. The C++ side communicates with Rust through a C FFI layer (RustIntegration.cpp/h) that passes source text to Rust and receives a populated Executable back via a BytecodeFactory interface.
2026-02-23 11:50:46 +01:00
#include <LibJS/RustIntegration.h>
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
namespace JS {
GC_DEFINE_ALLOCATOR(SharedFunctionInstanceData);
SharedFunctionInstanceData::SharedFunctionInstanceData(
LibJS: Remove C++ AST constructor from SharedFunctionInstanceData Remove the constructor that took C++ AST nodes (FunctionParameters, Statement), along with create_for_function_node() and the m_formal_parameters / m_ecmascript_code fields. These were only used by the now-removed C++ compilation pipeline. Also remove the dead EvalDeclarationData::create(VM&, Program&, bool) and ECMAScriptFunctionObject::ecmascript_code() accessor.
2026-03-19 13:15:04 -05:00
VM&,
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
FunctionKind kind,
Utf16FlyString name,
i32 function_length,
LibJS: Remove C++ AST constructor from SharedFunctionInstanceData Remove the constructor that took C++ AST nodes (FunctionParameters, Statement), along with create_for_function_node() and the m_formal_parameters / m_ecmascript_code fields. These were only used by the now-removed C++ compilation pipeline. Also remove the dead EvalDeclarationData::create(VM&, Program&, bool) and ECMAScriptFunctionObject::ecmascript_code() accessor.
2026-03-19 13:15:04 -05:00
u32 formal_parameter_count,
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
bool strict,
bool is_arrow_function,
LibJS: Remove C++ AST constructor from SharedFunctionInstanceData Remove the constructor that took C++ AST nodes (FunctionParameters, Statement), along with create_for_function_node() and the m_formal_parameters / m_ecmascript_code fields. These were only used by the now-removed C++ compilation pipeline. Also remove the dead EvalDeclarationData::create(VM&, Program&, bool) and ECMAScriptFunctionObject::ecmascript_code() accessor.
2026-03-19 13:15:04 -05:00
bool has_simple_parameter_list,
Vector<Utf16FlyString> parameter_names_for_mapped_arguments,
void* rust_function_ast)
: m_name(move(name))
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
, m_function_length(function_length)
LibJS: Remove C++ AST constructor from SharedFunctionInstanceData Remove the constructor that took C++ AST nodes (FunctionParameters, Statement), along with create_for_function_node() and the m_formal_parameters / m_ecmascript_code fields. These were only used by the now-removed C++ compilation pipeline. Also remove the dead EvalDeclarationData::create(VM&, Program&, bool) and ECMAScriptFunctionObject::ecmascript_code() accessor.
2026-03-19 13:15:04 -05:00
, m_formal_parameter_count(formal_parameter_count)
, m_parameter_names_for_mapped_arguments(move(parameter_names_for_mapped_arguments))
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
, m_kind(kind)
, m_strict(strict)
, m_is_arrow_function(is_arrow_function)
LibJS: Remove C++ AST constructor from SharedFunctionInstanceData Remove the constructor that took C++ AST nodes (FunctionParameters, Statement), along with create_for_function_node() and the m_formal_parameters / m_ecmascript_code fields. These were only used by the now-removed C++ compilation pipeline. Also remove the dead EvalDeclarationData::create(VM&, Program&, bool) and ECMAScriptFunctionObject::ecmascript_code() accessor.
2026-03-19 13:15:04 -05:00
, m_has_simple_parameter_list(has_simple_parameter_list)
, m_rust_function_ast(rust_function_ast)
, m_use_rust_compilation(true)
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
{
if (m_is_arrow_function)
m_this_mode = ThisMode::Lexical;
else if (m_strict)
m_this_mode = ThisMode::Strict;
else
m_this_mode = ThisMode::Global;
LibJS: Cache JS-to-JS inline call eligibility Store whether a function can participate in JS-to-JS inline calls on SharedFunctionInstanceData instead of recomputing the function kind, class-constructor bit, and bytecode availability at each fast-path call site.
2026-04-13 13:43:55 +02:00
update_can_inline_call();
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
}
void SharedFunctionInstanceData::visit_edges(Visitor& visitor)
{
Base::visit_edges(visitor);
visitor.visit(m_executable);
LibJS: Replace m_functions_to_initialize with pre-created data Replace Vector<FunctionDeclaration const&> with a FunctionToInitialize struct that stores a pre-created SharedFunctionInstanceData, function name, and local index. The SharedFunctionInstanceData for each hoisted function is created eagerly during the parent's construction, removing the need to reference FunctionDeclaration AST nodes after construction.
2026-02-11 01:08:21 +01:00
for (auto& function : m_functions_to_initialize)
visitor.visit(function.shared_data);
LibJS+LibWeb: Add missing GC marking visits This adds visit_edges(Cell::Visitor&) methods to various helper structs that contain GC pointers, and makes sure they are called from owning GC-heap-allocated objects as needed. These were found by our Clang plugin after expanding its capabilities. The added rules will be enforced by CI going forward.
2026-01-06 00:36:34 +01:00
m_class_field_initializer_name.visit([&](PropertyKey const& key) { key.visit_edges(visitor); }, [](auto&) {});
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
}
SharedFunctionInstanceData::~SharedFunctionInstanceData() = default;
LibJS: Cache JS-to-JS inline call eligibility Store whether a function can participate in JS-to-JS inline calls on SharedFunctionInstanceData instead of recomputing the function kind, class-constructor bit, and bytecode availability at each fast-path call site.
2026-04-13 13:43:55 +02:00
void SharedFunctionInstanceData::set_executable(GC::Ptr<Bytecode::Executable> executable)
{
m_executable = executable;
update_can_inline_call();
}
void SharedFunctionInstanceData::set_is_class_constructor()
{
m_is_class_constructor = true;
update_can_inline_call();
}
LibJS: Pack asm Call shared-data metadata Pack the asm Call fast path metadata next to the executable pointer so the interpreter can fetch both values with one paired load. This removes several dependent shared-data loads from the hot path. Keep the executable pointer and packed metadata in separate registers through this binding so the fast path can still use the paired-load layout after any non-strict this adjustment. Lower the packed metadata flag checks correctly on x86_64 as well. Those bits now live above bit 31, so the generator uses bt for single- bit high masks and covers that path with a unit test. Add a runtime test that exercises both object and global this binding through the asm Call fast path.
2026-04-14 09:56:33 +02:00
void SharedFunctionInstanceData::update_asm_call_metadata()
{
m_asm_call_metadata = m_formal_parameter_count;
if (m_can_inline_call)
m_asm_call_metadata |= asm_call_metadata_can_inline_call;
if (m_function_environment_needed)
m_asm_call_metadata |= asm_call_metadata_function_environment_needed;
if (m_uses_this)
m_asm_call_metadata |= asm_call_metadata_uses_this;
if (m_strict)
m_asm_call_metadata |= asm_call_metadata_strict;
}
LibJS: Add alternative source-to-bytecode pipeline in Rust Implement a complete Rust reimplementation of the LibJS frontend: lexer, parser, AST, scope collector, and bytecode code generator. The Rust pipeline is built via Corrosion (CMake-Cargo bridge) and linked into LibJS as a static library. It is gated behind a build flag (ENABLE_RUST, on by default except on Windows) and two runtime environment variables: - LIBJS_CPP: Use the C++ pipeline instead of Rust - LIBJS_COMPARE_PIPELINES=1: Run both pipelines in lockstep, aborting on any difference in AST or bytecode generated. The C++ side communicates with Rust through a C FFI layer (RustIntegration.cpp/h) that passes source text to Rust and receives a populated Executable back via a BytecodeFactory interface.
2026-02-23 11:50:46 +01:00
void SharedFunctionInstanceData::finalize()
{
Base::finalize();
RustIntegration::free_function_ast(m_rust_function_ast);
m_rust_function_ast = nullptr;
}
LibJS: Clear compile-only data from SharedFunctionInstanceData After successful bytecode compilation, the m_functions_to_initialize and m_var_names_to_initialize_binding vectors are no longer needed as they are only consumed by emit_function_declaration_instantiation() during code generation. Add clear_compile_inputs() to release these vectors post-compile, and call it from both ECMAScriptFunctionObject::get_stack_frame_size() and NativeJavaScriptBackedFunction::bytecode_executable() after their respective lazy compilation succeeds. Also add a pre-compile assertion in Generator::generate_from_function() to verify we never try to compile the same function data twice, and a VERIFY in ECMAScriptFunctionObject::ecmascript_code() to guard against null dereference.
2026-02-10 22:21:23 +01:00
void SharedFunctionInstanceData::clear_compile_inputs()
{
VERIFY(m_executable);
m_functions_to_initialize.clear();
m_var_names_to_initialize_binding.clear();
LibJS: Pre-compute ScopeNode queries in SharedFunctionInstanceData Pre-compute the data that emit_function_declaration_instantiation previously obtained by querying ScopeNode methods at codegen time: - m_has_scope_body: whether ecmascript_code is a ScopeNode - m_has_non_local_lexical_declarations: from ScopeNode query - m_lexical_bindings: non-local lexically-scoped identifier names and their constant-declaration status After this change, emit_function_declaration_instantiation no longer casts m_ecmascript_code to ScopeNode or calls any ScopeNode methods.
2026-02-11 01:10:40 +01:00
m_lexical_bindings.clear();
LibJS: Add alternative source-to-bytecode pipeline in Rust Implement a complete Rust reimplementation of the LibJS frontend: lexer, parser, AST, scope collector, and bytecode code generator. The Rust pipeline is built via Corrosion (CMake-Cargo bridge) and linked into LibJS as a static library. It is gated behind a build flag (ENABLE_RUST, on by default except on Windows) and two runtime environment variables: - LIBJS_CPP: Use the C++ pipeline instead of Rust - LIBJS_COMPARE_PIPELINES=1: Run both pipelines in lockstep, aborting on any difference in AST or bytecode generated. The C++ side communicates with Rust through a C FFI layer (RustIntegration.cpp/h) that passes source text to Rust and receives a populated Executable back via a BytecodeFactory interface.
2026-02-23 11:50:46 +01:00
RustIntegration::free_function_ast(m_rust_function_ast);
m_rust_function_ast = nullptr;
LibJS: Clear compile-only data from SharedFunctionInstanceData After successful bytecode compilation, the m_functions_to_initialize and m_var_names_to_initialize_binding vectors are no longer needed as they are only consumed by emit_function_declaration_instantiation() during code generation. Add clear_compile_inputs() to release these vectors post-compile, and call it from both ECMAScriptFunctionObject::get_stack_frame_size() and NativeJavaScriptBackedFunction::bytecode_executable() after their respective lazy compilation succeeds. Also add a pre-compile assertion in Generator::generate_from_function() to verify we never try to compile the same function data twice, and a VERIFY in ECMAScriptFunctionObject::ecmascript_code() to guard against null dereference.
2026-02-10 22:21:23 +01:00
}
LibJS: Cache JS-to-JS inline call eligibility Store whether a function can participate in JS-to-JS inline calls on SharedFunctionInstanceData instead of recomputing the function kind, class-constructor bit, and bytecode availability at each fast-path call site.
2026-04-13 13:43:55 +02:00
void SharedFunctionInstanceData::update_can_inline_call()
{
m_can_inline_call = m_executable && m_kind == FunctionKind::Normal && !m_is_class_constructor;
LibJS: Pack asm Call shared-data metadata Pack the asm Call fast path metadata next to the executable pointer so the interpreter can fetch both values with one paired load. This removes several dependent shared-data loads from the hot path. Keep the executable pointer and packed metadata in separate registers through this binding so the fast path can still use the paired-load layout after any non-strict this adjustment. Lower the packed metadata flag checks correctly on x86_64 as well. Those bits now live above bit 31, so the generator uses bt for single- bit high masks and covers that path with a unit test. Add a runtime test that exercises both object and global this binding through the asm Call fast path.
2026-04-14 09:56:33 +02:00
update_asm_call_metadata();
LibJS: Cache JS-to-JS inline call eligibility Store whether a function can participate in JS-to-JS inline calls on SharedFunctionInstanceData instead of recomputing the function kind, class-constructor bit, and bytecode availability at each fast-path call site.
2026-04-13 13:43:55 +02:00
}
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 16:20:45 +00:00
}
Reference in a new issue Copy permalink