4f0325873f
For Darwin/arm64 (including Apple Silicon Macs) this will enable exception
handling and stack unwinding in JIT'd code.
Darwin supports two unwind-info formats: DWARF eh-frames and compact-unwind. On
Darwin/x86-64 compilers usually produce both by default, and ORC supported
exceptions and unwinding via eh-frames (same as on Linux), discarding the
redundant compact-unwind info. On Darwin/arm64 compilers typically default to
producing compact-unwind only, with DWARF eh-frames as a fallback for functions
that can't be described in compact-unwind. Since ORC did not previously support
the compact-unwind format and eh-frames were not present ORC was unable to
handle exceptions or unwinding by default in Darwin/arm64 JIT'd code.
This patch enables support for the compact-unwind-info format, and contains
three major moving parts:
(1) The JITLink CompactUnwindManager class is responsible for transforming the
__compact_unwind records produced by the linker into the __unwind_info
tables that libunwind parses during unwinding. To enable this the
CompactUnwindManager class provides three JITLink passes: The
prepareForPrune pass that splits the __compact_unwind section into
single-record blocks, allowing unused records to be dead-stripped; the
processAndReserveUnwindInfo pass that reserves space for the final
__unwind_info section, and the writeUnwindInfo pass that writes the
__unwind_info section.
(2) The OrcTargetProcess UnwindInfoManager class maintains a table of
registered JIT'd __unwind_info and __eh_frame sections, and handles
requests from libunwind for unwind info sections (by registering a callback
with libunwind's __unw_add_find_dynamic_unwind_sections function).
(3) The Orc UnwindInfoRegistrationPlugin, which scans LinkGraphs for
__unwind_info and __eh_frame sections to register with the
UnwindInfoManager.
This commit adds the CompactUnwindManager passes to the default JITLink
pipelines for Darwin/arm64 and Darwin/x86-64, and UnwindInfoManager intances to
the SelfExecutorProcessControl class (when built for apple platforms) and the
llvm-jitlink-executor tool.
The LLJIT class will now create an UnwindInfoRegistrationPlugin when targeting
a process running on Darwin if it detects that an UnwindInfoManager is
available to handle the registrations.
The ORC runtime macho_platform class already supported libunwind callbacks, so
out-of-process execution and unwinding support will work when loading the ORC
runtime.
The llvm-jitlink tool will only support compact-unwind when the orc-runtime is
loaded, as the UnwindInfoRegistrationPlugin requires access to an IR compiler
to load a helper module and llvm-jitlink does not provide an IR compiler.
104 lines
3.5 KiB
C++
104 lines
3.5 KiB
C++
//=------- CompactUnwindSupport.cpp - Compact Unwind format support -------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Compact Unwind support.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CompactUnwindSupport.h"
|
|
|
|
#include "llvm/ADT/Sequence.h"
|
|
|
|
#define DEBUG_TYPE "jitlink"
|
|
|
|
namespace llvm {
|
|
namespace jitlink {
|
|
|
|
Error splitCompactUnwindBlocks(LinkGraph &G, Section &CompactUnwindSection,
|
|
size_t RecordSize) {
|
|
|
|
std::vector<Block *> OriginalBlocks(CompactUnwindSection.blocks().begin(),
|
|
CompactUnwindSection.blocks().end());
|
|
LLVM_DEBUG({
|
|
dbgs() << "In " << G.getName() << " splitting compact unwind section "
|
|
<< CompactUnwindSection.getName() << " containing "
|
|
<< OriginalBlocks.size() << " initial blocks...\n";
|
|
});
|
|
|
|
while (!OriginalBlocks.empty()) {
|
|
auto *B = OriginalBlocks.back();
|
|
OriginalBlocks.pop_back();
|
|
|
|
if (B->getSize() == 0) {
|
|
LLVM_DEBUG({
|
|
dbgs() << " Skipping empty block at "
|
|
<< formatv("{0:x16}", B->getAddress()) << "\n";
|
|
});
|
|
continue;
|
|
}
|
|
|
|
unsigned NumBlocks = B->getSize() / RecordSize;
|
|
|
|
LLVM_DEBUG({
|
|
dbgs() << " Splitting block at " << formatv("{0:x16}", B->getAddress())
|
|
<< " into " << NumBlocks << " compact unwind record(s)\n";
|
|
});
|
|
|
|
if (B->getSize() % RecordSize)
|
|
return make_error<JITLinkError>(
|
|
"Error splitting compact unwind record in " + G.getName() +
|
|
": block at " + formatv("{0:x}", B->getAddress()) + " has size " +
|
|
formatv("{0:x}", B->getSize()) +
|
|
" (not a multiple of CU record size of " +
|
|
formatv("{0:x}", RecordSize) + ")");
|
|
|
|
auto Blocks =
|
|
G.splitBlock(*B, map_range(seq(1U, NumBlocks), [=](Edge::OffsetT Idx) {
|
|
return Idx * RecordSize;
|
|
}));
|
|
|
|
for (auto *CURec : Blocks) {
|
|
bool AddedKeepAlive = false;
|
|
|
|
for (auto &E : CURec->edges()) {
|
|
if (E.getOffset() == 0) {
|
|
LLVM_DEBUG({
|
|
dbgs() << " Updating compact unwind record at "
|
|
<< CURec->getAddress() << " to point to "
|
|
<< (E.getTarget().hasName() ? *E.getTarget().getName()
|
|
: StringRef())
|
|
<< " (at " << E.getTarget().getAddress() << ")\n";
|
|
});
|
|
|
|
if (E.getTarget().isExternal())
|
|
return make_error<JITLinkError>(
|
|
"Error adding keep-alive edge for compact unwind record at " +
|
|
formatv("{0:x}", CURec->getAddress()) + ": target " +
|
|
*E.getTarget().getName() + " is an external symbol");
|
|
auto &TgtBlock = E.getTarget().getBlock();
|
|
auto &CURecSym =
|
|
G.addAnonymousSymbol(*CURec, 0, RecordSize, false, false);
|
|
TgtBlock.addEdge(Edge::KeepAlive, 0, CURecSym, 0);
|
|
AddedKeepAlive = true;
|
|
}
|
|
}
|
|
|
|
if (!AddedKeepAlive)
|
|
return make_error<JITLinkError>(
|
|
"Error adding keep-alive edge for compact unwind record at " +
|
|
formatv("{0:x}", CURec->getAddress()) +
|
|
": no outgoing target edge at offset 0");
|
|
}
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
} // end namespace jitlink
|
|
} // end namespace llvm
|