mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2026-06-24 18:30:23 +00:00
21cbfb3cb1
Store source map locations as bytecode offset, line, and column. Runtime consumers only emit the start line and column, so source end positions and source text offsets do not need to be carried through Executable source maps, bytecode cache serialization, or the Rust FFI. Keep SourceCode's internal position cache able to track source text offsets so callers can still translate source offsets to line and column pairs when needed. Hash dump-bytecode IDs from the name, first source position, and bytecode size instead of source slices that need end offsets. Bump the bytecode cache format version for the slimmer serialized source map entry shape.
121 lines
4.5 KiB
C++
121 lines
4.5 KiB
C++
/*
|
|
* Copyright (c) 2020-2025, Andreas Kling <andreas@ladybird.org>
|
|
* Copyright (c) 2021-2023, Linus Groh <linusg@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/StringBuilder.h>
|
|
#include <LibJS/Runtime/ErrorData.h>
|
|
#include <LibJS/Runtime/ExecutionContext.h>
|
|
#include <LibJS/Runtime/ExternalMemory.h>
|
|
#include <LibJS/Runtime/FunctionObject.h>
|
|
#include <LibJS/Runtime/PrimitiveString.h>
|
|
#include <LibJS/Runtime/VM.h>
|
|
|
|
namespace JS {
|
|
|
|
static SourceRange dummy_source_range { SourceCode::create({}, {}), {} };
|
|
|
|
SourceRange const& TracebackFrame::source_range() const
|
|
{
|
|
if (!cached_source_range.has_value())
|
|
return dummy_source_range;
|
|
return *cached_source_range;
|
|
}
|
|
|
|
ErrorData::ErrorData(VM& vm)
|
|
{
|
|
populate_stack(vm);
|
|
}
|
|
|
|
void ErrorData::visit_edges(Cell::Visitor& visitor)
|
|
{
|
|
visitor.visit(m_cached_string);
|
|
}
|
|
|
|
size_t ErrorData::external_memory_size() const
|
|
{
|
|
size_t size = vector_external_memory_size(m_traceback);
|
|
for (auto const& frame : m_traceback)
|
|
size = saturating_add_external_memory_size(size, utf16_string_external_memory_size(frame.function_name));
|
|
return size;
|
|
}
|
|
|
|
void ErrorData::populate_stack(VM& vm)
|
|
{
|
|
auto stack_trace = vm.stack_trace();
|
|
m_traceback.ensure_capacity(stack_trace.size());
|
|
for (auto& element : stack_trace) {
|
|
auto* context = element.execution_context;
|
|
m_traceback.append({
|
|
.function_name = context->function ? context->function->name_for_call_stack() : ""_utf16,
|
|
.cached_source_range = move(element.source_range),
|
|
});
|
|
}
|
|
}
|
|
|
|
Utf16String ErrorData::stack_string(CompactTraceback compact) const
|
|
{
|
|
if (m_traceback.is_empty())
|
|
return {};
|
|
|
|
StringBuilder stack_string_builder(StringBuilder::Mode::UTF16);
|
|
|
|
// Note: We roughly follow V8's formatting
|
|
auto append_frame = [&](TracebackFrame const& frame) {
|
|
auto const& function_name = frame.function_name;
|
|
auto const& source_range = frame.source_range();
|
|
// Note: Since we don't know whether we have a valid SourceRange here we just check for some default values.
|
|
if (!source_range.filename().is_empty() || source_range.start.line != 0 || source_range.start.column != 0) {
|
|
|
|
if (function_name.is_empty())
|
|
stack_string_builder.appendff(" at {}:{}:{}\n", source_range.filename(), source_range.start.line, source_range.start.column);
|
|
else
|
|
stack_string_builder.appendff(" at {} ({}:{}:{})\n", function_name, source_range.filename(), source_range.start.line, source_range.start.column);
|
|
} else {
|
|
stack_string_builder.appendff(" at {}\n", function_name.is_empty() ? "<unknown>"_utf16 : function_name);
|
|
}
|
|
};
|
|
|
|
auto is_same_frame = [](TracebackFrame const& a, TracebackFrame const& b) {
|
|
if (a.function_name.is_empty() && b.function_name.is_empty()) {
|
|
auto const& source_range_a = a.source_range();
|
|
auto const& source_range_b = b.source_range();
|
|
return source_range_a.filename() == source_range_b.filename() && source_range_a.start.line == source_range_b.start.line;
|
|
}
|
|
return a.function_name == b.function_name;
|
|
};
|
|
|
|
// Note: We don't want to capture the global execution context, so we omit the last frame
|
|
// Note: The error's name and message get prepended by Error.prototype.stack
|
|
unsigned repetitions = 0;
|
|
size_t used_frames = m_traceback.size() - 1;
|
|
for (size_t i = 0; i < used_frames; ++i) {
|
|
auto const& frame = m_traceback[i];
|
|
if (compact == CompactTraceback::Yes && i + 1 < used_frames) {
|
|
auto const& next_traceback_frame = m_traceback[i + 1];
|
|
if (is_same_frame(frame, next_traceback_frame)) {
|
|
repetitions++;
|
|
continue;
|
|
}
|
|
}
|
|
if (repetitions > 4) {
|
|
// If more than 5 (1 + >4) consecutive function calls with the same name, print
|
|
// the name only once and show the number of repetitions instead. This prevents
|
|
// printing ridiculously large call stacks of recursive functions.
|
|
append_frame(frame);
|
|
stack_string_builder.appendff(" {} more calls\n", repetitions);
|
|
} else {
|
|
for (size_t j = 0; j < repetitions + 1; j++)
|
|
append_frame(frame);
|
|
}
|
|
repetitions = 0;
|
|
}
|
|
for (size_t j = 0; j < repetitions; j++)
|
|
append_frame(m_traceback[used_frames - 1]);
|
|
|
|
return stack_string_builder.to_utf16_string();
|
|
}
|
|
|
|
}
|