diff options
Diffstat (limited to 'js/src/jit/ExecutableAllocator.cpp')
| -rw-r--r-- | js/src/jit/ExecutableAllocator.cpp | 390 |
1 files changed, 390 insertions, 0 deletions
diff --git a/js/src/jit/ExecutableAllocator.cpp b/js/src/jit/ExecutableAllocator.cpp new file mode 100644 index 000000000..20ca74183 --- /dev/null +++ b/js/src/jit/ExecutableAllocator.cpp @@ -0,0 +1,390 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * + * Copyright (C) 2008 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "jit/ExecutableAllocator.h" + +#include "jit/JitCompartment.h" +#include "js/MemoryMetrics.h" + +using namespace js::jit; + +ExecutablePool::~ExecutablePool() +{ + MOZ_ASSERT(m_ionCodeBytes == 0); + MOZ_ASSERT(m_baselineCodeBytes == 0); + MOZ_ASSERT(m_regexpCodeBytes == 0); + MOZ_ASSERT(m_otherCodeBytes == 0); + + MOZ_ASSERT(!isMarked()); + + m_allocator->releasePoolPages(this); +} + +void +ExecutablePool::release(bool willDestroy) +{ + MOZ_ASSERT(m_refCount != 0); + MOZ_ASSERT_IF(willDestroy, m_refCount == 1); + if (--m_refCount == 0) + js_delete(this); +} + +void +ExecutablePool::release(size_t n, CodeKind kind) +{ + switch (kind) { + case ION_CODE: + m_ionCodeBytes -= n; + MOZ_ASSERT(m_ionCodeBytes < m_allocation.size); // Shouldn't underflow. + break; + case BASELINE_CODE: + m_baselineCodeBytes -= n; + MOZ_ASSERT(m_baselineCodeBytes < m_allocation.size); + break; + case REGEXP_CODE: + m_regexpCodeBytes -= n; + MOZ_ASSERT(m_regexpCodeBytes < m_allocation.size); + break; + case OTHER_CODE: + m_otherCodeBytes -= n; + MOZ_ASSERT(m_otherCodeBytes < m_allocation.size); + break; + default: + MOZ_CRASH("bad code kind"); + } + + release(); +} + +void +ExecutablePool::addRef() +{ + // It should be impossible for us to roll over, because only small + // pools have multiple holders, and they have one holder per chunk + // of generated code, and they only hold 16KB or so of code. + MOZ_ASSERT(m_refCount); + ++m_refCount; + MOZ_ASSERT(m_refCount, "refcount overflow"); +} + +void* +ExecutablePool::alloc(size_t n, CodeKind kind) +{ + MOZ_ASSERT(n <= available()); + void* result = m_freePtr; + m_freePtr += n; + + switch (kind) { + case ION_CODE: m_ionCodeBytes += n; break; + case BASELINE_CODE: m_baselineCodeBytes += n; break; + case REGEXP_CODE: m_regexpCodeBytes += n; break; + case OTHER_CODE: m_otherCodeBytes += n; break; + default: MOZ_CRASH("bad code kind"); + } + + return result; +} + +size_t +ExecutablePool::available() const +{ + MOZ_ASSERT(m_end >= m_freePtr); + return m_end - m_freePtr; +} + +ExecutableAllocator::ExecutableAllocator(JSRuntime* rt) + : rt_(rt) +{ + MOZ_ASSERT(m_smallPools.empty()); +} + +ExecutableAllocator::~ExecutableAllocator() +{ + for (size_t i = 0; i < m_smallPools.length(); i++) + m_smallPools[i]->release(/* willDestroy = */true); + + // If this asserts we have a pool leak. + MOZ_ASSERT_IF(m_pools.initialized(), m_pools.empty()); +} + +ExecutablePool* +ExecutableAllocator::poolForSize(size_t n) +{ + // Try to fit in an existing small allocator. Use the pool with the + // least available space that is big enough (best-fit). This is the + // best strategy because (a) it maximizes the chance of the next + // allocation fitting in a small pool, and (b) it minimizes the + // potential waste when a small pool is next abandoned. + ExecutablePool* minPool = nullptr; + for (size_t i = 0; i < m_smallPools.length(); i++) { + ExecutablePool* pool = m_smallPools[i]; + if (n <= pool->available() && (!minPool || pool->available() < minPool->available())) + minPool = pool; + } + if (minPool) { + minPool->addRef(); + return minPool; + } + + // If the request is large, we just provide a unshared allocator + if (n > ExecutableCodePageSize) + return createPool(n); + + // Create a new allocator + ExecutablePool* pool = createPool(ExecutableCodePageSize); + if (!pool) + return nullptr; + // At this point, local |pool| is the owner. + + if (m_smallPools.length() < maxSmallPools) { + // We haven't hit the maximum number of live pools; add the new pool. + // If append() OOMs, we just return an unshared allocator. + if (m_smallPools.append(pool)) + pool->addRef(); + } else { + // Find the pool with the least space. + int iMin = 0; + for (size_t i = 1; i < m_smallPools.length(); i++) { + if (m_smallPools[i]->available() < m_smallPools[iMin]->available()) + iMin = i; + } + + // If the new allocator will result in more free space than the small + // pool with the least space, then we will use it instead + ExecutablePool* minPool = m_smallPools[iMin]; + if ((pool->available() - n) > minPool->available()) { + minPool->release(); + m_smallPools[iMin] = pool; + pool->addRef(); + } + } + + // Pass ownership to the caller. + return pool; +} + +/* static */ size_t +ExecutableAllocator::roundUpAllocationSize(size_t request, size_t granularity) +{ + // Something included via windows.h defines a macro with this name, + // which causes the function below to fail to compile. +#ifdef _MSC_VER +# undef max +#endif + + if ((std::numeric_limits<size_t>::max() - granularity) <= request) + return OVERSIZE_ALLOCATION; + + // Round up to next page boundary + size_t size = request + (granularity - 1); + size = size & ~(granularity - 1); + MOZ_ASSERT(size >= request); + return size; +} + +ExecutablePool* +ExecutableAllocator::createPool(size_t n) +{ + MOZ_ASSERT(rt_->jitRuntime()->preventBackedgePatching()); + + size_t allocSize = roundUpAllocationSize(n, ExecutableCodePageSize); + if (allocSize == OVERSIZE_ALLOCATION) + return nullptr; + + if (!m_pools.initialized() && !m_pools.init()) + return nullptr; + + ExecutablePool::Allocation a = systemAlloc(allocSize); + if (!a.pages) + return nullptr; + + ExecutablePool* pool = js_new<ExecutablePool>(this, a); + if (!pool) { + systemRelease(a); + return nullptr; + } + + if (!m_pools.put(pool)) { + // Note: this will call |systemRelease(a)|. + js_delete(pool); + return nullptr; + } + + return pool; +} + +void* +ExecutableAllocator::alloc(size_t n, ExecutablePool** poolp, CodeKind type) +{ + // Don't race with reprotectAll called from the signal handler. + JitRuntime::AutoPreventBackedgePatching apbp(rt_); + + // Caller must ensure 'n' is word-size aligned. If all allocations are + // of word sized quantities, then all subsequent allocations will be + // aligned. + MOZ_ASSERT(roundUpAllocationSize(n, sizeof(void*)) == n); + + if (n == OVERSIZE_ALLOCATION) { + *poolp = nullptr; + return nullptr; + } + + *poolp = poolForSize(n); + if (!*poolp) + return nullptr; + + // This alloc is infallible because poolForSize() just obtained + // (found, or created if necessary) a pool that had enough space. + void* result = (*poolp)->alloc(n, type); + MOZ_ASSERT(result); + return result; +} + +void +ExecutableAllocator::releasePoolPages(ExecutablePool* pool) +{ + // Don't race with reprotectAll called from the signal handler. + JitRuntime::AutoPreventBackedgePatching apbp(rt_); + + MOZ_ASSERT(pool->m_allocation.pages); + systemRelease(pool->m_allocation); + + MOZ_ASSERT(m_pools.initialized()); + + // Pool may not be present in m_pools if we hit OOM during creation. + if (auto ptr = m_pools.lookup(pool)) + m_pools.remove(ptr); +} + +void +ExecutableAllocator::purge() +{ + // Don't race with reprotectAll called from the signal handler. + JitRuntime::AutoPreventBackedgePatching apbp(rt_); + + for (size_t i = 0; i < m_smallPools.length(); i++) + m_smallPools[i]->release(); + m_smallPools.clear(); +} + +void +ExecutableAllocator::addSizeOfCode(JS::CodeSizes* sizes) const +{ + if (m_pools.initialized()) { + for (ExecPoolHashSet::Range r = m_pools.all(); !r.empty(); r.popFront()) { + ExecutablePool* pool = r.front(); + sizes->ion += pool->m_ionCodeBytes; + sizes->baseline += pool->m_baselineCodeBytes; + sizes->regexp += pool->m_regexpCodeBytes; + sizes->other += pool->m_otherCodeBytes; + sizes->unused += pool->m_allocation.size - pool->m_ionCodeBytes + - pool->m_baselineCodeBytes + - pool->m_regexpCodeBytes + - pool->m_otherCodeBytes; + } + } +} + +void +ExecutableAllocator::reprotectAll(ProtectionSetting protection) +{ + if (!m_pools.initialized()) + return; + + for (ExecPoolHashSet::Range r = m_pools.all(); !r.empty(); r.popFront()) + reprotectPool(rt_, r.front(), protection); +} + +/* static */ void +ExecutableAllocator::reprotectPool(JSRuntime* rt, ExecutablePool* pool, ProtectionSetting protection) +{ + // Don't race with reprotectAll called from the signal handler. + MOZ_ASSERT(rt->jitRuntime()->preventBackedgePatching() || rt->handlingJitInterrupt()); + + char* start = pool->m_allocation.pages; + if (!ReprotectRegion(start, pool->m_freePtr - start, protection)) + MOZ_CRASH(); +} + +/* static */ void +ExecutableAllocator::poisonCode(JSRuntime* rt, JitPoisonRangeVector& ranges) +{ + MOZ_ASSERT(CurrentThreadCanAccessRuntime(rt)); + + // Don't race with reprotectAll called from the signal handler. + JitRuntime::AutoPreventBackedgePatching apbp(rt); + +#ifdef DEBUG + // Make sure no pools have the mark bit set. + for (size_t i = 0; i < ranges.length(); i++) + MOZ_ASSERT(!ranges[i].pool->isMarked()); +#endif + + for (size_t i = 0; i < ranges.length(); i++) { + ExecutablePool* pool = ranges[i].pool; + if (pool->m_refCount == 1) { + // This is the last reference so the release() call below will + // unmap the memory. Don't bother poisoning it. + continue; + } + + MOZ_ASSERT(pool->m_refCount > 1); + + // Use the pool's mark bit to indicate we made the pool writable. + // This avoids reprotecting a pool multiple times. + if (!pool->isMarked()) { + reprotectPool(rt, pool, ProtectionSetting::Writable); + pool->mark(); + } + + memset(ranges[i].start, JS_SWEPT_CODE_PATTERN, ranges[i].size); + } + + // Make the pools executable again and drop references. + for (size_t i = 0; i < ranges.length(); i++) { + ExecutablePool* pool = ranges[i].pool; + if (pool->isMarked()) { + reprotectPool(rt, pool, ProtectionSetting::Executable); + pool->unmark(); + } + pool->release(); + } +} + +ExecutablePool::Allocation +ExecutableAllocator::systemAlloc(size_t n) +{ + void* allocation = AllocateExecutableMemory(n, ProtectionSetting::Executable); + ExecutablePool::Allocation alloc = { reinterpret_cast<char*>(allocation), n }; + return alloc; +} + +void +ExecutableAllocator::systemRelease(const ExecutablePool::Allocation& alloc) +{ + DeallocateExecutableMemory(alloc.pages, alloc.size); +} |