LLVM: llvm::sys::Memory Class Reference (original) (raw)

This class provides various memory handling functions that manipulate MemoryBlock instances. More...

#include "[llvm/Support/Memory.h](Memory%5F8h%5Fsource.html)"

Public Types
enum ProtectionFlags { MF_READ = 0x1000000 , MF_WRITE = 0x2000000 , MF_EXEC = 0x4000000 , MF_RWE_MASK = 0x7000000 , MF_HUGE_HINT = 0x0000001 }
Static Public Member Functions
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.g.
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 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 void InvalidateInstructionCache (const void *Addr, size_t Len)
InvalidateInstructionCache - Before the JIT can run a block of code that has been emitted it must invalidate the instruction cache on some platforms.

This class provides various memory handling functions that manipulate MemoryBlock instances.

Since

1.4 An abstraction for memory operations.

Definition at line 54 of file Memory.h.

◆ ProtectionFlags

Enumerator
MF_READ
MF_WRITE
MF_EXEC
MF_RWE_MASK
MF_HUGE_HINT The MF_HUGE_HINT flag is used to indicate that the request for a memory block should be satisfied with large pages if possible. This is only a hint and small pages will be used as fallback. The presence or absence of this flag in the returned memory block is (at least currently) not a reliable indicator that the memory block will use or will not use large pages. On some systems a request without this flag can be backed by large pages without this flag being set, and on some other systems a request with this flag can fallback to small pages without this flag being cleared.

Definition at line 56 of file Memory.h.

◆ allocateMappedMemory()

This method allocates a block of memory that is suitable for loading dynamically generated code (e.g.

JIT). An attempt to allocate NumBytes bytes of virtual memory is made. NearBlock may point to an existing allocation in which case an attempt is made to allocate more memory near the existing block. The actual allocated address is not guaranteed to be near the requested address. Flags is used to set the initial protection flags for the block of the memory. EC [out] returns an object describing any error that occurs.

This method may allocate more than the number of bytes requested. The actual number of bytes allocated is indicated in the returned MemoryBlock.

The start of the allocated block must be aligned with the system allocation granularity (64K on Windows, page size on Linux). If the address following NearBlock is not so aligned, it will be rounded up to the next allocation granularity boundary.

\r a non-null MemoryBlock if the function was successful, otherwise a null MemoryBlock is with EC describing the error.

Allocate mapped memory.

Referenced by llvm::jitlink::InProcessMemoryManager::allocate(), llvm::orc::LocalIndirectStubsInfo< ORCABI >::create(), createInMemoryBuffer(), llvm::orc::InProcessMemoryMapper::reserve(), and llvm::orc::rt_bootstrap::SimpleExecutorMemoryManager::reserve().

◆ InvalidateInstructionCache()

LLVM_ABI void llvm::sys::Memory::InvalidateInstructionCache ( const void * Addr, size_t Len ) static

◆ protectMappedMemory()

◆ releaseMappedMemory()

The documentation for this class was generated from the following file: