1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 02:47:35 +00:00

LibJS/JIT: Provide source location information for JIT code

This works by walking a backtrace until the currently executing
native executable is found, and then mapping the native address
to its bytecode instruction.
This commit is contained in:
Simon Wanner 2023-10-30 22:06:27 +01:00 committed by Andreas Kling
parent 112eadc863
commit fb7b4b9c59
8 changed files with 59 additions and 6 deletions

View file

@ -8,6 +8,7 @@
#include <LibJS/Bytecode/Executable.h>
#include <LibJS/Bytecode/RegexTable.h>
#include <LibJS/JIT/Compiler.h>
#include <LibJS/JIT/NativeExecutable.h>
#include <LibJS/SourceCode.h>
namespace JS::Bytecode {

View file

@ -15,9 +15,12 @@
#include <LibJS/Bytecode/Label.h>
#include <LibJS/Bytecode/StringTable.h>
#include <LibJS/Forward.h>
#include <LibJS/JIT/NativeExecutable.h>
#include <LibJS/Runtime/EnvironmentCoordinate.h>
namespace JS::JIT {
class NativeExecutable;
}
namespace JS::Bytecode {
struct PropertyLookupCache {
@ -70,6 +73,7 @@ public:
void dump() const;
JIT::NativeExecutable const* get_or_create_native_executable();
JIT::NativeExecutable const* native_executable() const { return m_native_executable; }
private:
OwnPtr<JIT::NativeExecutable> m_native_executable;

View file

@ -157,10 +157,10 @@ private:
class InstructionStreamIterator {
public:
InstructionStreamIterator(ReadonlyBytes bytes, Executable const* executable = nullptr)
InstructionStreamIterator(ReadonlyBytes bytes, Executable const* executable = nullptr, size_t offset = 0)
: m_begin(bytes.data())
, m_end(bytes.data() + bytes.size())
, m_ptr(bytes.data())
, m_ptr(bytes.data() + offset)
, m_executable(executable)
{
}

View file

@ -16,6 +16,7 @@
#include <LibJS/Bytecode/Label.h>
#include <LibJS/Bytecode/Op.h>
#include <LibJS/JIT/Compiler.h>
#include <LibJS/JIT/NativeExecutable.h>
#include <LibJS/Runtime/AbstractOperations.h>
#include <LibJS/Runtime/Array.h>
#include <LibJS/Runtime/BigInt.h>
@ -55,6 +56,13 @@ void Interpreter::visit_edges(Cell::Visitor& visitor)
}
}
Optional<InstructionStreamIterator const&> Interpreter::instruction_stream_iterator() const
{
if (m_current_executable && m_current_executable->native_executable())
return m_current_executable->native_executable()->instruction_stream_iterator(*m_current_executable);
return m_pc;
}
// 16.1.6 ScriptEvaluation ( scriptRecord ), https://tc39.es/ecma262/#sec-runtime-semantics-scriptevaluation
ThrowCompletionOr<Value> Interpreter::run(Script& script_record, JS::GCPtr<Environment> lexical_environment_override)
{

View file

@ -6,6 +6,7 @@
#pragma once
#include <LibJS/Bytecode/Executable.h>
#include <LibJS/Bytecode/Label.h>
#include <LibJS/Bytecode/Register.h>
#include <LibJS/Forward.h>
@ -77,7 +78,7 @@ public:
Executable& current_executable() { return *m_current_executable; }
Executable const& current_executable() const { return *m_current_executable; }
BasicBlock const& current_block() const { return *m_current_block; }
auto& instruction_stream_iterator() const { return m_pc; }
Optional<InstructionStreamIterator const&> instruction_stream_iterator() const;
void visit_edges(Cell::Visitor&);

View file

@ -8,12 +8,12 @@
#pragma once
#include <AK/Platform.h>
#include <LibJS/JIT/NativeExecutable.h>
#if ARCH(X86_64)
# include <LibJIT/Assembler.h>
# include <LibJS/Bytecode/Executable.h>
# include <LibJS/Bytecode/Op.h>
# include <LibJS/JIT/NativeExecutable.h>
namespace JS::JIT {

View file

@ -12,6 +12,11 @@
#include <LibX86/Disassembler.h>
#include <sys/mman.h>
#if __has_include(<execinfo.h>)
# include <execinfo.h>
# define EXECINFO_BACKTRACE
#endif
namespace JS::JIT {
NativeExecutable::NativeExecutable(void* code, size_t size, Vector<BytecodeMapping> mapping)
@ -34,6 +39,7 @@ void NativeExecutable::run(VM& vm) const
vm.running_execution_context().local_variables.data());
}
#if ARCH(X86_64)
class JITSymbolProvider : public X86::SymbolProvider {
public:
JITSymbolProvider(NativeExecutable const& executable)
@ -67,8 +73,9 @@ public:
private:
NativeExecutable const& m_executable;
};
#endif
void NativeExecutable::dump_disassembly(Bytecode::Executable const& executable) const
void NativeExecutable::dump_disassembly([[maybe_unused]] Bytecode::Executable const& executable) const
{
#if ARCH(X86_64)
auto const* code_bytes = static_cast<u8 const*>(m_code);
@ -148,4 +155,33 @@ BytecodeMapping const& NativeExecutable::find_mapping_entry(size_t native_offset
return m_mapping[nearby_index];
}
Optional<Bytecode::InstructionStreamIterator const&> NativeExecutable::instruction_stream_iterator([[maybe_unused]] Bytecode::Executable const& executable) const
{
#ifdef EXECINFO_BACKTRACE
void* buffer[10];
auto count = backtrace(buffer, 10);
auto start = bit_cast<FlatPtr>(m_code);
auto end = start + m_size;
for (auto i = 0; i < count; i++) {
auto address = bit_cast<FlatPtr>(buffer[i]);
if (address < start || address >= end)
continue;
// return address points after the call
// let's subtract 1 to make sure we don't hit the next bytecode
// (in practice that's not necessary, because our native_call() sequence continues)
auto offset = address - start - 1;
auto& entry = find_mapping_entry(offset);
if (entry.block_index < executable.basic_blocks.size()) {
auto const& block = *executable.basic_blocks[entry.block_index];
if (entry.bytecode_offset < block.size()) {
// This is rather clunky, but Interpreter::instruction_stream_iterator() gives out references, so we need to keep it alive.
m_instruction_stream_iterator = make<Bytecode::InstructionStreamIterator>(block.instruction_stream(), &executable, entry.bytecode_offset);
return *m_instruction_stream_iterator;
}
}
}
#endif
return {};
}
}

View file

@ -8,6 +8,7 @@
#include <AK/Noncopyable.h>
#include <AK/Types.h>
#include <LibJS/Bytecode/Instruction.h>
#include <LibJS/Runtime/Completion.h>
namespace JS::JIT {
@ -33,6 +34,7 @@ public:
void run(VM&) const;
void dump_disassembly(Bytecode::Executable const& executable) const;
BytecodeMapping const& find_mapping_entry(size_t native_offset) const;
Optional<Bytecode::InstructionStreamIterator const&> instruction_stream_iterator(Bytecode::Executable const& executable) const;
ReadonlyBytes code_bytes() const { return { m_code, m_size }; }
@ -40,6 +42,7 @@ private:
void* m_code { nullptr };
size_t m_size { 0 };
Vector<BytecodeMapping> m_mapping;
mutable OwnPtr<Bytecode::InstructionStreamIterator> m_instruction_stream_iterator;
};
}