11#include "llvm/Config/llvm-config.h"
15#if defined(LLVM_ON_UNIX) && !defined(__ANDROID__)
33 : PageSize(PageSize) {}
39 return PageSize.takeError();
40 return std::make_unique<InProcessMemoryMapper>(*PageSize);
53 std::lock_guard<std::mutex> Lock(Mutex);
54 Reservations[MB.base()].Size = MB.allocatedSize();
63 return Addr.
toPtr<
char *>();
74 auto Size = Segment.ContentSize + Segment.ZeroFillSize;
82 std::memset((
Base + Segment.ContentSize).toPtr<
void *>(), 0,
83 Segment.ZeroFillSize);
95 if (!DeinitializeActions)
96 return OnInitialized(DeinitializeActions.takeError());
99 std::lock_guard<std::mutex> Lock(Mutex);
102 auto &
Alloc = Allocations[MinAddr];
103 Alloc.Size = MaxAddr - MinAddr;
104 Alloc.DeinitializationActions = std::move(*DeinitializeActions);
105 Reservations[AI.
MappingBase.
toPtr<
void *>()].Allocations.push_back(MinAddr);
108 OnInitialized(MinAddr);
117 std::lock_guard<std::mutex> Lock(Mutex);
122 Allocations[
Base].DeinitializationActions)) {
123 AllErr =
joinErrors(std::move(AllErr), std::move(Err));
134 Allocations.erase(
Base);
138 OnDeinitialized(std::move(AllErr));
145 for (
auto Base : Bases) {
146 std::vector<ExecutorAddr> AllocAddrs;
149 std::lock_guard<std::mutex> Lock(Mutex);
150 auto &R = Reservations[
Base.toPtr<
void *>()];
152 AllocAddrs.swap(R.Allocations);
156 std::promise<MSVCPError>
P;
157 auto F =
P.get_future();
171 std::lock_guard<std::mutex> Lock(Mutex);
172 Reservations.erase(
Base.toPtr<
void *>());
175 OnReleased(std::move(Err));
179 std::vector<ExecutorAddr> ReservationAddrs;
181 std::lock_guard<std::mutex> Lock(Mutex);
183 ReservationAddrs.reserve(Reservations.size());
184 for (
const auto &R : Reservations) {
189 std::promise<MSVCPError>
P;
190 auto F =
P.get_future();
191 release(ReservationAddrs, [&](
Error Err) {
P.set_value(std::move(Err)); });
199 : EPC(EPC), SAs(SAs), PageSize(PageSize) {
200#if (!defined(LLVM_ON_UNIX) || defined(__ANDROID__)) && !defined(_WIN32)
201 llvm_unreachable(
"SharedMemoryMapper is not supported on this platform yet");
207#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
210 return PageSize.takeError();
212 return std::make_unique<SharedMemoryMapper>(EPC, SAs, *PageSize);
215 "SharedMemoryMapper is not supported on this platform yet",
222#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
224 int SharedMemoryId = -1;
225 EPC.callSPSWrapperAsync<
228 [
this, NumBytes, OnReserved = std::move(OnReserved), SharedMemoryId](
229 Error SerializationErr,
231 if (SerializationErr) {
233 return OnReserved(std::move(SerializationErr));
237 return OnReserved(
Result.takeError());
240 std::string SharedMemoryName;
241 std::tie(RemoteAddr, SharedMemoryName) = std::move(*
Result);
243 void *LocalAddr =
nullptr;
245#if defined(LLVM_ON_UNIX)
249 reinterpret_cast<const uint8_t *
>(SharedMemoryName.c_str()),
250 SharedMemoryName.size());
252 key_t
Key = *
reinterpret_cast<key_t *
>(HashedName.data());
254 shmget(
Key, NumBytes, IPC_CREAT | __IPC_SHAREAS | 0700);
255 if (SharedMemoryId < 0) {
257 std::error_code(errno, std::generic_category())));
259 LocalAddr = shmat(SharedMemoryId,
nullptr, 0);
260 if (LocalAddr ==
reinterpret_cast<void *
>(-1)) {
262 std::error_code(errno, std::generic_category())));
265 int SharedMemoryFile = shm_open(SharedMemoryName.c_str(), O_RDWR, 0700);
266 if (SharedMemoryFile < 0) {
271 shm_unlink(SharedMemoryName.c_str());
273 LocalAddr = mmap(
nullptr, NumBytes, PROT_READ | PROT_WRITE, MAP_SHARED,
274 SharedMemoryFile, 0);
275 if (LocalAddr == MAP_FAILED) {
279 close(SharedMemoryFile);
284 std::wstring WideSharedMemoryName(SharedMemoryName.begin(),
285 SharedMemoryName.end());
286 HANDLE SharedMemoryFile = OpenFileMappingW(
287 FILE_MAP_ALL_ACCESS, FALSE, WideSharedMemoryName.c_str());
288 if (!SharedMemoryFile)
292 MapViewOfFile(SharedMemoryFile, FILE_MAP_ALL_ACCESS, 0, 0, 0);
294 CloseHandle(SharedMemoryFile);
298 CloseHandle(SharedMemoryFile);
302 std::lock_guard<std::mutex> Lock(Mutex);
304 {RemoteAddr, {LocalAddr, NumBytes, SharedMemoryId}});
309 SAs.Instance,
static_cast<uint64_t>(NumBytes));
313 "SharedMemoryMapper is not supported on this platform yet",
319 size_t ContentSize) {
320 auto R = Reservations.upper_bound(Addr);
321 assert(R != Reservations.begin() &&
"Attempt to prepare unreserved range");
326 return static_cast<char *
>(R->second.LocalAddr) +
Offset;
331 auto Reservation = Reservations.upper_bound(AI.
MappingBase);
332 assert(Reservation != Reservations.begin() &&
"Attempt to initialize unreserved range");
335 auto AllocationOffset = AI.
MappingBase - Reservation->first;
344 char *
Base =
static_cast<char *
>(Reservation->second.LocalAddr) +
345 AllocationOffset + Segment.Offset;
346 std::memset(
Base + Segment.ContentSize, 0, Segment.ZeroFillSize);
349 SegReq.
RAG = {Segment.AG.getMemProt(),
352 SegReq.
Size = Segment.ContentSize + Segment.ZeroFillSize;
357 EPC.callSPSWrapperAsync<
360 [OnInitialized = std::move(OnInitialized)](
362 if (SerializationErr) {
364 return OnInitialized(std::move(SerializationErr));
367 OnInitialized(std::move(
Result));
369 SAs.Instance, Reservation->first, std::move(FR));
375 EPC.callSPSWrapperAsync<
378 [OnDeinitialized = std::move(OnDeinitialized)](
Error SerializationErr,
380 if (SerializationErr) {
382 return OnDeinitialized(std::move(SerializationErr));
385 OnDeinitialized(std::move(
Result));
387 SAs.Instance, Allocations);
392#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)
396 std::lock_guard<std::mutex> Lock(Mutex);
398 for (
auto Base : Bases) {
400#if defined(LLVM_ON_UNIX)
403 if (shmdt(Reservations[
Base].LocalAddr) < 0 ||
404 shmctl(Reservations[
Base].SharedMemoryId, IPC_RMID, NULL) < 0)
407 if (munmap(Reservations[
Base].LocalAddr, Reservations[
Base].
Size) != 0)
413 if (!UnmapViewOfFile(Reservations[
Base].LocalAddr))
419 Reservations.erase(
Base);
423 EPC.callSPSWrapperAsync<
426 [OnReleased = std::move(OnReleased),
428 if (SerializationErr) {
431 joinErrors(std::move(Err), std::move(SerializationErr)));
436 SAs.Instance, Bases);
439 "SharedMemoryMapper is not supported on this platform yet",
445 std::lock_guard<std::mutex> Lock(Mutex);
446 for (
const auto &R : Reservations) {
448#if defined(LLVM_ON_UNIX) && !defined(__ANDROID__)
451 shmdt(R.second.LocalAddr);
453 munmap(R.second.LocalAddr, R.second.Size);
458 UnmapViewOfFile(R.second.LocalAddr);
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
static BLAKE3Result< NumBytes > hash(ArrayRef< uint8_t > Data)
Returns a BLAKE3 hash for the given data.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
Represents an address in the executor process.
static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())
Create an ExecutorAddr from the given pointer.
std::enable_if_t< std::is_pointer< T >::value, T > toPtr(WrapFn &&Wrap=WrapFn()) const
Cast this ExecutorAddr to a pointer of the given type.
ExecutorProcessControl supports interaction with a JIT target process.
void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override
Ensures executor memory is synchronized with working copy memory, sends functions to be called after ...
void reserve(size_t NumBytes, OnReservedFunction OnReserved) override
Reserves address space in executor process.
InProcessMemoryMapper(size_t PageSize)
~InProcessMemoryMapper() override
char * prepare(jitlink::LinkGraph &G, ExecutorAddr Addr, size_t ContentSize) override
Provides working memory The LinkGraph parameter is included to allow implementations to allocate work...
void deinitialize(ArrayRef< ExecutorAddr > Allocations, OnDeinitializedFunction OnDeInitialized) override
Runs previously specified deinitialization actions Executor addresses returned by initialize should b...
static Expected< std::unique_ptr< InProcessMemoryMapper > > Create()
void release(ArrayRef< ExecutorAddr > Reservations, OnReleasedFunction OnRelease) override
Release address space acquired through reserve()
unique_function< void(Error)> OnReleasedFunction
unique_function< void(Expected< ExecutorAddr >)> OnInitializedFunction
unique_function< void(Expected< ExecutorAddrRange >)> OnReservedFunction
unique_function< void(Error)> OnDeinitializedFunction
static Expected< std::unique_ptr< SharedMemoryMapper > > Create(ExecutorProcessControl &EPC, SymbolAddrs SAs)
char * prepare(jitlink::LinkGraph &G, ExecutorAddr Addr, size_t ContentSize) override
Provides working memory The LinkGraph parameter is included to allow implementations to allocate work...
void reserve(size_t NumBytes, OnReservedFunction OnReserved) override
Reserves address space in executor process.
void deinitialize(ArrayRef< ExecutorAddr > Allocations, OnDeinitializedFunction OnDeInitialized) override
Runs previously specified deinitialization actions Executor addresses returned by initialize should b...
~SharedMemoryMapper() override
void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override
Ensures executor memory is synchronized with working copy memory, sends functions to be called after ...
void release(ArrayRef< ExecutorAddr > Reservations, OnReleasedFunction OnRelease) override
Release address space acquired through reserve()
SharedMemoryMapper(ExecutorProcessControl &EPC, SymbolAddrs SAs, size_t PageSize)
This class encapsulates the notion of a memory block which has an address and a size.
static LLVM_ABI std::error_code protectMappedMemory(const MemoryBlock &Block, unsigned Flags)
This method sets the protection flags for a block of memory to the state specified by /p Flags.
static LLVM_ABI std::error_code releaseMappedMemory(MemoryBlock &Block)
This method releases a block of memory that was allocated with the allocateMappedMemory method.
static LLVM_ABI void InvalidateInstructionCache(const void *Addr, size_t Len)
InvalidateInstructionCache - Before the JIT can run a block of code that has been emitted it must inv...
static LLVM_ABI MemoryBlock allocateMappedMemory(size_t NumBytes, const MemoryBlock *const NearBlock, unsigned Flags, std::error_code &EC)
This method allocates a block of memory that is suitable for loading dynamically generated code (e....
static LLVM_ABI Expected< unsigned > getPageSize()
Get the process's page size.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
shared::SPSExpected< shared::SPSTuple< shared::SPSExecutorAddr, shared::SPSString > >( shared::SPSExecutorAddr, uint64_t) SPSExecutorSharedMemoryMapperServiceReserveSignature
shared::SPSExpected< shared::SPSExecutorAddr >( shared::SPSExecutorAddr, shared::SPSExecutorAddr, shared::SPSSharedMemoryFinalizeRequest) SPSExecutorSharedMemoryMapperServiceInitializeSignature
shared::SPSError(shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSExecutorSharedMemoryMapperServiceDeinitializeSignature
shared::SPSError( shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSExecutorSharedMemoryMapperServiceReleaseSignature
LLVM_ABI Error runDeallocActions(ArrayRef< WrapperFunctionCall > DAs)
Run deallocation actions.
LLVM_ABI Expected< std::vector< WrapperFunctionCall > > runFinalizeActions(AllocActions &AAs)
Run finalize actions.
uint64_t ExecutorAddrDiff
@ Finalize
Finalize memory should be allocated by the allocator, and then be overwritten and deallocated after a...
sys::Memory::ProtectionFlags toSysMemoryProtectionFlags(MemProt MP)
Convert a MemProt value to a corresponding sys::Memory::ProtectionFlags value.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
auto reverse(ContainerTy &&C)
Error joinErrors(Error E1, Error E2)
Concatenate errors.
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
FunctionAddr VTableAddr uintptr_t uintptr_t Data
LLVM_ABI Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
LLVM_ABI std::error_code mapWindowsError(unsigned EV)
std::error_code errnoAsErrorCode()
Helper to get errno as an std::error_code.
Represents an address range in the exceutor process.
Represents a single allocation containing multiple segments and initialization and deinitialization a...
std::vector< SegInfo > Segments
shared::AllocActions Actions
std::vector< SharedMemorySegFinalizeRequest > Segments
shared::AllocActions Actions