dart::VirtualMemory Class Reference

#include <virtual_memory.h>

Public Types
enum	Protection {   kNoAccess , kReadOnly , kReadWrite , kReadExecute ,   kReadWriteExecute }

Public Member Functions
	~VirtualMemory ()
uword	start () const
uword	end () const
void *	address () const
intptr_t	size () const
bool	Contains (uword addr) const
void	Protect (Protection mode)
bool	DuplicateRX (VirtualMemory *target)
void	Truncate (intptr_t new_size)
bool	vm_owns_region () const

Static Public Member Functions
static void	Init ()
static void	Cleanup ()
static void	Protect (void *address, intptr_t size, Protection mode)
static void	DontNeed (void *address, intptr_t size)
static VirtualMemory *	Allocate (intptr_t size, bool is_executable, bool is_compressed, const char *name)
static VirtualMemory *	AllocateAligned (intptr_t size, intptr_t alignment, bool is_executable, bool is_compressed, const char *name)
static intptr_t	PageSize ()
static bool	InSamePage (uword address0, uword address1)
static VirtualMemory *	ForImagePage (void *pointer, uword size)

Detailed Description

Definition at line 19 of file virtual_memory.h.

Member Enumeration Documentation

Protection

enum dart::VirtualMemory::Protection

Enumerator
kNoAccess
kReadOnly
kReadWrite
kReadExecute
kReadWriteExecute

Definition at line 21 of file virtual_memory.h.

                  {
    kNoAccess,
    kReadOnly,
    kReadWrite,
    kReadExecute,
    kReadWriteExecute
  };

Constructor & Destructor Documentation

~VirtualMemory()

dart::VirtualMemory::~VirtualMemory

(

)

Member Function Documentation

address()

void * dart::VirtualMemory::address ( ) const

inline

Definition at line 34 of file virtual_memory.h.

{ return region_.pointer(); }

Allocate()

static VirtualMemory * dart::VirtualMemory::Allocate ( intptr_t  size, bool  is_executable, bool  is_compressed, const char *  name  )

inlinestatic

Definition at line 54 of file virtual_memory.h.

                                                   {
    return AllocateAligned(size, PageSize(), is_executable, is_compressed,
                           name);
  }

AllocateAligned()

static VirtualMemory * dart::VirtualMemory::AllocateAligned ( intptr_t  size, intptr_t  alignment, bool  is_executable, bool  is_compressed, const char *  name  )

static

Cleanup()

static void dart::VirtualMemory::Cleanup ( )

static

Contains()

bool dart::VirtualMemory::Contains ( uword  addr ) const

inline

Definition at line 44 of file virtual_memory.h.

{ return region_.Contains(addr); }

DontNeed()

static void dart::VirtualMemory::DontNeed ( void *  address, intptr_t  size  )

static

DuplicateRX()

bool dart::VirtualMemory::DuplicateRX

(

VirtualMemory *

target

)

Definition at line 48 of file virtual_memory.cc.

                                                     {
  const intptr_t aligned_size = Utils::RoundUp(size(), PageSize());
  ASSERT_LESS_OR_EQUAL(aligned_size, target->size());
 
#if defined(DART_HOST_OS_MACOS) && defined(DART_PRECOMPILED_RUNTIME)
  // Mac is special cased because iOS doesn't allow allocating new executable
  // memory, so the default approach would fail. We are allowed to make new
  // mappings of existing executable memory using vm_remap though, which is
  // effectively the same for non-writable memory.
  const mach_port_t task = mach_task_self();
  const vm_address_t source_address = reinterpret_cast<vm_address_t>(address());
  const vm_size_t mem_size = aligned_size;
  const vm_prot_t read_execute = VM_PROT_READ | VM_PROT_EXECUTE;
  vm_prot_t current_protection = read_execute;
  vm_prot_t max_protection = read_execute;
  vm_address_t target_address =
      reinterpret_cast<vm_address_t>(target->address());
  kern_return_t status = vm_remap(
      task, &target_address, mem_size,
      /*mask=*/0,
      /*flags=*/VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE, task, source_address,
      /*copy=*/true, &current_protection, &max_protection,
      /*inheritance=*/VM_INHERIT_NONE);
  if (status != KERN_SUCCESS) {
    return false;
  }
  ASSERT(reinterpret_cast<void*>(target_address) == target->address());
  ASSERT_EQUAL(current_protection & read_execute, read_execute);
  ASSERT_EQUAL(max_protection & read_execute, read_execute);
  return true;
 
#else   // defined(DART_HOST_OS_MACOS)
  // TODO(52497): Use dual mapping on platforms where it's supported.
  // Check that target doesn't overlap with this.
  ASSERT(target->start() >= end() || target->end() <= start());
  memcpy(target->address(), address(), size());  // NOLINT
  Protect(target->address(), aligned_size, kReadExecute);
  return true;
#endif  // defined(DART_HOST_OS_MACOS)
}

end()

uword dart::VirtualMemory::end ( ) const

inline

Definition at line 33 of file virtual_memory.h.

{ return region_.end(); }

ForImagePage()

VirtualMemory * dart::VirtualMemory::ForImagePage ( void *  pointer, uword  size  )

static

Definition at line 34 of file virtual_memory.cc.

                                                                    {
  // Memory for precompilated instructions was allocated by the embedder, so
  // create a VirtualMemory without allocating.
  MemoryRegion region(pointer, size);
  MemoryRegion reserved(nullptr, 0);  // null reservation indicates VM should
                                      // not attempt to free this memory.
  VirtualMemory* memory = new VirtualMemory(region, reserved);
  ASSERT(!memory->vm_owns_region());
  return memory;
}

Init()

static void dart::VirtualMemory::Init ( )

static

InSamePage()

bool dart::VirtualMemory::InSamePage ( uword  address0, uword  address1  )

static

Definition at line 16 of file virtual_memory.cc.

                                                             {
  return (Utils::RoundDown(address0, PageSize()) ==
          Utils::RoundDown(address1, PageSize()));
}

PageSize()

static intptr_t dart::VirtualMemory::PageSize ( )

inlinestatic

Definition at line 79 of file virtual_memory.h.

                             {
    ASSERT(page_size_ != 0);
    return page_size_;
  }

Protect() [1/2]

void dart::VirtualMemory::Protect ( Protection  mode )

inline

Definition at line 48 of file virtual_memory.h.

{ return Protect(address(), size(), mode); }

Protect() [2/2]

static void dart::VirtualMemory::Protect ( void *  address, intptr_t  size, Protection  mode  )

static

size()

intptr_t dart::VirtualMemory::size ( ) const

inline

Definition at line 35 of file virtual_memory.h.

{ return region_.size(); }

start()

uword dart::VirtualMemory::start ( ) const

inline

Definition at line 32 of file virtual_memory.h.

{ return region_.start(); }

Truncate()

void dart::VirtualMemory::Truncate

(

intptr_t

new_size

)

Definition at line 21 of file virtual_memory.cc.

                                              {
  ASSERT(Utils::IsAligned(new_size, PageSize()));
  ASSERT(new_size <= size());
  if (reserved_.size() ==
      region_.size()) {  // Don't create holes in reservation.
    if (FreeSubSegment(reinterpret_cast<void*>(start() + new_size),
                       size() - new_size)) {
      reserved_.set_size(new_size);
    }
  }
  region_.Subregion(region_, 0, new_size);
}

vm_owns_region()

bool dart::VirtualMemory::vm_owns_region ( ) const

inline

Definition at line 92 of file virtual_memory.h.

{ return reserved_.pointer() != nullptr; }

---

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

• third_party/dart-lang/sdk/runtime/vm/virtual_memory.h
• third_party/dart-lang/sdk/runtime/vm/virtual_memory.cc