An abstraction for memory operations. More...

#include <Memory.h>

Public Types
enum	ProtectionFlags { MF_READ = 0x1000000, MF_WRITE = 0x2000000, MF_EXEC = 0x4000000 }

Static Public Member Functions
static MemoryBlock	allocateMappedMemory (size_t NumBytes, const MemoryBlock *const NearBlock, unsigned Flags, error_code &EC)
	Allocate mapped memory. More...

static error_code	releaseMappedMemory (MemoryBlock &Block)
	Release mapped memory. More...

static error_code	protectMappedMemory (const MemoryBlock &Block, unsigned Flags)
	Set memory protection state. More...

static MemoryBlock	AllocateRWX (size_t NumBytes, const MemoryBlock NearBlock, std::string ErrMsg=0)
	Allocate Read/Write/Execute memory. More...

static bool	ReleaseRWX (MemoryBlock &block, std::string *ErrMsg=0)
	Release Read/Write/Execute memory. More...

static void	InvalidateInstructionCache (const void *Addr, size_t Len)

static bool	setExecutable (MemoryBlock &M, std::string *ErrMsg=0)

static bool	setWritable (MemoryBlock &M, std::string *ErrMsg=0)

static bool	setRangeExecutable (const void *Addr, size_t Size)

static bool	setRangeWritable (const void *Addr, size_t Size)

Detailed Description

An abstraction for memory operations.

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

Since: 1.4

Definition at line 45 of file Memory.h.

Member Enumeration Documentation

enum llvm::sys::Memory::ProtectionFlags

Enumerator
MF_READ
MF_WRITE
MF_EXEC

Definition at line 47 of file Memory.h.

Member Function Documentation

static MemoryBlock llvm::sys::Memory::allocateMappedMemory	(	size_t	NumBytes,
		const MemoryBlock *const	NearBlock,
		unsigned	Flags,
		error_code &	EC
	)

static

Allocate mapped memory.

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.

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

static MemoryBlock llvm::sys::Memory::AllocateRWX	(	size_t	NumBytes,
		const MemoryBlock *	NearBlock,
		std::string *	ErrMsg = `0`
	)

static

Allocate Read/Write/Execute memory.

This method allocates a block of Read/Write/Execute memory that is suitable for executing 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.

On success, this returns a non-null memory block, otherwise it returns a null memory block and fills in *ErrMsg.

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

static

InvalidateInstructionCache - Before the JIT can run a block of code that has been emitted it must invalidate the instruction cache on some platforms.

Referenced by llvm::PPCJITInfo::emitFunctionStub(), llvm::SparcJITInfo::emitFunctionStub(), llvm::MipsJITInfo::emitFunctionStub(), llvm::ARMJITInfo::emitFunctionStub(), llvm::SectionMemoryManager::invalidateInstructionCache(), LLVMPPCCompilationCallback(), MipsCompilationCallbackC(), llvm::MipsJITInfo::replaceMachineCodeForFunction(), llvm::PPCJITInfo::replaceMachineCodeForFunction(), and SparcCompilationCallbackC().

static error_code llvm::sys::Memory::protectMappedMemory	(	const MemoryBlock &	Block,
		unsigned	Flags
	)

static

Set memory protection state.

This method sets the protection flags for a block of memory to the state specified by /p Flags. The behavior is not specified if the memory was not allocated using the allocateMappedMemory method. Block describes the memory block to be protected. Flags specifies the new protection state to be assigned to the block. ErrMsg [out] returns a string describing any error that occured.

If Flags is MF_WRITE, the actual behavior varies with the operating system (i.e. MF_READ | MF_WRITE on Windows) and the target architecture (i.e. MF_WRITE -> MF_READ | MF_WRITE on i386).

error_success if the function was successful, or an error_code describing the failure if an error occurred.

static error_code llvm::sys::Memory::releaseMappedMemory ( MemoryBlock & Block )

static

Release mapped memory.

This method releases a block of memory that was allocated with the allocateMappedMemory method. It should not be used to release any memory block allocated any other way. Block describes the memory to be released.

error_success if the function was successful, or an error_code describing the failure if an error occurred.

Referenced by llvm::SectionMemoryManager::~SectionMemoryManager().

static bool llvm::sys::Memory::ReleaseRWX	(	MemoryBlock &	block,
		std::string *	ErrMsg = `0`
	)

static

Release Read/Write/Execute memory.

This method releases a block of Read/Write/Execute memory that was allocated with the AllocateRWX method. It should not be used to release any memory block allocated any other way.

On success, this returns false, otherwise it returns true and fills in *ErrMsg.

static bool llvm::sys::Memory::setExecutable	(	MemoryBlock &	M,
		std::string *	ErrMsg = `0`
	)

static

setExecutable - Before the JIT can run a block of code, it has to be given read and executable privilege. Return true if it is already r-x or the system is able to change its previlege.

static bool llvm::sys::Memory::setRangeExecutable	(	const void *	Addr,
		size_t	Size
	)

static

setRangeExecutable - Mark the page containing a range of addresses as executable.

Referenced by ARMCompilationCallbackC(), llvm::SparcJITInfo::emitFunctionStub(), llvm::MipsJITInfo::emitFunctionStub(), and llvm::ARMJITInfo::emitFunctionStub().

static bool llvm::sys::Memory::setRangeWritable	(	const void *	Addr,
		size_t	Size
	)

static

setRangeWritable - Mark the page containing a range of addresses as writable.

Referenced by ARMCompilationCallbackC(), llvm::SparcJITInfo::emitFunctionStub(), llvm::MipsJITInfo::emitFunctionStub(), and llvm::ARMJITInfo::emitFunctionStub().

static bool llvm::sys::Memory::setWritable	(	MemoryBlock &	M,
		std::string *	ErrMsg = `0`
	)

static

setWritable - When adding to a block of code, the JIT may need to mark a block of code as RW since the protections are on page boundaries, and the JIT internal allocations are not page aligned.

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

Memory.h

Public Types

Static Public Member Functions

Detailed Description

Member Enumeration Documentation

Member Function Documentation