Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef MASM_EXECUTABLEALLOCATOR_H
#define MASM_EXECUTABLEALLOCATOR_H
#include <RefPtr.h>
#include <RefCounted.h>
#include <wtf/PageBlock.h>
#include <private/qv4executableallocator_p.h>
#if OS(INTEGRITY)
#include "OSAllocator.h"
#endif
#if OS(WINDOWS)
#include <qt_windows.h>
#else
#include <sys/mman.h>
#include <unistd.h>
#endif
#ifdef __QNXNTO__
using std::perror;
#endif
namespace JSC {
class JSGlobalData;
struct ExecutableMemoryHandle : public RefCounted<ExecutableMemoryHandle> {
ExecutableMemoryHandle(QV4::ExecutableAllocator *allocator, size_t size)
: m_allocator(allocator)
, m_size(size)
{
m_allocation = allocator->allocate(size);
}
~ExecutableMemoryHandle()
{
m_allocation->deallocate(m_allocator);
}
inline void shrink(size_t) {
// ### TODO.
}
inline bool isManaged() const { return true; }
void *memoryStart() { return m_allocation->memoryStart(); }
size_t memorySize() { return m_allocation->memorySize(); }
void *exceptionHandlerStart() { return m_allocation->exceptionHandlerStart(); }
size_t exceptionHandlerSize() { return m_allocation->exceptionHandlerSize(); }
void *codeStart() { return m_allocation->codeStart(); }
size_t codeSize() { return m_size; }
QV4::ExecutableAllocator::ChunkOfPages *chunk() const
{ return m_allocator->chunkForAllocation(m_allocation); }
QV4::ExecutableAllocator *m_allocator;
QV4::ExecutableAllocator::Allocation *m_allocation;
size_t m_size;
};
struct ExecutableAllocator {
ExecutableAllocator(QV4::ExecutableAllocator *alloc)
: realAllocator(alloc)
{}
Ref<ExecutableMemoryHandle> allocate(JSGlobalData&, size_t size, void*, int)
{
return adoptRef(new ExecutableMemoryHandle(realAllocator, size));
}
static bool makeWritable(void* addr, size_t size)
{
quintptr pageSize = WTF::pageSize();
quintptr iaddr = reinterpret_cast<quintptr>(addr);
quintptr roundAddr = iaddr & ~(pageSize - 1);
size = size + (iaddr - roundAddr);
addr = reinterpret_cast<void*>(roundAddr);
#if ENABLE(ASSEMBLER_WX_EXCLUSIVE) && !defined(V4_BOOTSTRAP)
# if OS(WINDOWS)
DWORD oldProtect;
# if !OS(WINRT)
VirtualProtect(addr, size, PAGE_READWRITE, &oldProtect);
# else
bool hr = VirtualProtectFromApp(addr, size, PAGE_READWRITE, &oldProtect);
if (!hr) {
return false;
}
# endif
# elif OS(INTEGRITY)
OSAllocator::setMemoryAttributes(addr, size, /*writable*/ true, /*executable*/ false);
# else
int mode = PROT_READ | PROT_WRITE;
if (mprotect(addr, size, mode) != 0) {
perror("mprotect failed in ExecutableAllocator::makeWritable");
return false;
}
# endif
#else
// We assume we already have RWX
(void)addr; // suppress unused parameter warning
(void)size; // suppress unused parameter warning
#endif
return true;
}
static bool makeExecutable(void* addr, size_t size)
{
quintptr pageSize = WTF::pageSize();
quintptr iaddr = reinterpret_cast<quintptr>(addr);
quintptr roundAddr = iaddr & ~(pageSize - 1);
size = size + (iaddr - roundAddr);
addr = reinterpret_cast<void*>(roundAddr);
#if !defined(V4_BOOTSTRAP)
#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
# if OS(WINDOWS)
DWORD oldProtect;
# if !OS(WINRT)
VirtualProtect(addr, size, PAGE_EXECUTE_READ, &oldProtect);
# else
bool hr = VirtualProtectFromApp(addr, size, PAGE_EXECUTE_READ, &oldProtect);
if (!hr) {
return false;
}
# endif
# elif OS(INTEGRITY)
OSAllocator::setMemoryAttributes(addr, size, /*writable*/ false, /*executable*/ true);
# else
int mode = PROT_READ | PROT_EXEC;
if (mprotect(addr, size, mode) != 0) {
perror("mprotect failed in ExecutableAllocator::makeExecutable");
return false;
}
# endif
#else
# error "Only W^X is supported"
#endif
#else
(void)addr; // suppress unused parameter warning
(void)size; // suppress unused parameter warning
#endif
return true;
}
QV4::ExecutableAllocator *realAllocator;
};
}
#endif // MASM_EXECUTABLEALLOCATOR_H