| /* |
| * Copyright (C) 2025 Igalia, S.L. All rights reserved. |
| * Copyright 2010 the V8 project authors. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include "config.h" |
| #include "GdbJIT.h" |
| |
| #include <wtf/TZoneMallocInlines.h> |
| |
| #if ENABLE(ASSEMBLER) |
| #if OS(DARWIN) || OS(LINUX) |
| |
| #include "CallFrame.h" |
| #include "CallFrameInlines.h" |
| #include "Options.h" |
| #include "ProfilerSupport.h" |
| #include <array> |
| #include <fcntl.h> |
| #include <mutex> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <wtf/DataLog.h> |
| #include <wtf/MonotonicTime.h> |
| #include <wtf/PageBlock.h> |
| #include <wtf/ProcessID.h> |
| #include <wtf/RefCountedAndCanMakeWeakPtr.h> |
| #include <wtf/StringPrintStream.h> |
| |
| WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN |
| |
| // Binary GDB JIT Interface as described in |
| // http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html |
| extern "C" { |
| enum JITAction { |
| NoAction = 0, |
| RegisterFunction = 1, |
| UnregisterFunction = 2 |
| }; |
| |
| struct JITCodeEntry { |
| JITCodeEntry* next { }; |
| JITCodeEntry* prev { }; |
| uint8_t* symfileAddr { }; |
| uint64_t symfileSize { }; |
| }; |
| |
| struct JITDescriptor { |
| uint32_t version { }; |
| uint32_t actionFlag { }; |
| JITCodeEntry* relevantEntry { }; |
| JITCodeEntry* firstEntry { }; |
| }; |
| |
| // GDB will place breakpoint into this function. |
| // To prevent GCC from inlining or removing it we place noinline attribute |
| // and inline assembler statement inside. |
| static REFERENCED_FROM_ASM NEVER_INLINE void __jit_debug_register_code() |
| { |
| __asm__(""); |
| } |
| |
| // GDB will inspect contents of this descriptor. |
| // Static initialization is necessary to prevent GDB from seeing |
| // uninitialized descriptor. |
| static REFERENCED_FROM_ASM JITDescriptor __jit_debug_descriptor = { 1, 0, nullptr, nullptr }; |
| |
| } // extern "C" |
| |
| namespace JSC { |
| |
| namespace GdbJITInternal { |
| static constexpr bool verbose = false; |
| } // namespace GdbJITInternal |
| |
| WTF_MAKE_TZONE_ALLOCATED_IMPL(GdbJIT); |
| |
| GdbJIT& GdbJIT::singleton() |
| { |
| static LazyNeverDestroyed<GdbJIT> logger; |
| static std::once_flag onceKey; |
| std::call_once(onceKey, [] { |
| logger.construct(); |
| }); |
| return logger.get(); |
| } |
| |
| #if OS(DARWIN) |
| class MachO; |
| class MachOSection; |
| using DebugObject = MachO; |
| using DebugSection = MachOSection; |
| #else |
| class ELF; |
| class ELFSection; |
| class ELFStringTable; |
| using DebugObject = ELF; |
| using DebugSection = ELFSection; |
| #endif |
| |
| template<typename V> |
| static inline void writeUnalignedValue(uint8_t* p, V value) |
| { |
| memcpy(p, &value, sizeof(V)); |
| } |
| |
| class Writer : public RefCountedAndCanMakeWeakPtr<Writer> { |
| public: |
| static Ref<Writer> create(DebugObject* obj) |
| { |
| return adoptRef(*new Writer(obj)); |
| } |
| |
| uintptr_t position() const { return m_position; } |
| |
| template<typename T> |
| class Slot { |
| public: |
| Slot(WeakPtr<Writer> writer, uintptr_t offset) |
| : m_writer(writer) |
| , m_offset(offset) |
| { |
| } |
| |
| T* operator->() { return m_writer->template rawSlotAt<T>(m_offset); } |
| T operator*() { return *m_writer->template rawSlotAt<T>(m_offset); } |
| |
| void set(const T& value) |
| { |
| writeUnalignedValue(m_writer->template addressAt<T>(m_offset), value); |
| } |
| |
| Slot<T> at(int i) { return Slot<T>(m_writer, m_offset + sizeof(T) * i); } |
| |
| private: |
| WeakPtr<Writer> m_writer; |
| uintptr_t m_offset; |
| }; |
| |
| template<typename T> |
| void write(const T& val) |
| { |
| ensure(m_position + sizeof(T)); |
| writeUnalignedValue(addressAt<T>(m_position), val); |
| m_position += sizeof(T); |
| } |
| |
| template<typename T> |
| Slot<T> slotAt(uintptr_t offset) LIFETIME_BOUND |
| { |
| ensure(offset + sizeof(T)); |
| return Slot<T>(*this, offset); |
| } |
| |
| template<typename T> |
| Slot<T> createSlotHere() LIFETIME_BOUND |
| { |
| return createSlotsHere<T>(1); |
| } |
| |
| template<typename T> |
| Slot<T> createSlotsHere(uint32_t count) LIFETIME_BOUND |
| { |
| uintptr_t slotPosition = m_position; |
| m_position += sizeof(T) * count; |
| ensure(m_position); |
| return slotAt<T>(slotPosition); |
| } |
| |
| void ensure(uintptr_t pos) |
| { |
| if (m_buffer.size() < pos) |
| m_buffer.grow(pos); |
| } |
| |
| DebugObject* debugObject() { return m_debugObject; } |
| |
| uint8_t* buffer() LIFETIME_BOUND { return &m_buffer[0]; } |
| |
| void align(uintptr_t align) |
| { |
| uintptr_t delta = m_position % align; |
| if (!delta) |
| return; |
| uintptr_t padding = align - delta; |
| ensure(m_position += padding); |
| ASSERT(m_position % align == 0); |
| } |
| |
| void writeULEB128(uintptr_t value) |
| { |
| do { |
| uint8_t byte = value & 0x7F; |
| value >>= 7; |
| if (value) |
| byte |= 0x80; |
| write<uint8_t>(byte); |
| } while (value); |
| } |
| |
| void writeSLEB128(intptr_t value) |
| { |
| bool more = true; |
| while (more) { |
| int8_t byte = value & 0x7F; |
| bool byteSign = byte & 0x40; |
| value >>= 7; |
| |
| if ((!value && !byteSign) || (value == -1 && byteSign)) |
| more = false; |
| else |
| byte |= 0x80; |
| |
| write<int8_t>(byte); |
| } |
| } |
| |
| void writeString(const CString& str) |
| { |
| for (auto c : str.span()) |
| write<char>(c); |
| write<char>('\0'); |
| } |
| |
| private: |
| template<typename T> |
| friend class Slot; |
| |
| template<typename T> |
| uint8_t* addressAt(uintptr_t offset) LIFETIME_BOUND |
| { |
| ASSERT(offset < m_buffer.size() && offset + sizeof(T) <= m_buffer.size()); |
| return &m_buffer[offset]; |
| } |
| |
| template<typename T> |
| T* rawSlotAt(uintptr_t offset) LIFETIME_BOUND |
| { |
| ASSERT(offset < m_buffer.size() && offset + sizeof(T) <= m_buffer.size()); |
| return reinterpret_cast<T*>(&m_buffer[offset]); |
| } |
| |
| Writer(DebugObject* debugObject) |
| : m_debugObject(debugObject) |
| , m_position(0) |
| { |
| } |
| |
| DebugObject* m_debugObject; |
| uintptr_t m_position; |
| Vector<uint8_t> m_buffer; |
| }; |
| |
| class CodeDescription : public RefCounted<CodeDescription> { |
| public: |
| const CString& name() const LIFETIME_BOUND { return m_name; } |
| |
| const void* codeStart() const { return reinterpret_cast<const void*>(m_codeRegion.data()); } |
| |
| const void* codeEnd() const { return reinterpret_cast<const void*>(m_codeRegion.data() + m_codeRegion.size()); } |
| |
| uintptr_t codeSize() const { return m_codeRegion.size(); } |
| |
| std::span<const uint8_t> region() { return m_codeRegion; } |
| |
| static Ref<CodeDescription> create(const CString& name, std::span<const uint8_t> region) |
| { |
| return adoptRef(*new CodeDescription(name, region)); |
| } |
| |
| private: |
| CodeDescription(const CString& name, std::span<const uint8_t> region) |
| : m_name(name) |
| , m_codeRegion(region) |
| { |
| } |
| |
| CString m_name; |
| std::span<const uint8_t> m_codeRegion; |
| }; |
| |
| static JITCodeEntry* createCodeEntry(uint8_t* symfileAddr, uintptr_t symfileSize) |
| { |
| // It is easiest to just leak this. |
| auto* entry = static_cast<JITCodeEntry*>(malloc(sizeof(JITCodeEntry) + symfileSize)); |
| |
| entry->symfileAddr = reinterpret_cast<uint8_t*>(entry + 1); |
| entry->symfileSize = symfileSize; |
| memcpy(entry->symfileAddr, symfileAddr, symfileSize); |
| |
| entry->prev = entry->next = nullptr; |
| |
| return entry; |
| } |
| |
| static void registerCodeEntry(JITCodeEntry* entry) |
| { |
| entry->next = __jit_debug_descriptor.firstEntry; |
| if (entry->next) |
| entry->next->prev = entry; |
| __jit_debug_descriptor.firstEntry = __jit_debug_descriptor.relevantEntry = entry; |
| |
| __jit_debug_descriptor.actionFlag = RegisterFunction; |
| __jit_debug_register_code(); |
| } |
| |
| static void unregisterCodeEntry(JITCodeEntry* entry) |
| { |
| if (entry->prev) |
| entry->prev->next = entry->next; |
| else |
| __jit_debug_descriptor.firstEntry = entry->next; |
| |
| if (entry->next) |
| entry->next->prev = entry->prev; |
| |
| __jit_debug_descriptor.relevantEntry = entry; |
| __jit_debug_descriptor.actionFlag = UnregisterFunction; |
| __jit_debug_register_code(); |
| } |
| |
| template <typename THeader> |
| class DebugSectionBase { |
| WTF_DEPRECATED_MAKE_FAST_ALLOCATED(DebugSectionBase); |
| |
| public: |
| virtual ~DebugSectionBase() = default; |
| |
| virtual void writeBody(Writer::Slot<THeader> header, Ref<Writer> writer) |
| { |
| uint64_t start = writer->position(); |
| if (writeBodyInternal(writer)) { |
| header->offset = static_cast<uint32_t>(start); |
| uint64_t end = writer->position(); |
| header->size = std::max(end - start, static_cast<uint64_t>(header->size)); |
| } |
| } |
| |
| virtual bool writeBodyInternal(Ref<Writer>) { return false; } |
| |
| using Header = THeader; |
| }; |
| |
| struct MachOSectionHeader { |
| char sectname[16]; |
| char segname[16]; |
| uint64_t addr; |
| uint64_t size; |
| uint32_t offset; |
| uint32_t align; |
| uint32_t reloff; |
| uint32_t nreloc; |
| uint32_t flags; |
| uint32_t reserved1; |
| uint32_t reserved2; |
| uint32_t reserved3; |
| } __attribute__((packed,aligned(1))); |
| |
| class MachOSection : public DebugSectionBase<MachOSectionHeader> { |
| public: |
| enum Type { |
| Regular = 0x0u, |
| AttrCoalesced = 0xBu, |
| AttrSomeInstructions = 0x400u, |
| AttrDebug = 0x02000000u, |
| AttrPureInstructions = 0x80000000u |
| }; |
| |
| MachOSection(const CString& name, const CString& segment, uint32_t align, const void* addr, size_t size, uint32_t flags) |
| : m_name(name) |
| , m_segment(segment) |
| , m_align(align) |
| , m_addr(addr) |
| , m_size(size) |
| , m_flags(flags) |
| { |
| if (m_align) { |
| ASSERT(WTF::isPowerOfTwo(align)); |
| m_align = WTF::fastLog2(align); |
| } |
| } |
| |
| ~MachOSection() override = default; |
| |
| virtual void populateHeader(Writer::Slot<Header> header) |
| { |
| header->addr = reinterpret_cast<uintptr_t>(m_addr); |
| header->size = m_size; |
| header->offset = 0; |
| header->align = m_align; |
| header->reloff = 0; |
| header->nreloc = 0; |
| header->flags = m_flags; |
| header->reserved1 = 0; |
| header->reserved2 = 0; |
| header->reserved3 = 0; |
| memset(header->sectname, 0, sizeof(header->sectname)); |
| memset(header->segname, 0, sizeof(header->segname)); |
| ASSERT(m_name.length() < sizeof(header->sectname)); |
| ASSERT(m_segment.length() < sizeof(header->segname)); |
| strncpy(header->sectname, m_name.data(), sizeof(header->sectname)); |
| strncpy(header->segname, m_segment.data(), sizeof(header->segname)); |
| } |
| |
| const void* addr() const { return m_addr; } |
| size_t size() const { return m_size; } |
| |
| private: |
| CString m_name; |
| CString m_segment; |
| uint32_t m_align; |
| const void* m_addr; |
| size_t m_size; |
| uint32_t m_flags; |
| }; |
| |
| struct ELFsectionHeader { |
| uint32_t name; |
| uint32_t type; |
| uintptr_t flags; |
| const void* address; |
| uintptr_t offset; |
| uintptr_t size; |
| uint32_t link; |
| uint32_t info; |
| uintptr_t alignment; |
| uintptr_t entrySize; |
| } __attribute__((packed,aligned(1))); |
| |
| #if OS(LINUX) |
| class ELFSection : public DebugSectionBase<ELFsectionHeader> { |
| public: |
| enum Type { |
| TypeNull = 0, |
| TypeProgBits = 1, |
| TypeSymTab = 2, |
| TypeStrTab = 3, |
| TypeRela = 4, |
| TypeHash = 5, |
| TypeDynamic = 6, |
| TypeNote = 7, |
| TypeNoBits = 8, |
| TypeRel = 9, |
| TypeShLib = 10, |
| TypeDynSym = 11, |
| TypeLoProc = 0x70000000, |
| TypeX86_64Unwind = 0x70000001, |
| TypeHiProc = 0x7FFFFFFF, |
| TypeLoUser = 0x80000000, |
| TypeHiUser = 0xFFFFFFFF |
| }; |
| |
| enum Flags { |
| FlagWrite = 1, |
| FlagAlloc = 2, |
| FlagExec = 4 |
| }; |
| |
| enum SpecialIndexes { |
| IndexAbsolute = 0xFFF1 |
| }; |
| |
| ELFSection(const CString& name, Type type, uintptr_t align) |
| : m_type(type) |
| , m_name(name) |
| , m_align(align) |
| { |
| } |
| |
| ~ELFSection() override = default; |
| |
| void populateHeader(Writer::Slot<Header>, ELFStringTable* strtab); |
| |
| void writeBody(Writer::Slot<Header> header, Ref<Writer> writer) override |
| { |
| uintptr_t start = writer->position(); |
| if (writeBodyInternal(writer)) { |
| uintptr_t end = writer->position(); |
| header->offset = start; |
| header->size = end - start; |
| } |
| } |
| |
| bool writeBodyInternal(Ref<Writer>) override { return false; } |
| |
| uint16_t index() const { return m_index; } |
| void setIndex(uint16_t index) { m_index = index; } |
| |
| const Type m_type; |
| |
| protected: |
| virtual void populateHeader(Writer::Slot<Header> header) |
| { |
| header->flags = 0; |
| header->address = 0; |
| header->offset = 0; |
| header->size = 0; |
| header->link = 0; |
| header->info = 0; |
| header->entrySize = 0; |
| } |
| |
| private: |
| CString m_name; |
| uintptr_t m_align; |
| uint16_t m_index; |
| }; |
| #endif // OS(LINUX) |
| |
| #if OS(DARWIN) |
| class MachOTextSection : public MachOSection { |
| public: |
| MachOTextSection(uint32_t align, const void* codeAddr, uintptr_t codeSize) |
| : MachOSection("__text", "__TEXT", align, codeAddr, codeSize, MachOSection::Regular | MachOSection::AttrSomeInstructions | MachOSection::AttrPureInstructions) |
| , m_codeAddr(reinterpret_cast<const uint64_t*>(codeAddr)) |
| , m_codeSize(codeSize) |
| { |
| } |
| |
| bool writeBodyInternal(Ref<Writer> writer) override |
| { |
| for (auto* ptr = m_codeAddr; ptr < m_codeAddr + m_codeSize / sizeof(uint64_t); ++ptr) |
| writer->write<uint64_t>(*ptr); |
| return true; |
| } |
| |
| private: |
| const uint64_t* m_codeAddr; |
| const size_t m_codeSize; |
| }; |
| #endif // OS(DARWIN) |
| |
| #if OS(LINUX) |
| class FullHeaderELFSection : public ELFSection { |
| public: |
| FullHeaderELFSection(const CString& name, Type type, uintptr_t align, const void* addr, uintptr_t offset, uintptr_t size, uintptr_t flags) |
| : ELFSection(name, type, align) |
| , m_addr(addr) |
| , m_offset(offset) |
| , m_size(size) |
| , m_flags(flags) |
| { |
| } |
| |
| protected: |
| void populateHeader(Writer::Slot<Header> header) override |
| { |
| ELFSection::populateHeader(header); |
| header->address = m_addr; |
| header->offset = m_offset; |
| header->size = m_size; |
| header->flags = m_flags; |
| } |
| |
| private: |
| const void* m_addr; |
| uintptr_t m_offset; |
| uintptr_t m_size; |
| uintptr_t m_flags; |
| }; |
| |
| class ELFStringTable : public ELFSection { |
| public: |
| explicit ELFStringTable(const CString& name) |
| : ELFSection(name, TypeStrTab, 1) |
| , m_writer(nullptr) |
| , m_offset(0) |
| , m_size(0) |
| { |
| } |
| |
| uintptr_t add(const CString& str) |
| { |
| if (!str.length()) |
| return 0; |
| |
| uintptr_t offset = m_size; |
| writeString(str); |
| return offset; |
| } |
| |
| void attachWriter(Ref<Writer> w) |
| { |
| m_writer = w.ptr(); |
| m_offset = m_writer->position(); |
| |
| // First entry in the string table should be an empty string. |
| writeString(""); |
| } |
| |
| void detachWriter() |
| { |
| m_writer = nullptr; |
| } |
| |
| void writeBody(Writer::Slot<Header> header, Ref<Writer>) override |
| { |
| ASSERT(!m_writer); |
| header->offset = m_offset; |
| header->size = m_size; |
| } |
| |
| private: |
| void writeString(const CString& str) |
| { |
| for (auto c : str.span()) |
| m_writer->write(c); |
| m_writer->write('\0'); |
| m_size += str.length() + 1; |
| } |
| |
| RefPtr<Writer> m_writer; |
| uintptr_t m_offset; |
| uintptr_t m_size; |
| }; |
| |
| void ELFSection::populateHeader(Writer::Slot<ELFSection::Header> header, ELFStringTable* strtab) |
| { |
| header->name = static_cast<uint32_t>(strtab->add(m_name)); |
| header->type = m_type; |
| header->alignment = m_align; |
| populateHeader(header); |
| } |
| #endif // OS(LINUX) |
| |
| #if OS(DARWIN) |
| class MachO { |
| WTF_DEPRECATED_MAKE_FAST_ALLOCATED(MachO); |
| |
| public: |
| size_t addSection(std::unique_ptr<MachOSection> section) |
| { |
| m_sections.append(WTFMove(section)); |
| return m_sections.size() - 1; |
| } |
| |
| void write(Ref<Writer> w, const CString& name, uintptr_t codeStart, uintptr_t) |
| { |
| Writer::Slot<MachOHeader> header = writeHeader(w); |
| uintptr_t loadCommandStart = w->position(); |
| |
| Vector<Writer::Slot<MachOSegmentCommand>> segmentCommands; |
| Vector<Writer::Slot<MachOSection::Header>> sectionHeadersForSegments; |
| |
| for (auto& section : m_sections) { |
| segmentCommands.append(writeSegmentCommand(w, reinterpret_cast<uintptr_t>(section->addr()), section->size())); |
| sectionHeadersForSegments.append(w->createSlotHere<MachOSection::Header>()); |
| } |
| |
| auto symtabCmd = writeSymtabCommand(w, name); |
| header->sizeOfCommands = static_cast<uint32_t>(w->position() - loadCommandStart); |
| |
| for (unsigned i = 0; i < m_sections.size(); ++i) { |
| auto segmentCmd = segmentCommands[i]; |
| auto sectionHeader = sectionHeadersForSegments[i]; |
| segmentCmd->fileOff = w->position(); |
| m_sections[i]->populateHeader(sectionHeader); |
| m_sections[i]->writeBody(sectionHeader, w); |
| segmentCmd->fileSize = w->position() - segmentCmd->fileOff; |
| segmentCmd->vmSize = sectionHeader->size; |
| } |
| |
| writeNList(w, symtabCmd, codeStart); |
| writeStringTable(w, name, symtabCmd); |
| } |
| |
| private: |
| struct MachOHeader { |
| uint32_t magic; |
| uint32_t cpuType; |
| uint32_t cpuSubtype; |
| uint32_t fileType; |
| uint32_t numCommands; |
| uint32_t sizeOfCommands; |
| uint32_t flags; |
| #if USE(JSVALUE64) |
| uint32_t reserved; |
| #endif |
| } __attribute__((packed,aligned(1))); |
| |
| struct MachOSegmentCommand { |
| uint32_t cmd; |
| uint32_t cmdSize; |
| char segname[16]; |
| uint64_t vmAddr; |
| uint64_t vmSize; |
| uint64_t fileOff; |
| uint64_t fileSize; |
| uint32_t maxProt; |
| uint32_t initProt; |
| uint32_t numSects; |
| uint32_t flags; |
| } __attribute__((packed,aligned(1))); |
| |
| struct MachOSymtabCommand { |
| uint32_t cmd; |
| uint32_t cmdSize; |
| uint32_t symFileOff; |
| uint32_t numSyms; |
| uint32_t strFileOff; |
| uint32_t stringBytes; |
| } __attribute__((packed,aligned(1))); |
| |
| enum MachOLoadCommandCmd { |
| LCSegment32 = 0x00000001u, |
| LCSymTab = 0x00000002u, |
| LCSegment64 = 0x00000019u, |
| }; |
| |
| enum NListType { |
| NAbs = 0x2, |
| NSect = 0xe, |
| }; |
| |
| enum NListDescription { |
| ReferenceFlagDefined = 0x2, |
| }; |
| |
| struct __attribute__((packed)) NList64 { |
| uint32_t index; |
| uint8_t type; |
| uint8_t section; |
| uint16_t desc; |
| uint64_t value; |
| }; |
| |
| Writer::Slot<MachOHeader> writeHeader(Ref<Writer> writer) |
| { |
| ASSERT(!writer->position()); |
| Writer::Slot<MachOHeader> header = writer->createSlotHere<MachOHeader>(); |
| #if CPU(ARM64) |
| header->magic = 0xFEEDFACFu; |
| header->cpuType = 0x0000000C | 0x01000000; // ARM | 64-bit ABI |
| header->cpuSubtype = 0x00000000; // All |
| header->reserved = 0; |
| #elif CPU(X86_64) |
| header->magic = 0xFEEDFACFu; |
| header->cpuType = 7 | 0x01000000; // i386 | 64-bit ABI |
| header->cpuSubtype = 3; |
| header->reserved = 0; |
| #else |
| #error Unsupported target architecture. |
| #endif |
| header->fileType = 0x1; // MH_OBJECT |
| header->numCommands = 3; |
| header->sizeOfCommands = 0; |
| header->flags = 0; |
| return header; |
| } |
| |
| Writer::Slot<MachOSegmentCommand> writeSegmentCommand(Ref<Writer> writer, uintptr_t codeStart, uintptr_t codeSize) |
| { |
| auto cmd = writer->createSlotHere<MachOSegmentCommand>(); |
| cmd->cmd = LCSegment64; |
| cmd->vmAddr = codeStart; |
| cmd->vmSize = codeSize; |
| cmd->fileOff = 0; |
| cmd->fileSize = 0; |
| cmd->maxProt = 7; |
| cmd->initProt = 7; |
| cmd->flags = 0; |
| cmd->numSects = 1; |
| memset(cmd->segname, 0, 16); |
| cmd->cmdSize = sizeof(MachOSegmentCommand) + sizeof(MachOSection::Header) * cmd->numSects; |
| return cmd; |
| } |
| |
| Writer::Slot<MachOSymtabCommand> writeSymtabCommand(Ref<Writer> writer, const CString& name) |
| { |
| auto cmd = writer->createSlotHere<MachOSymtabCommand>(); |
| cmd->cmd = LCSymTab; |
| cmd->symFileOff = 0; |
| cmd->numSyms = 1; |
| cmd->strFileOff = 0; |
| cmd->stringBytes = name.length() + 1; |
| cmd->cmdSize = sizeof(MachOSymtabCommand); |
| return cmd; |
| } |
| |
| void writeNList(Ref<Writer> writer, Writer::Slot<MachOSymtabCommand> cmd, uintptr_t codeStart) |
| { |
| cmd->symFileOff = writer->position(); |
| auto slot = writer->createSlotHere<NList64>(); |
| slot->index = 1; |
| slot->type = NSect; |
| slot->section = 2; |
| slot->desc = 0; |
| slot->value = codeStart; |
| } |
| |
| void writeStringTable(Ref<Writer> writer, const CString& name, Writer::Slot<MachOSymtabCommand> cmd) |
| { |
| cmd->strFileOff = writer->position(); |
| writer->write<char>('\0'); // Index 0 |
| for (auto c : name.span()) |
| writer->write<char>(c); |
| writer->write<char>('\0'); |
| } |
| |
| Vector<std::unique_ptr<MachOSection>> m_sections { }; |
| }; |
| #endif // OS(DARWIN) |
| |
| #if OS(LINUX) |
| class ELF { |
| public: |
| explicit ELF() |
| { |
| m_sections.append(WTF::makeUnique<ELFSection>("", ELFSection::TypeNull, 0)); |
| m_sections.append(WTF::makeUnique<ELFStringTable>(".shstrtab")); |
| } |
| |
| void write(Ref<Writer> writer) |
| { |
| writeHeader(writer); |
| writeSectionTable(writer); |
| writeSections(writer); |
| } |
| |
| ELFSection* SectionAt(uint32_t index) { return m_sections[index].get(); } |
| |
| size_t addSection(std::unique_ptr<ELFSection> section) |
| { |
| section->setIndex(m_sections.size()); |
| m_sections.append(WTFMove(section)); |
| return m_sections.size() - 1; |
| } |
| |
| private: |
| struct ELFHeader { |
| uint8_t ident[16]; |
| uint16_t type; |
| uint16_t machine; |
| uint32_t version; |
| uintptr_t entry; |
| uintptr_t phtOffset; |
| uintptr_t shtOffset; |
| uint32_t flags; |
| uint16_t headerSize; |
| uint16_t phtEntrySize; |
| uint16_t phtEntryNum; |
| uint16_t shtEntrySize; |
| uint16_t shtEntryNum; |
| uint16_t shtStrTabIndex; |
| } __attribute__((packed,aligned(1))); |
| |
| void writeHeader(Ref<Writer> writer) |
| { |
| ASSERT(!writer->position()); |
| Writer::Slot<ELFHeader> header = writer->createSlotHere<ELFHeader>(); |
| #if CPU(ARM_THUMB2) |
| const uint8_t ident[16] = { |
| 0x7F, 'E', 'L', 'F', 1, 1, 1, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0 |
| }; |
| #elif CPU(X86_64) || CPU(ARM64) |
| const uint8_t ident[16] = { |
| 0x7F, 'E', 'L', 'F', 2, 1, 1, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0 |
| }; |
| #else |
| #error Unsupported target architecture. |
| #endif |
| memcpy(header->ident, ident, 16); |
| header->type = 1; |
| #if CPU(X86_64) |
| // Processor identification value for x64 is 62 as defined in |
| // System V ABI, AMD64 Supplement |
| // http://www.x86-64.org/documentation/abi.pdf |
| header->machine = 62; |
| #elif CPU(ARM_THUMB2) |
| // Set to EM_ARM, defined as 40, in "ARM ELF File Format" at |
| // infocenter.arm.com/help/topic/com.arm.doc.dui0101a/DUI0101A_Elf.pdf |
| header->machine = 40; |
| #elif CPU(ARM64) |
| // AARCH64 |
| header->machine = 0xB7; |
| #else |
| #error Unsupported target architecture. |
| #endif |
| header->version = 1; |
| header->entry = 0; |
| header->phtOffset = 0; |
| header->shtOffset = sizeof(ELFHeader); // Section table follows header. |
| header->flags = 0; |
| header->headerSize = sizeof(ELFHeader); |
| header->phtEntrySize = 0; |
| header->phtEntryNum = 0; |
| header->shtEntrySize = sizeof(ELFSection::Header); |
| header->shtEntryNum = m_sections.size(); |
| header->shtStrTabIndex = 1; |
| } |
| |
| void writeSectionTable(Ref<Writer> writer) |
| { |
| // Section headers table immediately follows file header. |
| ASSERT(writer->position() == sizeof(ELFHeader)); |
| |
| Writer::Slot<ELFSection::Header> headers = writer->createSlotsHere<ELFSection::Header>( |
| static_cast<uint32_t>(m_sections.size())); |
| |
| // String table for section table is the first section. |
| ELFStringTable* strtab = static_cast<ELFStringTable*>(SectionAt(1)); |
| ASSERT(strtab->m_type == ELFSection::TypeStrTab); |
| strtab->attachWriter(writer); |
| uint32_t index = 0; |
| for (auto& section : m_sections) { |
| section->populateHeader(headers.at(index), strtab); |
| index++; |
| } |
| strtab->detachWriter(); |
| } |
| |
| void writeSections(Ref<Writer> writer) |
| { |
| Writer::Slot<ELFSection::Header> headers = writer->slotAt<ELFSection::Header>(sizeof(ELFHeader)); |
| |
| uint32_t index = 0; |
| for (auto& section : m_sections) { |
| section->writeBody(headers.at(index), writer); |
| index++; |
| } |
| } |
| |
| Vector<std::unique_ptr<ELFSection>> m_sections; |
| }; |
| |
| class ELFSymbol { |
| public: |
| enum Type { |
| TypeNone = 0, |
| TypeObject = 1, |
| TypeFunction = 2, |
| TypeSection = 3, |
| TypeFile = 4, |
| TypeLoProc = 13, |
| TypeHiProc = 15 |
| }; |
| |
| enum Binding { |
| BindLocal = 0, |
| BindGlobal = 1, |
| BindWeak = 2, |
| BindLoProc = 13, |
| BindHiProc = 15 |
| }; |
| |
| ELFSymbol(const CString& name, uintptr_t value, uintptr_t size, Binding binding, Type type, uint16_t section) |
| : m_name(name) |
| , m_value(value) |
| , m_size(size) |
| , m_info((binding << 4) | type) |
| , m_other(0) |
| , m_section(section) |
| { |
| } |
| |
| Binding binding() const { return static_cast<Binding>(m_info >> 4); } |
| |
| #if CPU(ARM_THUMB2) |
| struct SerializedLayout { |
| SerializedLayout(uint32_t name, uintptr_t value, uintptr_t size, Binding binding, Type type, uint16_t section) |
| : m_name(name) |
| , m_value(value) |
| , m_size(size) |
| , m_info((binding << 4) | type) |
| , m_other(0) |
| , m_section(section) |
| { |
| } |
| |
| uint32_t m_name; |
| uintptr_t m_value; |
| uintptr_t m_size; |
| uint8_t m_info; |
| uint8_t m_other; |
| uint16_t m_section; |
| } __attribute__((packed,aligned(1))); |
| #elif CPU(X86_64) || CPU(ARM64) |
| struct SerializedLayout { |
| SerializedLayout(uint32_t name, uintptr_t value, uintptr_t size, Binding binding, Type type, uint16_t section) |
| : m_name(name) |
| , m_info((binding << 4) | type) |
| , m_other(0) |
| , m_section(section) |
| , m_value(value) |
| , m_size(size) |
| { |
| } |
| |
| uint32_t m_name; |
| uint8_t m_info; |
| uint8_t m_other; |
| uint16_t m_section; |
| uintptr_t m_value; |
| uintptr_t m_size; |
| } __attribute__((packed,aligned(1))); |
| #endif |
| |
| void write(Writer::Slot<SerializedLayout> slot, ELFStringTable* table) const |
| { |
| // Convert symbol names from strings to indexes in the string table. |
| slot->m_name = static_cast<uint32_t>(table->add(m_name)); |
| slot->m_value = m_value; |
| slot->m_size = m_size; |
| slot->m_info = m_info; |
| slot->m_other = m_other; |
| slot->m_section = m_section; |
| } |
| |
| private: |
| CString m_name; |
| uintptr_t m_value; |
| uintptr_t m_size; |
| uint8_t m_info; |
| uint8_t m_other; |
| uint16_t m_section; |
| }; |
| |
| class ELFSymbolTable : public ELFSection { |
| public: |
| ELFSymbolTable(const CString& name) |
| : ELFSection(name, TypeSymTab, sizeof(uintptr_t)) |
| { |
| } |
| |
| void writeBody(Writer::Slot<Header> header, Ref<Writer> writer) override |
| { |
| writer->align(header->alignment); |
| size_t totalSymbols = m_locals.size() + m_globals.size() + 1; |
| header->offset = writer->position(); |
| |
| Writer::Slot<ELFSymbol::SerializedLayout> symbols = writer->createSlotsHere<ELFSymbol::SerializedLayout>( |
| static_cast<uint32_t>(totalSymbols)); |
| |
| header->size = writer->position() - header->offset; |
| |
| // String table for this symbol table should follow it in the section table. |
| ELFStringTable* strtab = static_cast<ELFStringTable*>(writer->debugObject()->SectionAt(index() + 1)); |
| ASSERT(strtab->m_type == ELFSection::TypeStrTab); |
| strtab->attachWriter(writer); |
| symbols.at(0).set(ELFSymbol::SerializedLayout(0, 0, 0, ELFSymbol::BindLocal, ELFSymbol::TypeNone, 0)); |
| writeSymbolsList(&m_locals, symbols.at(1), strtab); |
| writeSymbolsList(&m_globals, symbols.at(static_cast<uint32_t>(m_locals.size() + 1)), strtab); |
| strtab->detachWriter(); |
| } |
| |
| void add(const ELFSymbol& symbol) |
| { |
| if (symbol.binding() == ELFSymbol::BindLocal) |
| m_locals.append(symbol); |
| else |
| m_globals.append(symbol); |
| } |
| |
| protected: |
| void populateHeader(Writer::Slot<Header> header) override |
| { |
| ELFSection::populateHeader(header); |
| // We are assuming that string table will follow symbol table. |
| header->link = index() + 1; |
| header->info = static_cast<uint32_t>(m_locals.size() + 1); |
| header->entrySize = sizeof(ELFSymbol::SerializedLayout); |
| } |
| |
| private: |
| void writeSymbolsList(const Vector<ELFSymbol>* src, |
| Writer::Slot<ELFSymbol::SerializedLayout> dst, |
| ELFStringTable* strtab) |
| { |
| int i = 0; |
| for (const ELFSymbol& symbol : *src) |
| symbol.write(dst.at(i++), strtab); |
| } |
| |
| Vector<ELFSymbol> m_locals; |
| Vector<ELFSymbol> m_globals; |
| }; |
| |
| static void createSymbolsTable(Ref<CodeDescription> desc, ELF* elf, size_t textSectionIndex) |
| { |
| auto symtab = WTF::makeUnique<ELFSymbolTable>(".symtab"); |
| auto strtab = WTF::makeUnique<ELFStringTable>(".strtab"); |
| |
| symtab->add(ELFSymbol("JSC Code", 0, 0, ELFSymbol::BindLocal, |
| ELFSymbol::TypeFile, ELFSection::IndexAbsolute)); |
| |
| symtab->add(ELFSymbol(desc->name(), 0, desc->codeSize(), |
| ELFSymbol::BindGlobal, ELFSymbol::TypeFunction, textSectionIndex)); |
| |
| // Symbol table should be followed by the linked string table. |
| elf->addSection(WTFMove(symtab)); |
| elf->addSection(WTFMove(strtab)); |
| } |
| #endif // OS(LINUX) |
| |
| class UnwindInfoSection : public DebugSection { |
| public: |
| explicit UnwindInfoSection(Ref<CodeDescription>); |
| bool writeBodyInternal(Ref<Writer>) override; |
| |
| int writeCIE(Ref<Writer>, uint32_t debugSectionStart); |
| Writer::Slot<int32_t> writeFDE(Ref<Writer>); |
| void writeFDEState(Ref<Writer>); |
| void WriteLength(Ref<Writer>, Writer::Slot<uint32_t>* lengthSlot, int initialPosition); |
| |
| private: |
| const Ref<CodeDescription> m_desc; |
| |
| // DWARF3 Specification, Table 7.23 |
| enum CFIInstructions { |
| AdvanceLoc = 0x40, |
| Offset = 0x80, |
| Restore = 0xC0, |
| Nop = 0x00, |
| SetLoc = 0x01, |
| AdvanceLoc1 = 0x02, |
| AdvanceLoc2 = 0x03, |
| AdvanceLoc4 = 0x04, |
| OffsetExtended = 0x05, |
| RestoreExtended = 0x06, |
| Undefined = 0x07, |
| SameValue = 0x08, |
| Register = 0x09, |
| RememberState = 0x0A, |
| RestoreState = 0x0B, |
| DefCFA = 0x0C, |
| DefCFARegister = 0x0D, |
| DefCFAOffset = 0x0E, |
| DefCFAExpression = 0x0F, |
| Expression = 0x10, |
| OffsetExtendedSF = 0x11, |
| DefCFASF = 0x12, |
| DefCFAOffsetSF = 0x13, |
| ValOffset = 0x14, |
| ValOffsetSF = 0x15, |
| ValExpression = 0x16 |
| }; |
| |
| // System V ABI, AMD64 Supplement, Version 0.99.5, Figure 3.36 |
| enum RegisterMapping { |
| // Only the relevant ones have been added to reduce clutter. |
| #if CPU(X86_64) |
| RegisterFP = 6, |
| RegisterLR = 16, |
| #elif CPU(ARM64) |
| RegisterFP = 29, |
| RegisterLR = 30, |
| #else |
| RegisterFP = 7, |
| RegisterLR = 14, |
| #endif |
| }; |
| |
| enum CFIConstants : uint32_t { |
| CIEID = UINT32_MAX, |
| CIEVersion = 4, |
| CodeAlignFactor = 1, |
| DataAlignFactor = 1, |
| ReturnAddressRegister = RegisterLR |
| }; |
| }; |
| |
| void UnwindInfoSection::WriteLength(Ref<Writer> writer, Writer::Slot<uint32_t>* lengthSlot, int initialPosition) |
| { |
| uint32_t align = (writer->position() - initialPosition) % sizeof(void*); |
| |
| if (align) { |
| for (uint32_t i = 0; i < (sizeof(void*) - align); i++) |
| writer->write<uint8_t>(Nop); |
| } |
| |
| ASSERT((writer->position() - initialPosition) % sizeof(void*) == 0); |
| lengthSlot->set(static_cast<uint32_t>(writer->position() - initialPosition)); |
| } |
| |
| UnwindInfoSection::UnwindInfoSection(Ref<CodeDescription> desc) |
| #if OS(LINUX) |
| : ELFSection(".debug_frame", TypeProgBits, 1) |
| #elif OS(DARWIN) |
| : MachOSection("__debug_frame", "__TEXT", sizeof(uintptr_t), 0, 0, MachOSection::Regular) |
| #else |
| #error "Unsupported platform" |
| #endif |
| , m_desc(desc) |
| { |
| } |
| |
| int UnwindInfoSection::writeCIE(Ref<Writer> writer, uint32_t) |
| { |
| auto ciePosition = static_cast<uint32_t>(writer->position()); |
| auto cieLengthSlot = writer->createSlotHere<uint32_t>(); |
| |
| writer->write<uint32_t>(CIEID); |
| writer->write<uint8_t>(CIEVersion); |
| writer->write<uint8_t>(0); // Null augmentation string. |
| writer->write<uint8_t>(sizeof(uintptr_t)); // Address size |
| writer->write<uint8_t>(0); // Segment size |
| writer->writeULEB128(CodeAlignFactor); |
| writer->writeSLEB128(DataAlignFactor); |
| writer->writeULEB128(ReturnAddressRegister); |
| |
| WriteLength(writer, &cieLengthSlot, ciePosition + sizeof(*cieLengthSlot)); |
| |
| return ciePosition; |
| } |
| |
| Writer::Slot<int32_t> UnwindInfoSection::writeFDE(Ref<Writer> writer) |
| { |
| int fdePosition = static_cast<uint32_t>(writer->position()); |
| auto fdeLengthSlot = writer->createSlotHere<uint32_t>(); |
| auto ciePointerSlot = writer->createSlotHere<int32_t>(); |
| |
| writer->write<uintptr_t>(reinterpret_cast<uintptr_t>(m_desc->codeStart())); |
| writer->write<uintptr_t>(reinterpret_cast<uintptr_t>(m_desc->codeSize())); |
| |
| writeFDEState(writer); |
| |
| WriteLength(writer, &fdeLengthSlot, fdePosition + sizeof(*fdeLengthSlot)); |
| return ciePointerSlot; |
| } |
| |
| // You can read an example unwind section from GCC: |
| // readelf --debug-dump=frames ./test |
| // Or: |
| // llvm-dwarfdump -a "/tmp/jit-8113659Thunk: CallTrampoline.o" |
| // Also, try adding `log enable lldb unwind` to your .lldbinit if you debug with lldb, |
| // or `set debug frame on` and `set debug jit on` for gdb. |
| // https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf |
| // https://github.com/ARM-software/abi-aa/blob/main/aadwarf64/aadwarf64.rst#dwarf-register-names |
| // https://dwarfstd.org/doc/DWARF5.pdf |
| /* |
| CFA means canonical frame address. These bytecodes define CFA in terms of other registers, |
| or other registers in terms of CFA. |
| |
| In the CIE: |
| DW_CFA_def_cfa: r31 (sp) ofs 0 |
| |
| 00000000004007a4 <main>: |
| 4007a4: d100c3ff sub sp, sp, #0x30 (decimal 48) |
| |
| DW_CFA_def_cfa_offset: 48 |
| |
| 4007a8: a9027bfd stp fp, lr, [sp, #32] |
| 4007ac: 910083fd add fp, sp, #0x20 |
| |
| DW_CFA_def_cfa: r29 (fp) ofs 16 |
| DW_CFA_offset: r30 (lr) at cfa-8 |
| DW_CFA_offset: r29 (fp) at cfa-16 |
| |
| <snip> |
| |
| DW_CFA_def_cfa: r31 (sp) ofs 48 |
| |
| 400840: a9427bfd ldp fp, lr, [sp, #32] |
| 400844: 9100c3ff add sp, sp, #0x30 |
| |
| DW_CFA_def_cfa_offset: 0 |
| DW_CFA_restore: r30 (lr) |
| DW_CFA_restore: r29 (fp) |
| 400848: d65f03c0 ret |
| |
| The generated table: |
| |
| 0x4007a4: CFA=WSP |
| 0x4007a8: CFA=WSP+48 |
| 0x4007b0: CFA=W29+16: W29=[CFA-16], W30=[CFA-8] |
| 0x400840: CFA=WSP+48: W29=[CFA-16], W30=[CFA-8] |
| 0x400848: CFA=WSP |
| */ |
| |
| void UnwindInfoSection::writeFDEState(Ref<Writer> writer) |
| { |
| // The first state, just after the control has been transferred to the the |
| // function. |
| // Since we just want simple unwinding to work, we will just use this blanket rule to |
| // force the unwidner to check fp. It won't be accurate, but it should be good enough for |
| // basic debugging. |
| // Consider when we are after these instructions: |
| // stp fp, lr |
| // mov fp, sp |
| // Then: |
| // CFA = fp (current) + 8 |
| // fp (previous value) = *(CFA - 16); lr / Return Address (saved) = *(CFA - 8); |
| // Start with a bogus rule. LLDB is off by one some times, and this seemed to fix it for some reason. |
| writer->write<uint8_t>(DefCFASF); |
| writer->writeULEB128(RegisterFP); |
| writer->writeSLEB128(0); |
| writer->write<uint8_t>(AdvanceLoc1); |
| writer->write<uint8_t>(is32Bit() ? 2 : 4); |
| writer->write<uint8_t>(DefCFASF); |
| writer->writeULEB128(RegisterFP); |
| writer->writeSLEB128(static_cast<int32_t>(sizeof(CallerFrameAndPC))); |
| writer->write<uint8_t>(OffsetExtendedSF); |
| writer->writeULEB128(RegisterLR); |
| writer->writeSLEB128(-static_cast<int32_t>(sizeof(uintptr_t))); |
| writer->write<uint8_t>(OffsetExtendedSF); |
| writer->writeULEB128(RegisterFP); |
| writer->writeSLEB128(-2 * static_cast<int32_t>(sizeof(uintptr_t))); |
| } |
| |
| bool UnwindInfoSection::writeBodyInternal(Ref<Writer> writer) |
| { |
| uint32_t debugSectionStart = writer->position(); |
| // This is a throw-away; The CIE must come first for LLDB to be happy, but |
| // the offset can't be 0 according to the spec / gdb. |
| writeCIE(writer, debugSectionStart); |
| auto ciePosition = writeCIE(writer, debugSectionStart); |
| auto ciePointer = writeFDE(writer); |
| ciePointer.set(ciePosition - debugSectionStart); |
| return true; |
| } |
| |
| static JITCodeEntry* createELFObject(Ref<CodeDescription> desc) |
| { |
| constexpr int codeAlignment = 4; |
| #if OS(DARWIN) |
| MachO machO; |
| auto writer = Writer::create(&machO); |
| |
| if constexpr (isARM64()) |
| machO.addSection(WTF::makeUnique<UnwindInfoSection>(desc)); |
| machO.addSection(WTF::makeUnique<MachOTextSection>(codeAlignment, desc->codeStart(), desc->codeSize())); |
| |
| machO.write(writer, desc->name(), reinterpret_cast<uintptr_t>(desc->codeStart()), desc->codeSize()); |
| #else |
| ELF elf; |
| auto writer = Writer::create(&elf); |
| |
| size_t textSectionIndex = elf.addSection(WTF::makeUnique<FullHeaderELFSection>( |
| ".text", ELFSection::TypeNoBits, codeAlignment, desc->codeStart(), 0, |
| desc->codeSize(), ELFSection::FlagAlloc | ELFSection::FlagExec)); |
| |
| createSymbolsTable(desc, &elf, textSectionIndex); |
| if constexpr (isARM64() || is32Bit()) |
| elf.addSection(WTF::makeUnique<UnwindInfoSection>(desc)); |
| |
| elf.write(writer); |
| #endif |
| |
| return createCodeEntry(writer->buffer(), writer->position()); |
| } |
| |
| static std::optional<std::pair<GdbJITCodeMap::iterator, GdbJITCodeMap::iterator>> |
| getOverlappingRegions(GdbJITCodeMap& map, const std::span<const uint8_t> region) |
| { |
| ASSERT(region.data() < region.data() + region.size()); |
| |
| if (map.empty()) |
| return std::nullopt; |
| |
| // Find the first overlapping entry. |
| |
| // If successful, points to the first element not less than `region`. The |
| // returned iterator has the key in `first` and the value in `second`. |
| auto it = map.lower_bound(region); |
| auto startIt = it; |
| |
| if (it == map.end()) { |
| startIt = map.begin(); |
| // Find the first overlapping entry. |
| for (; startIt != map.end(); ++startIt) { |
| if (startIt->first.data() + startIt->first.size() > region.data()) |
| break; |
| } |
| } else if (it != map.begin()) { |
| for (--it; it != map.begin(); --it) { |
| if (it->first.data() + it->first.size() <= region.data()) |
| break; |
| startIt = it; |
| } |
| if (it == map.begin() && it->first.data() + it->first.size() > region.data()) |
| startIt = it; |
| } |
| |
| if (startIt == map.end()) |
| return std::nullopt; |
| |
| // Find the first non-overlapping entry after `region`. |
| |
| const auto endIt = map.lower_bound({ region.data() + region.size(), 0 }); |
| |
| // Return a range containing intersecting regions. |
| |
| if (std::distance(startIt, endIt) < 1) |
| return std::nullopt; // No overlapping entries. |
| |
| return { { startIt, endIt } }; |
| } |
| |
| static void removeJITCodeEntries(GdbJITCodeMap& map, const std::span<const uint8_t> region) |
| { |
| if (auto overlap = getOverlappingRegions(map, region)) { |
| auto startIt = overlap->first; |
| auto endIt = overlap->second; |
| for (auto it = startIt; it != endIt; ++it) |
| unregisterCodeEntry(it->second); |
| |
| map.erase(startIt, endIt); |
| } |
| } |
| |
| // Insert the entry into the map and register it with GDB. |
| static void addJITCodeEntry(GdbJITCodeMap& map, std::span<const uint8_t> region, |
| JITCodeEntry* entry, bool shouldDump, const CString& nameHint) |
| { |
| static int fileNum = 0; |
| if (shouldDump) { |
| StringPrintStream filename; |
| if (auto* optionalDirectory = Options::jitDumpDirectory()) |
| filename.print(optionalDirectory); |
| else |
| filename.print("/tmp"); |
| filename.print("/jit-", getCurrentProcessID(), fileNum++, nameHint, ".o"); |
| auto fd = open(filename.toCString().data(), O_CREAT | O_TRUNC | O_RDWR, 0666); |
| RELEASE_ASSERT(fd != -1); |
| auto file = fdopen(fd, "wb"); |
| RELEASE_ASSERT(file); |
| |
| fwrite(entry->symfileAddr, entry->symfileSize, 1, file); |
| fflush(file); |
| dataLogLnIf(GdbJITInternal::verbose, "GDBInfo dumped: ", nameHint, " ", RawPointer(region.data()), "-", RawPointer(region.data() + region.size()), " ", region.size(), " ", filename.toCString().data()); |
| } |
| |
| auto result = map.emplace(region, entry); |
| ASSERT_UNUSED(result, result.second); // Insertion happened. |
| |
| registerCodeEntry(entry); |
| } |
| |
| void GdbJIT::log(const CString& name, MacroAssemblerCodeRef<LinkBufferPtrTag> code) |
| { |
| if (!Options::useGdbJITInfo()) |
| return; |
| GdbJIT& logger = singleton(); |
| size_t size = code.size(); |
| auto* executableAddress = code.code().untaggedPtr<const uint8_t*>(); |
| if (!size) { |
| dataLogLnIf(GdbJITInternal::verbose, "0 size record ", name, " ", RawPointer(executableAddress)); |
| return; |
| } |
| |
| Locker locker { logger.m_lock }; |
| |
| auto region = unsafeMakeSpan(executableAddress, size); |
| removeJITCodeEntries(logger.m_map, region); |
| auto* entry = createELFObject(CodeDescription::create(name, region)); |
| bool shouldDump = false; |
| addJITCodeEntry(logger.m_map, region, entry, shouldDump, name); |
| } |
| |
| } // namespace JSC |
| |
| WTF_ALLOW_UNSAFE_BUFFER_USAGE_END |
| |
| #else |
| |
| namespace JSC { |
| |
| WTF_MAKE_TZONE_ALLOCATED_IMPL(GdbJIT); |
| |
| GdbJIT& GdbJIT::singleton() |
| { |
| static LazyNeverDestroyed<GdbJIT> logger; |
| static std::once_flag onceKey; |
| std::call_once(onceKey, [] { |
| logger.construct(); |
| }); |
| return logger.get(); |
| } |
| |
| void GdbJIT::log(const CString&, MacroAssemblerCodeRef<LinkBufferPtrTag>) { } |
| |
| } // namespace JSC |
| |
| #endif // OS(DARWIN) || OS(LINUX) |
| #endif // ENABLE(ASSEMBLER) |
