dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibJS/Runtime/SharedFunctionInstanceData.cpp

265 lines
8.9 KiB
C++
Raw Normal View History

LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03:00
/*
* Copyright (c) 2025, Andreas Kling <andreas@ladybird.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
LibJS: Account executable storage as external memory Report outline storage retained by bytecode executables, table objects, object property iterator cache data, and shared function instance data. This includes bytecode vectors, cache arrays, source maps, class blueprint elements, and binding metadata.
2026-05-05 19:16:40 -03:00
#include <LibJS/Runtime/ExternalMemory.h>
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03:00
#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 07:50:46 -03:00
#include <LibJS/RustIntegration.h>
LibJS+LibWeb: Keep cached script source text lazy Avoid decoding warm-cache script responses into full UTF-16 SourceCode buffers when a bytecode cache sidecar is available. SourceCode now keeps the original immutable source bytes and source encoding, then decodes only when full source text or a Function.toString() range is requested. Compute the bytecode cache source hash while streaming decoded code points from the response bytes, so cache validation does not force an intermediate UTF-8 string. Function and class source text metadata now stores SourceCode ranges instead of views into a materialized buffer.
2026-05-17 14:54:58 -03:00
#include <LibJS/SourceCode.h>
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03: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 15:15:04 -03:00
VM&,
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03: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 15:15:04 -03:00
u32 formal_parameter_count,
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03: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 15:15:04 -03:00
bool has_simple_parameter_list,
Vector<Utf16FlyString> parameter_names_for_mapped_arguments,
LibJS: Track shared function data ownership Give scripts and modules an explicit list of their shared function data records, and teach Rust materialization to populate that list directly. This gives bytecode cache installation a stable set of functions to update when replacing executable backing storage.
2026-05-21 16:49:43 -03:00
SharedFunctionInstanceDataList& owner_shared_function_data_list,
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 15:15:04 -03:00
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 13:20:45 -03: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 15:15:04 -03: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 13:20:45 -03: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 15:15:04 -03:00
, m_has_simple_parameter_list(has_simple_parameter_list)
, m_rust_function_ast(rust_function_ast)
, m_use_rust_compilation(true)
LibJS: Track shared function data ownership Give scripts and modules an explicit list of their shared function data records, and teach Rust materialization to populate that list directly. This gives bytecode cache installation a stable set of functions to update when replacing executable backing storage.
2026-05-21 16:49:43 -03:00
{
initialize_after_construction();
owner_shared_function_data_list.append(*this);
}
SharedFunctionInstanceData::SharedFunctionInstanceData(
VM&,
FunctionKind kind,
Utf16FlyString name,
i32 function_length,
u32 formal_parameter_count,
bool strict,
bool is_arrow_function,
bool has_simple_parameter_list,
Vector<Utf16FlyString> parameter_names_for_mapped_arguments,
NoSharedFunctionDataList,
void* rust_function_ast)
: m_name(move(name))
, m_function_length(function_length)
, m_formal_parameter_count(formal_parameter_count)
, m_parameter_names_for_mapped_arguments(move(parameter_names_for_mapped_arguments))
, m_kind(kind)
, m_strict(strict)
, m_is_arrow_function(is_arrow_function)
, m_has_simple_parameter_list(has_simple_parameter_list)
, m_rust_function_ast(rust_function_ast)
, m_use_rust_compilation(true)
{
initialize_after_construction();
}
void SharedFunctionInstanceData::initialize_after_construction()
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03: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 08:43:55 -03:00
update_can_inline_call();
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03:00
}
void SharedFunctionInstanceData::visit_edges(Visitor& visitor)
{
Base::visit_edges(visitor);
visitor.visit(m_executable);
LibJS: Share function environment binding shapes Cache EnvironmentShape on SharedFunctionInstanceData after the first function environment creates its statically known bindings. Install the cached shape before later calls create bindings so those environments avoid building their own name vector and lookup map. Let DeclarativeEnvironment keep a local overlay for eval-created bindings, and keep the packed flag mirror per environment while the asm interpreter still reads flags directly from the environment. Add runtime coverage for repeated calls with an eval-created binding.
2026-05-14 19:17:32 -03:00
visitor.visit(m_function_environment_shape);
LibJS: Share parameter var environment shapes Cache EnvironmentShape for var environments created when default parameter expressions force body vars into a separate environment. Reuse that cache in CreateVariableEnvironment when the capacity matches the active function metadata. Expose active SharedFunctionInstanceData through VM so the bytecode instruction can update the cache through a narrow API. Add coverage for repeated calls with captured vars in this environment.
2026-05-14 19:24:11 -03:00
visitor.visit(m_var_environment_shape);
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-10 21:08:21 -03: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-05 20:36:34 -03: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 13:20:45 -03:00
}
LibJS: Account executable storage as external memory Report outline storage retained by bytecode executables, table objects, object property iterator cache data, and shared function instance data. This includes bytecode vectors, cache arrays, source maps, class blueprint elements, and binding metadata.
2026-05-05 19:16:40 -03:00
size_t SharedFunctionInstanceData::external_memory_size() const
{
size_t size = utf16_string_external_memory_size(m_source_text_owner);
size = saturating_add_external_memory_size(size, vector_external_memory_size(m_local_variables_names));
size = saturating_add_external_memory_size(size, vector_external_memory_size(m_parameter_names_for_mapped_arguments));
size = saturating_add_external_memory_size(size, hash_map_external_memory_size(m_parameter_names));
size = saturating_add_external_memory_size(size, vector_external_memory_size(m_functions_to_initialize));
size = saturating_add_external_memory_size(size, vector_external_memory_size(m_var_names_to_initialize_binding));
size = saturating_add_external_memory_size(size, vector_external_memory_size(m_function_names_to_initialize_binding));
size = saturating_add_external_memory_size(size, vector_external_memory_size(m_lexical_bindings));
return size;
}
LibJS+LibWeb: Keep cached script source text lazy Avoid decoding warm-cache script responses into full UTF-16 SourceCode buffers when a bytecode cache sidecar is available. SourceCode now keeps the original immutable source bytes and source encoding, then decodes only when full source text or a Function.toString() range is requested. Compute the bytecode cache source hash while streaming decoded code points from the response bytes, so cache validation does not force an intermediate UTF-8 string. Function and class source text metadata now stores SourceCode ranges instead of views into a materialized buffer.
2026-05-17 14:54:58 -03:00
Utf16String SharedFunctionInstanceData::source_text() const
{
if (!m_source_text_owner.is_empty())
return m_source_text_owner;
if (!m_source_code)
return {};
LibJS: Avoid repeated lazy source decoding Function.prototype.toString() can ask for the same cached function source text repeatedly after a script was materialized from the bytecode cache. In that path SourceCode still owns only the encoded source bytes, so every request decoded the requested source range again. Large ASCII bundles made that path expensive enough to stall Speedometer 2.1's Ember debug test. Keep the byte-backed SourceCode representation lazy, but let ASCII UTF-8 source ranges slice the source bytes directly. For other ASCII byte-backed encodings, first ask the decoder to prove that the source bytes map to the same UTF-16 code units at the same positions. Cache extracted function source text on shared function data after the first request so repeated toString() calls do not keep going back to SourceCode. Add bytecode cache coverage for toString() on lazy UTF-8 source bytes, keep malformed UTF-8 and UTF-16 edge cases on the decoder path, and cover PDFDocEncoding bytes that are not identity-mapped.
2026-05-19 08:59:58 -03:00
auto old_external_memory_size = utf16_string_external_memory_size(m_source_text_owner);
m_source_text_owner = m_source_code->source_text_from_offsets(m_source_text_offset, m_source_text_length);
auto new_external_memory_size = utf16_string_external_memory_size(m_source_text_owner);
if (new_external_memory_size > old_external_memory_size)
heap().did_allocate_external_memory(new_external_memory_size - old_external_memory_size);
return m_source_text_owner;
LibJS+LibWeb: Keep cached script source text lazy Avoid decoding warm-cache script responses into full UTF-16 SourceCode buffers when a bytecode cache sidecar is available. SourceCode now keeps the original immutable source bytes and source encoding, then decodes only when full source text or a Function.toString() range is requested. Compute the bytecode cache source hash while streaming decoded code points from the response bytes, so cache validation does not force an intermediate UTF-8 string. Function and class source text metadata now stores SourceCode ranges instead of views into a materialized buffer.
2026-05-17 14:54:58 -03:00
}
void SharedFunctionInstanceData::set_source_text(Utf16View source_text)
{
m_source_text_owner = Utf16String::from_utf16(source_text);
m_source_code = nullptr;
m_source_text_offset = 0;
m_source_text_length = 0;
}
void SharedFunctionInstanceData::set_source_text_range(SourceCode const& source_code, size_t source_text_offset, size_t source_text_length)
{
m_source_text_owner = {};
m_source_code = &source_code;
m_source_text_offset = source_text_offset;
m_source_text_length = source_text_length;
}
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03: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 08:43:55 -03: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 04:56:33 -03: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;
LibJS: Avoid function envs for lexical-this arrows Track whether a function needs environment-backed this resolution separately from whether it needs to allocate its own function environment. Arrow functions that only capture lexical this can now resolve through the outer environment without allocating an empty function environment for every call. Keep the asm Call path conservative by routing functions that still need lexical-this resolution through the C++ inline-call helper, so the call receiver is not cached as the arrow function's this value. Microbenchmark: function makeLexicalThisArrow() { return () => this.value; } let object = { value: 1, makeLexicalThisArrow }; let fn = object.makeLexicalThisArrow(); for (let i = 0; i < 20_000_000; ++i) fn(); Measured with the same Release build toggling this patch: baseline: 1069.2 ms mean over 12 runs optimized: 501.2 ms mean over 12 runs speedup: 2.13 times faster
2026-04-30 12:07:49 -03:00
if (m_function_environment_needed || m_this_value_needs_environment_resolution)
m_asm_call_metadata |= asm_call_metadata_needs_environment_or_this_value_resolution;
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 04:56:33 -03:00
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 07:50:46 -03:00
void SharedFunctionInstanceData::finalize()
{
LibJS: Track shared function data ownership Give scripts and modules an explicit list of their shared function data records, and teach Rust materialization to populate that list directly. This gives bytecode cache installation a stable set of functions to update when replacing executable backing storage.
2026-05-21 16:49:43 -03:00
if (m_owner_shared_function_data_list)
m_owner_shared_function_data_list->remove(*this);
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 07:50:46 -03:00
Base::finalize();
RustIntegration::free_function_ast(m_rust_function_ast);
m_rust_function_ast = nullptr;
LibJS: Materialize compiled function bytecode lazily Keep fully compiled function bytecode in its Rust-side form until the function is called for the first time. This covers decoded disk cache records and freshly precompiled bytecode, so startup avoids eagerly allocating every nested function executable. Validate cached function bytecode before accepting a cache entry. This keeps the existing failure behavior for corrupt on-disk cache data. Add coverage for bytecode-cache and freshly precompiled functions to assert that nested executables stay absent after script materialization, then appear after the function is called.
2026-05-13 18:35:55 -03:00
RustIntegration::free_cached_bytecode_executable(m_cached_bytecode_executable);
m_cached_bytecode_executable = nullptr;
RustIntegration::free_precompiled_bytecode_executable(m_precompiled_bytecode_executable);
m_precompiled_bytecode_executable = nullptr;
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 07:50:46 -03:00
}
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 18:21:23 -03:00
void SharedFunctionInstanceData::clear_compile_inputs()
{
LibJS: Track shared function data ownership Give scripts and modules an explicit list of their shared function data records, and teach Rust materialization to populate that list directly. This gives bytecode cache installation a stable set of functions to update when replacing executable backing storage.
2026-05-21 16:49:43 -03:00
clear_non_bytecode_cache_compile_inputs();
RustIntegration::free_cached_bytecode_executable(m_cached_bytecode_executable);
m_cached_bytecode_executable = nullptr;
}
void SharedFunctionInstanceData::clear_non_bytecode_cache_compile_inputs()
{
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 18:21:23 -03:00
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-10 21:10:40 -03: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 07:50:46 -03:00
RustIntegration::free_function_ast(m_rust_function_ast);
m_rust_function_ast = nullptr;
LibJS: Materialize compiled function bytecode lazily Keep fully compiled function bytecode in its Rust-side form until the function is called for the first time. This covers decoded disk cache records and freshly precompiled bytecode, so startup avoids eagerly allocating every nested function executable. Validate cached function bytecode before accepting a cache entry. This keeps the existing failure behavior for corrupt on-disk cache data. Add coverage for bytecode-cache and freshly precompiled functions to assert that nested executables stay absent after script materialization, then appear after the function is called.
2026-05-13 18:35:55 -03:00
RustIntegration::free_precompiled_bytecode_executable(m_precompiled_bytecode_executable);
m_precompiled_bytecode_executable = 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 18:21:23 -03: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 08:43:55 -03: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 04:56:33 -03: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 08:43:55 -03:00
}
LibJS: Track shared function data ownership Give scripts and modules an explicit list of their shared function data records, and teach Rust materialization to populate that list directly. This gives bytecode cache installation a stable set of functions to update when replacing executable backing storage.
2026-05-21 16:49:43 -03:00
SharedFunctionInstanceDataList::~SharedFunctionInstanceDataList()
{
clear();
}
void SharedFunctionInstanceDataList::append(SharedFunctionInstanceData& shared_data)
{
if (shared_data.m_owner_shared_function_data_list == this)
return;
if (shared_data.m_owner_shared_function_data_list)
shared_data.m_owner_shared_function_data_list->remove(shared_data);
VERIFY(!shared_data.m_script_or_module_list_node.is_in_list());
m_list.append(shared_data);
shared_data.m_owner_shared_function_data_list = this;
}
void SharedFunctionInstanceDataList::visit_edges(GC::Cell::Visitor& visitor)
{
for (auto& shared_data : m_list)
visitor.visit(shared_data);
}
void SharedFunctionInstanceDataList::clear_non_bytecode_cache_compile_inputs()
{
for (auto& shared_data : m_list)
shared_data.clear_non_bytecode_cache_compile_inputs();
}
bool SharedFunctionInstanceDataList::contains_rust_function_ast() const
{
for (auto const& shared_data : m_list) {
if (shared_data.m_rust_function_ast)
return true;
}
return false;
}
bool SharedFunctionInstanceDataList::contains_precompiled_bytecode() const
{
for (auto const& shared_data : m_list) {
if (shared_data.m_precompiled_bytecode_executable)
return true;
}
return false;
}
void SharedFunctionInstanceDataList::clear()
{
while (!m_list.is_empty()) {
auto* shared_data = m_list.first();
remove(*shared_data);
}
}
void SharedFunctionInstanceDataList::remove(SharedFunctionInstanceData& shared_data)
{
VERIFY(shared_data.m_owner_shared_function_data_list == this);
m_list.remove(shared_data);
shared_data.m_owner_shared_function_data_list = nullptr;
}
LibJS: Moved SharedFunctionInstanceData into separate files This will allow it to be reused by NativeJavaScriptBackedFunction.
2025-11-06 13:20:45 -03:00
}
Reference in a new issue Copy permalink