mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 20:23:11 +01:00
900dc7edc7
Initializers and deinitializers are used to implement C++ static constructors
and destructors, runtime registration for some languages (e.g. with the
Objective-C runtime for Objective-C/C++ code) and other tasks that would
typically be performed when a shared-object/dylib is loaded or unloaded by a
statically compiled program.
MCJIT and ORC have historically provided limited support for discovering and
running initializers/deinitializers by scanning the llvm.global_ctors and
llvm.global_dtors variables and recording the functions to be run. This approach
suffers from several drawbacks: (1) It only works for IR inputs, not for object
files (including cached JIT'd objects). (2) It only works for initializers
described by llvm.global_ctors and llvm.global_dtors, however not all
initializers are described in this way (Objective-C, for example, describes
initializers via specially named metadata sections). (3) To make the
initializer/deinitializer functions described by llvm.global_ctors and
llvm.global_dtors searchable they must be promoted to extern linkage, polluting
the JIT symbol table (extra care must be taken to ensure this promotion does
not result in symbol name clashes).
This patch introduces several interdependent changes to ORCv2 to support the
construction of new initialization schemes, and includes an implementation of a
backwards-compatible llvm.global_ctor/llvm.global_dtor scanning scheme, and a
MachO specific scheme that handles Objective-C runtime registration (if the
Objective-C runtime is available) enabling execution of LLVM IR compiled from
Objective-C and Swift.
The major changes included in this patch are:
(1) The MaterializationUnit and MaterializationResponsibility classes are
extended to describe an optional "initializer" symbol for the module (see the
getInitializerSymbol method on each class). The presence or absence of this
symbol indicates whether the module contains any initializers or
deinitializers. The initializer symbol otherwise behaves like any other:
searching for it triggers materialization.
(2) A new Platform interface is introduced in llvm/ExecutionEngine/Orc/Core.h
which provides the following callback interface:
- Error setupJITDylib(JITDylib &JD): Can be used to install standard symbols
in JITDylibs upon creation. E.g. __dso_handle.
- Error notifyAdding(JITDylib &JD, const MaterializationUnit &MU): Generally
used to record initializer symbols.
- Error notifyRemoving(JITDylib &JD, VModuleKey K): Used to notify a platform
that a module is being removed.
Platform implementations can use these callbacks to track outstanding
initializers and implement a platform-specific approach for executing them. For
example, the MachOPlatform installs a plugin in the JIT linker to scan for both
__mod_inits sections (for C++ static constructors) and ObjC metadata sections.
If discovered, these are processed in the usual platform order: Objective-C
registration is carried out first, then static initializers are executed,
ensuring that calls to Objective-C from static initializers will be safe.
This patch updates LLJIT to use the new scheme for initialization. Two
LLJIT::PlatformSupport classes are implemented: A GenericIR platform and a MachO
platform. The GenericIR platform implements a modified version of the previous
llvm.global-ctor scraping scheme to provide support for Windows and
Linux. LLJIT's MachO platform uses the MachOPlatform class to provide MachO
specific initialization as described above.
Reviewers: sgraenitz, dblaikie
Subscribers: mgorny, hiraditya, mgrang, ributzka, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D74300
95 lines
2.8 KiB
C++
95 lines
2.8 KiB
C++
//===------ CompileUtils.cpp - Utilities for compiling IR in the JIT ------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/ExecutionEngine/ObjectCache.h"
|
|
#include "llvm/IR/LegacyPassManager.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/SmallVectorMemoryBuffer.h"
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include <algorithm>
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
IRSymbolMapper::ManglingOptions
|
|
irManglingOptionsFromTargetOptions(const TargetOptions &Opts) {
|
|
IRSymbolMapper::ManglingOptions MO;
|
|
|
|
MO.EmulatedTLS = Opts.EmulatedTLS;
|
|
|
|
return MO;
|
|
}
|
|
|
|
/// Compile a Module to an ObjectFile.
|
|
Expected<SimpleCompiler::CompileResult> SimpleCompiler::operator()(Module &M) {
|
|
CompileResult CachedObject = tryToLoadFromObjectCache(M);
|
|
if (CachedObject)
|
|
return std::move(CachedObject);
|
|
|
|
SmallVector<char, 0> ObjBufferSV;
|
|
|
|
{
|
|
raw_svector_ostream ObjStream(ObjBufferSV);
|
|
|
|
legacy::PassManager PM;
|
|
MCContext *Ctx;
|
|
if (TM.addPassesToEmitMC(PM, Ctx, ObjStream))
|
|
return make_error<StringError>("Target does not support MC emission",
|
|
inconvertibleErrorCode());
|
|
PM.run(M);
|
|
}
|
|
|
|
auto ObjBuffer = std::make_unique<SmallVectorMemoryBuffer>(
|
|
std::move(ObjBufferSV), M.getModuleIdentifier() + "-jitted-objectbuffer");
|
|
|
|
auto Obj = object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
|
|
|
|
if (!Obj)
|
|
return Obj.takeError();
|
|
|
|
notifyObjectCompiled(M, *ObjBuffer);
|
|
return std::move(ObjBuffer);
|
|
}
|
|
|
|
SimpleCompiler::CompileResult
|
|
SimpleCompiler::tryToLoadFromObjectCache(const Module &M) {
|
|
if (!ObjCache)
|
|
return CompileResult();
|
|
|
|
return ObjCache->getObject(&M);
|
|
}
|
|
|
|
void SimpleCompiler::notifyObjectCompiled(const Module &M,
|
|
const MemoryBuffer &ObjBuffer) {
|
|
if (ObjCache)
|
|
ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
|
|
}
|
|
|
|
ConcurrentIRCompiler::ConcurrentIRCompiler(JITTargetMachineBuilder JTMB,
|
|
ObjectCache *ObjCache)
|
|
: IRCompiler(irManglingOptionsFromTargetOptions(JTMB.getOptions())),
|
|
JTMB(std::move(JTMB)), ObjCache(ObjCache) {}
|
|
|
|
Expected<std::unique_ptr<MemoryBuffer>>
|
|
ConcurrentIRCompiler::operator()(Module &M) {
|
|
auto TM = cantFail(JTMB.createTargetMachine());
|
|
SimpleCompiler C(*TM, ObjCache);
|
|
return C(M);
|
|
}
|
|
|
|
} // end namespace orc
|
|
} // end namespace llvm
|