Movatterモバイル変換

Go to the documentation of this file.

1//===- MemoryMapper.cpp - Cross-process memory mapper ------------*- C++ -*-==//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

9#include "llvm/ExecutionEngine/Orc/MemoryMapper.h"

11#include "llvm/Config/llvm-config.h"// for LLVM_ON_UNIX

12#include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"

13#include "llvm/Support/WindowsError.h"

15#if defined(LLVM_ON_UNIX) && !defined(__ANDROID__)

16#include <fcntl.h>

17#include <sys/mman.h>

18#if defined(__MVS__)

19#include "llvm/Support/BLAKE3.h"

20#include <sys/shm.h>

21#endif

22#include <unistd.h>

23#elif defined(_WIN32)

24#include <windows.h>

25#endif

27namespacellvm {

28namespaceorc {

30MemoryMapper::~MemoryMapper() {}

32InProcessMemoryMapper::InProcessMemoryMapper(size_tPageSize)

33 :PageSize(PageSize) {}

35Expected<std::unique_ptr<InProcessMemoryMapper>>

36InProcessMemoryMapper::Create() {

37auto PageSize =sys::Process::getPageSize();

38if (!PageSize)

39return PageSize.takeError();

40return std::make_unique<InProcessMemoryMapper>(*PageSize);

41}

43voidInProcessMemoryMapper::reserve(size_t NumBytes,

44OnReservedFunction OnReserved) {

45 std::error_code EC;

46auto MB =sys::Memory::allocateMappedMemory(

47 NumBytes,nullptr,sys::Memory::MF_READ |sys::Memory::MF_WRITE, EC);

49if (EC)

50return OnReserved(errorCodeToError(EC));

52 {

53 std::lock_guard<std::mutex> Lock(Mutex);

54 Reservations[MB.base()].Size = MB.allocatedSize();

55 }

57 OnReserved(

58ExecutorAddrRange(ExecutorAddr::fromPtr(MB.base()), MB.allocatedSize()));

59}

61char *InProcessMemoryMapper::prepare(ExecutorAddr Addr,size_t ContentSize) {

62returnAddr.toPtr<char *>();

63}

65voidInProcessMemoryMapper::initialize(MemoryMapper::AllocInfo &AI,

66OnInitializedFunction OnInitialized) {

67ExecutorAddr MinAddr(~0ULL);

68ExecutorAddr MaxAddr(0);

70// FIXME: Release finalize lifetime segments.

71for (auto &Segment : AI.Segments) {

72autoBase = AI.MappingBase + Segment.Offset;

73autoSize = Segment.ContentSize + Segment.ZeroFillSize;

75if (Base < MinAddr)

76 MinAddr =Base;

78if (Base +Size > MaxAddr)

79 MaxAddr =Base +Size;

81 std::memset((Base + Segment.ContentSize).toPtr<void *>(), 0,

82 Segment.ZeroFillSize);

84if (auto EC =sys::Memory::protectMappedMemory(

85 {Base.toPtr<void *>(),Size},

86toSysMemoryProtectionFlags(Segment.AG.getMemProt()))) {

87return OnInitialized(errorCodeToError(EC));

88 }

89if ((Segment.AG.getMemProt() &MemProt::Exec) ==MemProt::Exec)

90sys::Memory::InvalidateInstructionCache(Base.toPtr<void *>(),Size);

91 }

93auto DeinitializeActions =shared::runFinalizeActions(AI.Actions);

94if (!DeinitializeActions)

95return OnInitialized(DeinitializeActions.takeError());

97 {

98 std::lock_guard<std::mutex> Lock(Mutex);

100// This is the maximum range whose permission have been possibly modified

101 Allocations[MinAddr].Size = MaxAddr - MinAddr;

102 Allocations[MinAddr].DeinitializationActions =

103 std::move(*DeinitializeActions);

104 Reservations[AI.MappingBase.toPtr<void *>()].Allocations.push_back(MinAddr);

105 }

106

107 OnInitialized(MinAddr);

108}

109

110voidInProcessMemoryMapper::deinitialize(

111ArrayRef<ExecutorAddr> Bases,

112MemoryMapper::OnDeinitializedFunction OnDeinitialized) {

113Error AllErr =Error::success();

114

115 {

116 std::lock_guard<std::mutex> Lock(Mutex);

117

118for (autoBase :llvm::reverse(Bases)) {

119

120if (Error Err =shared::runDeallocActions(

121 Allocations[Base].DeinitializationActions)) {

122 AllErr =joinErrors(std::move(AllErr), std::move(Err));

123 }

124

125// Reset protections to read/write so the area can be reused

126if (auto EC =sys::Memory::protectMappedMemory(

127 {Base.toPtr<void *>(), Allocations[Base].Size},

128sys::Memory::ProtectionFlags::MF_READ |

129sys::Memory::ProtectionFlags::MF_WRITE)) {

130 AllErr =joinErrors(std::move(AllErr),errorCodeToError(EC));

131 }

132

133 Allocations.erase(Base);

134 }

135 }

136

137 OnDeinitialized(std::move(AllErr));

138}

139

140voidInProcessMemoryMapper::release(ArrayRef<ExecutorAddr> Bases,

141OnReleasedFunction OnReleased) {

142Error Err =Error::success();

143

144for (autoBase : Bases) {

145 std::vector<ExecutorAddr> AllocAddrs;

146size_tSize;

147 {

148 std::lock_guard<std::mutex> Lock(Mutex);

149auto &R = Reservations[Base.toPtr<void *>()];

150Size = R.Size;

151 AllocAddrs.swap(R.Allocations);

152 }

153

154// deinitialize sub allocations

155 std::promise<MSVCPError>P;

156autoF =P.get_future();

157deinitialize(AllocAddrs, [&](Error Err) {P.set_value(std::move(Err)); });

158if (Error E =F.get()) {

159 Err =joinErrors(std::move(Err), std::move(E));

160 }

161

162// free the memory

163auto MB =sys::MemoryBlock(Base.toPtr<void *>(),Size);

164

165auto EC =sys::Memory::releaseMappedMemory(MB);

166if (EC) {

167 Err =joinErrors(std::move(Err),errorCodeToError(EC));

168 }

169

170 std::lock_guard<std::mutex> Lock(Mutex);

171 Reservations.erase(Base.toPtr<void *>());

172 }

173

174 OnReleased(std::move(Err));

175}

176

177InProcessMemoryMapper::~InProcessMemoryMapper() {

178 std::vector<ExecutorAddr> ReservationAddrs;

179 {

180 std::lock_guard<std::mutex> Lock(Mutex);

181

182 ReservationAddrs.reserve(Reservations.size());

183for (constauto &R : Reservations) {

184 ReservationAddrs.push_back(ExecutorAddr::fromPtr(R.getFirst()));

185 }

186 }

187

188 std::promise<MSVCPError>P;

189autoF =P.get_future();

190release(ReservationAddrs, [&](Error Err) {P.set_value(std::move(Err)); });

191cantFail(F.get());

192}

193

194// SharedMemoryMapper

195

196SharedMemoryMapper::SharedMemoryMapper(ExecutorProcessControl &EPC,

197SymbolAddrs SAs,size_tPageSize)

198 : EPC(EPC), SAs(SAs),PageSize(PageSize) {

199#if (!defined(LLVM_ON_UNIX) || defined(__ANDROID__)) && !defined(_WIN32)

200llvm_unreachable("SharedMemoryMapper is not supported on this platform yet");

201#endif

202}

203

204Expected<std::unique_ptr<SharedMemoryMapper>>

205SharedMemoryMapper::Create(ExecutorProcessControl &EPC,SymbolAddrs SAs) {

206#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)

207auto PageSize =sys::Process::getPageSize();

208if (!PageSize)

209return PageSize.takeError();

210

211return std::make_unique<SharedMemoryMapper>(EPC, SAs, *PageSize);

212#else

213return make_error<StringError>(

214"SharedMemoryMapper is not supported on this platform yet",

215inconvertibleErrorCode());

216#endif

217}

218

219voidSharedMemoryMapper::reserve(size_t NumBytes,

220OnReservedFunction OnReserved) {

221#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)

222

223 EPC.callSPSWrapperAsync<

224rt::SPSExecutorSharedMemoryMapperServiceReserveSignature>(

225 SAs.Reserve,

226 [this, NumBytes, OnReserved = std::move(OnReserved)](

227Error SerializationErr,

228Expected<std::pair<ExecutorAddr, std::string>>Result)mutable {

229if (SerializationErr) {

230cantFail(Result.takeError());

231return OnReserved(std::move(SerializationErr));

232 }

233

234if (!Result)

235return OnReserved(Result.takeError());

236

237ExecutorAddr RemoteAddr;

238 std::string SharedMemoryName;

239 std::tie(RemoteAddr, SharedMemoryName) = std::move(*Result);

240

241void *LocalAddr =nullptr;

242

243#if defined(LLVM_ON_UNIX)

244

245#if defined(__MVS__)

246ArrayRef<uint8_t>Data(

247reinterpret_cast<constuint8_t *>(SharedMemoryName.c_str()),

248 SharedMemoryName.size());

249auto HashedName = BLAKE3::hash<sizeof(key_t)>(Data);

250 key_t Key = *reinterpret_cast<key_t *>(HashedName.data());

251int SharedMemoryId =

252 shmget(Key, NumBytes, IPC_CREAT | __IPC_SHAREAS | 0700);

253if (SharedMemoryId < 0) {

254return OnReserved(errorCodeToError(

255 std::error_code(errno, std::generic_category())));

256 }

257 LocalAddr = shmat(SharedMemoryId,nullptr, 0);

258if (LocalAddr ==reinterpret_cast<void *>(-1)) {

259return OnReserved(errorCodeToError(

260 std::error_code(errno, std::generic_category())));

261 }

262#else

263int SharedMemoryFile = shm_open(SharedMemoryName.c_str(), O_RDWR, 0700);

264if (SharedMemoryFile < 0) {

265return OnReserved(errorCodeToError(errnoAsErrorCode()));

266 }

267

268// this prevents other processes from accessing it by name

269 shm_unlink(SharedMemoryName.c_str());

270

271 LocalAddr = mmap(nullptr, NumBytes, PROT_READ | PROT_WRITE, MAP_SHARED,

272 SharedMemoryFile, 0);

273if (LocalAddr == MAP_FAILED) {

274return OnReserved(errorCodeToError(errnoAsErrorCode()));

275 }

276

277 close(SharedMemoryFile);

278#endif

279

280#elif defined(_WIN32)

281

282 std::wstring WideSharedMemoryName(SharedMemoryName.begin(),

283 SharedMemoryName.end());

284 HANDLE SharedMemoryFile = OpenFileMappingW(

285 FILE_MAP_ALL_ACCESS, FALSE, WideSharedMemoryName.c_str());

286if (!SharedMemoryFile)

287return OnReserved(errorCodeToError(mapWindowsError(GetLastError())));

288

289 LocalAddr =

290 MapViewOfFile(SharedMemoryFile, FILE_MAP_ALL_ACCESS, 0, 0, 0);

291if (!LocalAddr) {

292 CloseHandle(SharedMemoryFile);

293return OnReserved(errorCodeToError(mapWindowsError(GetLastError())));

294 }

295

296 CloseHandle(SharedMemoryFile);

297

298#endif

299 {

300 std::lock_guard<std::mutex> Lock(Mutex);

301 Reservations.insert({RemoteAddr, {LocalAddr, NumBytes}});

302 }

303

304 OnReserved(ExecutorAddrRange(RemoteAddr, NumBytes));

305 },

306 SAs.Instance,static_cast<uint64_t>(NumBytes));

307

308#else

309 OnReserved(make_error<StringError>(

310"SharedMemoryMapper is not supported on this platform yet",

311inconvertibleErrorCode()));

312#endif

313}

314

315char *SharedMemoryMapper::prepare(ExecutorAddr Addr,size_t ContentSize) {

316auto R = Reservations.upper_bound(Addr);

317assert(R != Reservations.begin() &&"Attempt to prepare unreserved range");

318 R--;

319

320ExecutorAddrDiff Offset =Addr - R->first;

321

322returnstatic_cast<char *>(R->second.LocalAddr) +Offset;

323}

324

325voidSharedMemoryMapper::initialize(MemoryMapper::AllocInfo &AI,

326OnInitializedFunction OnInitialized) {

327auto Reservation = Reservations.upper_bound(AI.MappingBase);

328assert(Reservation != Reservations.begin() &&"Attempt to initialize unreserved range");

329 Reservation--;

330

331auto AllocationOffset = AI.MappingBase - Reservation->first;

332

333tpctypes::SharedMemoryFinalizeRequest FR;

334

335 AI.Actions.swap(FR.Actions);

336

337 FR.Segments.reserve(AI.Segments.size());

338

339for (auto Segment : AI.Segments) {

340char *Base =static_cast<char *>(Reservation->second.LocalAddr) +

341 AllocationOffset + Segment.Offset;

342 std::memset(Base + Segment.ContentSize, 0, Segment.ZeroFillSize);

343

344tpctypes::SharedMemorySegFinalizeRequest SegReq;

345 SegReq.RAG = {Segment.AG.getMemProt(),

346 Segment.AG.getMemLifetime() ==MemLifetime::Finalize};

347 SegReq.Addr = AI.MappingBase + Segment.Offset;

348 SegReq.Size = Segment.ContentSize + Segment.ZeroFillSize;

349

350 FR.Segments.push_back(SegReq);

351 }

352

353 EPC.callSPSWrapperAsync<

354rt::SPSExecutorSharedMemoryMapperServiceInitializeSignature>(

355 SAs.Initialize,

356 [OnInitialized = std::move(OnInitialized)](

357Error SerializationErr,Expected<ExecutorAddr>Result)mutable {

358if (SerializationErr) {

359cantFail(Result.takeError());

360return OnInitialized(std::move(SerializationErr));

361 }

362

363 OnInitialized(std::move(Result));

364 },

365 SAs.Instance, Reservation->first, std::move(FR));

366}

367

368voidSharedMemoryMapper::deinitialize(

369ArrayRef<ExecutorAddr> Allocations,

370MemoryMapper::OnDeinitializedFunction OnDeinitialized) {

371 EPC.callSPSWrapperAsync<

372rt::SPSExecutorSharedMemoryMapperServiceDeinitializeSignature>(

373 SAs.Deinitialize,

374 [OnDeinitialized = std::move(OnDeinitialized)](Error SerializationErr,

375Error Result)mutable {

376if (SerializationErr) {

377cantFail(std::move(Result));

378return OnDeinitialized(std::move(SerializationErr));

379 }

380

381 OnDeinitialized(std::move(Result));

382 },

383 SAs.Instance, Allocations);

384}

385

386voidSharedMemoryMapper::release(ArrayRef<ExecutorAddr> Bases,

387OnReleasedFunction OnReleased) {

388#if (defined(LLVM_ON_UNIX) && !defined(__ANDROID__)) || defined(_WIN32)

389Error Err =Error::success();

390

391 {

392 std::lock_guard<std::mutex> Lock(Mutex);

393

394for (autoBase : Bases) {

395

396#if defined(LLVM_ON_UNIX)

397

398#if defined(__MVS__)

399if (shmdt(Reservations[Base].LocalAddr) < 0)

400 Err =joinErrors(std::move(Err),errorCodeToError(errnoAsErrorCode()));

401#else

402if (munmap(Reservations[Base].LocalAddr, Reservations[Base].Size) != 0)

403 Err =joinErrors(std::move(Err),errorCodeToError(errnoAsErrorCode()));

404#endif

405

406#elif defined(_WIN32)

407

408if (!UnmapViewOfFile(Reservations[Base].LocalAddr))

409 Err =joinErrors(std::move(Err),

410errorCodeToError(mapWindowsError(GetLastError())));

411

412#endif

413

414 Reservations.erase(Base);

415 }

416 }

417

418 EPC.callSPSWrapperAsync<

419rt::SPSExecutorSharedMemoryMapperServiceReleaseSignature>(

420 SAs.Release,

421 [OnReleased = std::move(OnReleased),

422 Err = std::move(Err)](Error SerializationErr,Error Result)mutable {

423if (SerializationErr) {

424cantFail(std::move(Result));

425return OnReleased(

426joinErrors(std::move(Err), std::move(SerializationErr)));

427 }

428

429return OnReleased(joinErrors(std::move(Err), std::move(Result)));

430 },

431 SAs.Instance, Bases);

432#else

433 OnReleased(make_error<StringError>(

434"SharedMemoryMapper is not supported on this platform yet",

435inconvertibleErrorCode()));

436#endif

437}

438

439SharedMemoryMapper::~SharedMemoryMapper() {

440 std::lock_guard<std::mutex> Lock(Mutex);

441for (constauto &R : Reservations) {

442

443#if defined(LLVM_ON_UNIX) && !defined(__ANDROID__)

444

445#if defined(__MVS__)

446 shmdt(R.second.LocalAddr);

447#else

448 munmap(R.second.LocalAddr, R.second.Size);

449#endif

450

451#elif defined(_WIN32)

452

453 UnmapViewOfFile(R.second.LocalAddr);

454

455#else

456

457 (void)R;

458

459#endif

460 }

461}

462

463}// namespace orc

464

465}// namespace llvm

BLAKE3.h

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

Addr

uint64_t Addr

Definition:ELFObjHandler.cpp:79

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

PageSize

static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)

#define F(x, y, z)

Definition:MD5.cpp:55

MemoryMapper.h

#define P(N)

OrcRTBridge.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

WindowsError.h

llvm::ArrayRef

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Definition:ArrayRef.h:41

llvm::DenseMapBase::erase

bool erase(const KeyT &Val)

Definition:DenseMap.h:321

llvm::DenseMapBase::size

unsigned size() const

Definition:DenseMap.h:99

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::orc::ExecutorAddr

Represents an address in the executor process.

Definition:ExecutorAddress.h:34

llvm::orc::ExecutorAddr::fromPtr

static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())

Create an ExecutorAddr from the given pointer.

Definition:ExecutorAddress.h:111

llvm::orc::ExecutorAddr::toPtr

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.

Definition:ExecutorAddress.h:120

llvm::orc::ExecutorProcessControl

ExecutorProcessControl supports interaction with a JIT target process.

Definition:ExecutorProcessControl.h:38

llvm::orc::ExecutorProcessControl::callSPSWrapperAsync

void callSPSWrapperAsync(RunPolicyT &&Runner, ExecutorAddr WrapperFnAddr, SendResultT &&SendResult, const ArgTs &...Args)

Run a wrapper function using SPS to serialize the arguments and deserialize the results.

Definition:ExecutorProcessControl.h:343

llvm::orc::InProcessMemoryMapper::initialize

void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override

Ensures executor memory is synchronized with working copy memory, sends functions to be called after ...

Definition:MemoryMapper.cpp:65

llvm::orc::InProcessMemoryMapper::reserve

void reserve(size_t NumBytes, OnReservedFunction OnReserved) override

Reserves address space in executor process.

Definition:MemoryMapper.cpp:43

llvm::orc::InProcessMemoryMapper::InProcessMemoryMapper

InProcessMemoryMapper(size_t PageSize)

Definition:MemoryMapper.cpp:32

llvm::orc::InProcessMemoryMapper::~InProcessMemoryMapper

~InProcessMemoryMapper() override

Definition:MemoryMapper.cpp:177

llvm::orc::InProcessMemoryMapper::deinitialize

void deinitialize(ArrayRef< ExecutorAddr > Allocations, OnDeinitializedFunction OnDeInitialized) override

Runs previously specified deinitialization actions Executor addresses returned by initialize should b...

Definition:MemoryMapper.cpp:110

llvm::orc::InProcessMemoryMapper::Create

static Expected< std::unique_ptr< InProcessMemoryMapper > > Create()

Definition:MemoryMapper.cpp:36

llvm::orc::InProcessMemoryMapper::prepare

char * prepare(ExecutorAddr Addr, size_t ContentSize) override

Provides working memory.

Definition:MemoryMapper.cpp:61

llvm::orc::InProcessMemoryMapper::release

void release(ArrayRef< ExecutorAddr > Reservations, OnReleasedFunction OnRelease) override

Release address space acquired through reserve()

Definition:MemoryMapper.cpp:140

llvm::orc::MemoryMapper::~MemoryMapper

virtual ~MemoryMapper()

Definition:MemoryMapper.cpp:30

llvm::orc::SharedMemoryMapper::Create

static Expected< std::unique_ptr< SharedMemoryMapper > > Create(ExecutorProcessControl &EPC, SymbolAddrs SAs)

Definition:MemoryMapper.cpp:205

llvm::orc::SharedMemoryMapper::reserve

void reserve(size_t NumBytes, OnReservedFunction OnReserved) override

Reserves address space in executor process.

Definition:MemoryMapper.cpp:219

llvm::orc::SharedMemoryMapper::deinitialize

void deinitialize(ArrayRef< ExecutorAddr > Allocations, OnDeinitializedFunction OnDeInitialized) override

Runs previously specified deinitialization actions Executor addresses returned by initialize should b...

Definition:MemoryMapper.cpp:368

llvm::orc::SharedMemoryMapper::~SharedMemoryMapper

~SharedMemoryMapper() override

Definition:MemoryMapper.cpp:439

llvm::orc::SharedMemoryMapper::initialize

void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override

Ensures executor memory is synchronized with working copy memory, sends functions to be called after ...

Definition:MemoryMapper.cpp:325

llvm::orc::SharedMemoryMapper::prepare

char * prepare(ExecutorAddr Addr, size_t ContentSize) override

Provides working memory.

Definition:MemoryMapper.cpp:315

llvm::orc::SharedMemoryMapper::release

void release(ArrayRef< ExecutorAddr > Reservations, OnReleasedFunction OnRelease) override

Release address space acquired through reserve()

Definition:MemoryMapper.cpp:386

llvm::orc::SharedMemoryMapper::SharedMemoryMapper

SharedMemoryMapper(ExecutorProcessControl &EPC, SymbolAddrs SAs, size_t PageSize)

Definition:MemoryMapper.cpp:196

llvm::sys::MemoryBlock

This class encapsulates the notion of a memory block which has an address and a size.

Definition:Memory.h:32

llvm::sys::Memory::releaseMappedMemory

static std::error_code releaseMappedMemory(MemoryBlock &Block)

This method releases a block of memory that was allocated with the allocateMappedMemory method.

llvm::sys::Memory::allocateMappedMemory

static 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....

llvm::sys::Memory::MF_READ

@ MF_READ

Definition:Memory.h:56

llvm::sys::Memory::MF_WRITE

@ MF_WRITE

Definition:Memory.h:57

llvm::sys::Memory::InvalidateInstructionCache

static 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...

llvm::sys::Memory::protectMappedMemory

static 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.

llvm::sys::Process::getPageSize

static Expected< unsigned > getPageSize()

Get the process's page size.

llvm::sys::SmartMutex< false >

llvm::unique_function

unique_function is a type-erasing functor similar to std::function.

Definition:FunctionExtras.h:57

uint64_t

uint8_t

llvm_unreachable

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

llvm::orc::rt::SPSExecutorSharedMemoryMapperServiceInitializeSignature

shared::SPSExpected< shared::SPSExecutorAddr >(shared::SPSExecutorAddr, shared::SPSExecutorAddr, shared::SPSSharedMemoryFinalizeRequest) SPSExecutorSharedMemoryMapperServiceInitializeSignature

Definition:OrcRTBridge.h:79

llvm::orc::rt::SPSExecutorSharedMemoryMapperServiceReleaseSignature

shared::SPSError(shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSExecutorSharedMemoryMapperServiceReleaseSignature

Definition:OrcRTBridge.h:84

llvm::orc::rt::SPSExecutorSharedMemoryMapperServiceReserveSignature

shared::SPSExpected< shared::SPSTuple< shared::SPSExecutorAddr, shared::SPSString > >(shared::SPSExecutorAddr, uint64_t) SPSExecutorSharedMemoryMapperServiceReserveSignature

Definition:OrcRTBridge.h:75

llvm::orc::rt::SPSExecutorSharedMemoryMapperServiceDeinitializeSignature

shared::SPSError(shared::SPSExecutorAddr, shared::SPSSequence< shared::SPSExecutorAddr >) SPSExecutorSharedMemoryMapperServiceDeinitializeSignature

Definition:OrcRTBridge.h:82

llvm::orc::shared::runDeallocActions

Error runDeallocActions(ArrayRef< WrapperFunctionCall > DAs)

Run deallocation actions.

Definition:AllocationActions.cpp:33

llvm::orc::shared::runFinalizeActions

Expected< std::vector< WrapperFunctionCall > > runFinalizeActions(AllocActions &AAs)

Run finalize actions.

Definition:AllocationActions.cpp:16