kInstructionStream,

kWasmCode,

kWasmJumpTable,

kWasmFarJumpTable,

kWasmLazyCompileTable,

typedef T value_type;

StlAllocator() = default;

template <class U>

explicit StlAllocator(const StlAllocator<U>&) noexcept {}

value_type* allocate(size_t n) {

if (Enabled()) {

return static_cast<value_type*>(

ThreadIsolation::allocator()->Allocate(n * sizeof(value_type)));

} else {

return static_cast<value_type*>(::operator new(n * sizeof(T)));

}

}

void deallocate(value_type* ptr, size_t n) {

if (Enabled()) {

ThreadIsolation::allocator()->Free(ptr);

} else {

::operator delete(ptr);

}

}

public:

explicit JitAllocation(size_t size, JitAllocationType type)

: size_(size), type_(type) {}

size_t Size() const { return size_; }

JitAllocationType Type() const { return type_; }

private:

size_t size_;

JitAllocationType type_;

public:

explicit JitPage(size_t size) : size_(size) {}

~JitPage();

private:

base::Mutex mutex_;

typedef std::map<Address, JitAllocation, std::less<Address>,

StlAllocator<std::pair<const Address, JitAllocation>>>

AllocationMap;

AllocationMap allocations_;

size_t size_;

friend class JitPageReference;

// Allow CanLookupStartOfJitAllocationAt to check if the mutex is locked.

friend bool ThreadIsolation::CanLookupStartOfJitAllocationAt(Address);

public:

WritableJitAllocation(const WritableJitAllocation&) = delete;

WritableJitAllocation& operator=(const WritableJitAllocation&) = delete;

V8_INLINE ~WritableJitAllocation();

static WritableJitAllocation ForInstructionStream(

Tagged<InstructionStream> istream);

// WritableJitAllocations are used during reloc iteration. But in some

// cases, we relocate code off-heap, e.g. when growing AssemblerBuffers.

// This function creates a WritableJitAllocation that doesn't unlock the

// executable memory.

static V8_INLINE WritableJitAllocation ForNonExecutableMemory(

Address addr, size_t size, ThreadIsolation::JitAllocationType type);

// Writes a header slot either as a primitive or as a Tagged value.

// Important: this function will not trigger a write barrier by itself,

// since we want to keep the code running with write access to executable

// memory to a minimum. You should trigger the write barriers after this

// function goes out of scope.

template <typename T, size_t offset>

V8_INLINE void WriteHeaderSlot(T value);

template <typename T, size_t offset>

V8_INLINE void WriteHeaderSlot(Tagged<T> value, ReleaseStoreTag);

template <typename T, size_t offset>

V8_INLINE void WriteHeaderSlot(Tagged<T> value, RelaxedStoreTag);

template <typename T, size_t offset>

V8_INLINE void WriteProtectedPointerHeaderSlot(Tagged<T> value,

ReleaseStoreTag);

template <typename T, size_t offset>

V8_INLINE void WriteProtectedPointerHeaderSlot(Tagged<T> value,

RelaxedStoreTag);

template <typename T>

V8_INLINE void WriteHeaderSlot(Address address, T value, RelaxedStoreTag);

// CopyCode and CopyData have the same implementation at the moment, but

// they will diverge once we implement validation.

V8_INLINE void CopyCode(size_t dst_offset, const uint8_t* src,

size_t num_bytes);

V8_INLINE void CopyData(size_t dst_offset, const uint8_t* src,

size_t num_bytes);

template <typename T>

V8_INLINE void WriteUnalignedValue(Address address, T value);

template <typename T>

V8_INLINE void WriteValue(Address address, T value);

template <typename T>

V8_INLINE void WriteValue(Address address, T value, RelaxedStoreTag);

V8_INLINE void ClearBytes(size_t offset, size_t len);

Address address() const { return address_; }

size_t size() const { return allocation_.Size(); }

private:

enum class JitAllocationSource {

kRegister,

kLookup,

};

V8_INLINE WritableJitAllocation(Address addr, size_t size,

ThreadIsolation::JitAllocationType type,

JitAllocationSource source,

bool enforce_write_api = false);

// Used for non-executable memory.

V8_INLINE WritableJitAllocation(Address addr, size_t size,

ThreadIsolation::JitAllocationType type,

bool enforce_write_api);

ThreadIsolation::JitPageReference& page_ref() { return page_ref_.value(); }

// In DEBUG mode, we only make RWX memory writable during the write operations

// themselves to ensure that all writes go through this object.

// This function returns a write scope that can be used for these writes.

V8_INLINE std::optional<RwxMemoryWriteScope> WriteScopeForApiEnforcement()

const;

const Address address_;

// TODO(sroettger): we can move the memory write scopes into the Write*

// functions in debug builds. This would allow us to ensure that all writes

// go through this object.

// The scope and page reference are optional in case we're creating a

// WritableJitAllocation for off-heap memory. See ForNonExecutableMemory

// above.

std::optional<RwxMemoryWriteScope> write_scope_;

std::optional<ThreadIsolation::JitPageReference> page_ref_;

const ThreadIsolation::JitAllocation allocation_;

bool enforce_write_api_ = false;

friend class ThreadIsolation;

friend class WritableJitPage;

friend class WritableJumpTablePair;

public:

// This function can be used to create a WritableFreeSpace object for

// non-executable memory only, i.e. it won't perform CFI validation and

// doesn't unlock the code space.

// For executable memory, use the WritableJitPage::FreeRange function.

static V8_INLINE WritableFreeSpace ForNonExecutableMemory(base::Address addr,

size_t size);

WritableFreeSpace(const WritableFreeSpace&) = delete;

WritableFreeSpace& operator=(const WritableFreeSpace&) = delete;

V8_INLINE ~WritableFreeSpace();

template <typename T, size_t offset>

V8_INLINE void WriteHeaderSlot(Tagged<T> value, RelaxedStoreTag) const;

template <size_t offset>

void ClearTagged(size_t count) const;

base::Address Address() const { return address_; }

int Size() const { return size_; }

bool Executable() const { return executable_; }

private:

WritableFreeSpace(base::Address addr, size_t size, bool executable);

const base::Address address_;

const int size_;

const bool executable_;

friend class WritableJitPage;

public:

V8_INLINE WritableJitPage(Address addr, size_t size);

WritableJitPage(const WritableJitPage&) = delete;

WritableJitPage& operator=(const WritableJitPage&) = delete;

V8_INLINE ~WritableJitPage();

friend class ThreadIsolation;

V8_INLINE WritableJitAllocation LookupAllocationContaining(Address addr);

V8_INLINE WritableFreeSpace FreeRange(Address addr, size_t size);

bool Empty() const { return page_ref_.Empty(); }

private:

RwxMemoryWriteScope write_scope_;

ThreadIsolation::JitPageReference page_ref_;