1 files changed, 361 insertions, 0 deletions
diff --git a/JavaScriptCore/wtf/PageAllocation.h b/JavaScriptCore/wtf/PageAllocation.h
new file mode 100644
index 0000000..26d53a5
--- /dev/null
+++ b/JavaScriptCore/wtf/PageAllocation.h
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2010 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. 
+ */
+
+#ifndef PageAllocation_h
+#define PageAllocation_h
+
+#include <wtf/Assertions.h>
+#include <wtf/UnusedParam.h>
+#include <wtf/VMTags.h>
+
+#if OS(DARWIN)
+#include <mach/mach_init.h>
+#include <mach/vm_map.h>
+#endif
+
+#if OS(HAIKU)
+#include <OS.h>
+#endif
+
+#if OS(WINDOWS)
+#include <malloc.h>
+#include <windows.h>
+#endif
+
+#if OS(SYMBIAN)
+#include <e32hal.h>
+#include <e32std.h>
+#endif
+
+#if HAVE(ERRNO_H)
+#include <errno.h>
+#endif
+
+#if HAVE(MMAP)
+#include <sys/mman.h>
+#include <unistd.h>
+#endif
+
+namespace WTF {
+
+/*
+    PageAllocation
+
+    The PageAllocation class provides a cross-platform memory allocation interface
+    with similar capabilities to posix mmap/munmap.  Memory is allocated by calling
+    PageAllocation::allocate, and deallocated by calling deallocate on the
+    PageAllocation object.  The PageAllocation holds the allocation's base pointer
+    and size.
+
+    The allocate method is passed the size required (which must be a multiple of
+    the system page size, which can be accessed using PageAllocation::pageSize).
+    Callers may also optinally provide a flag indicating the usage (for use by
+    system memory usage tracking tools, where implemented), and boolean values
+    specifying the required protection (defaulting to writable, non-executable).
+
+    Where HAVE(PAGE_ALLOCATE_AT) and HAVE(PAGE_ALLOCATE_ALIGNED) are available
+    memory may also be allocated at a specified address, or with a specified
+    alignment respectively.  PageAllocation::allocateAt take an address to try
+    to allocate at, and a boolean indicating whether this behaviour is strictly
+    required (if this address is unavailable, should memory at another address
+    be allocated instead).  PageAllocation::allocateAligned requires that the
+    size is a power of two that is >= system page size.
+*/
+class PageAllocation {
+public:
+    enum Usage {
+        UnknownUsage = -1,
+        FastMallocPages = VM_TAG_FOR_TCMALLOC_MEMORY,
+        JSGCHeapPages = VM_TAG_FOR_COLLECTOR_MEMORY,
+        JSVMStackPages = VM_TAG_FOR_REGISTERFILE_MEMORY,
+        JSJITCodePages = VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY,
+    };
+
+    PageAllocation()
+        : m_base(0)
+        , m_size(0)
+#if OS(SYMBIAN)
+        , m_chunk(0)
+#endif
+    {
+    }
+
+    bool operator!() const { return !m_base; }
+    void* base() const { return m_base; }
+    size_t size() const { return m_size; }
+
+    static PageAllocation allocate(size_t size, Usage usage = UnknownUsage, bool writable = true, bool executable = false)
+    {
+        ASSERT(isPageAligned(size));
+        return systemAllocate(size, usage, writable, executable);
+    }
+
+#if HAVE(PAGE_ALLOCATE_AT)
+    static PageAllocation allocateAt(void* address, bool fixed, size_t size, Usage usage = UnknownUsage, bool writable = true, bool executable = false)
+    {
+        ASSERT(isPageAligned(address));
+        ASSERT(isPageAligned(size));
+        return systemAllocateAt(address, fixed, size, usage, writable, executable);
+    }
+#endif
+
+#if HAVE(PAGE_ALLOCATE_ALIGNED)
+    static PageAllocation allocateAligned(size_t size, Usage usage = UnknownUsage)
+    {
+        ASSERT(isPageAligned(size));
+        ASSERT(isPowerOfTwo(size));
+        return systemAllocateAligned(size, usage);
+    }
+#endif
+
+    void deallocate()
+    {
+        ASSERT(m_base);
+        systemDeallocate(true);
+    }
+
+    static size_t pageSize()
+    {
+        if (!s_pageSize)
+            s_pageSize = systemPageSize();
+        ASSERT(isPowerOfTwo(s_pageSize));
+        return s_pageSize;
+    }
+
+#ifndef NDEBUG
+    static bool isPageAligned(void* address) { return !(reinterpret_cast<intptr_t>(address) & (pageSize() - 1)); }
+    static bool isPageAligned(size_t size) { return !(size & (pageSize() - 1)); }
+    static bool isPowerOfTwo(size_t size) { return !(size & (size - 1)); }
+    static int lastError();
+#endif
+
+protected:
+#if OS(SYMBIAN)
+    PageAllocation(void* base, size_t size, RChunk* chunk)
+        : m_base(base)
+        , m_size(size)
+        , m_chunk(chunk)
+    {
+    }
+#else
+    PageAllocation(void* base, size_t size)
+        : m_base(base)
+        , m_size(size)
+    {
+    }
+#endif
+
+    static PageAllocation systemAllocate(size_t, Usage, bool, bool);
+#if HAVE(PAGE_ALLOCATE_AT)
+    static PageAllocation systemAllocateAt(void*, bool, size_t, Usage, bool, bool);
+#endif
+#if HAVE(PAGE_ALLOCATE_ALIGNED)
+    static PageAllocation systemAllocateAligned(size_t, Usage);
+#endif
+    // systemDeallocate takes a parameter indicating whether memory is currently committed
+    // (this should always be true for PageAllocation, false for PageReservation).
+    void systemDeallocate(bool committed);
+    static size_t systemPageSize();
+
+    void* m_base;
+    size_t m_size;
+#if OS(SYMBIAN)
+    RChunk* m_chunk;
+#endif
+
+    static JS_EXPORTDATA size_t s_pageSize;
+};
+
+
+#if HAVE(MMAP)
+
+
+inline PageAllocation PageAllocation::systemAllocate(size_t size, Usage usage, bool writable, bool executable)
+{
+    return systemAllocateAt(0, false, size, usage, writable, executable);
+}
+
+inline PageAllocation PageAllocation::systemAllocateAt(void* address, bool fixed, size_t size, Usage usage, bool writable, bool executable)
+{
+    int protection = PROT_READ;
+    if (writable)
+        protection |= PROT_WRITE;
+    if (executable)
+        protection |= PROT_EXEC;
+
+    int flags = MAP_PRIVATE | MAP_ANON;
+    if (fixed)
+        flags |= MAP_FIXED;
+
+#if OS(DARWIN) && !defined(BUILDING_ON_TIGER)
+    int fd = usage;
+#else
+    int fd = -1;
+#endif
+
+    void* base = mmap(address, size, protection, flags, fd, 0);
+    if (base == MAP_FAILED)
+        base = 0;
+    return PageAllocation(base, size);
+}
+
+inline PageAllocation PageAllocation::systemAllocateAligned(size_t size, Usage usage)
+{
+#if OS(DARWIN)
+    vm_address_t address = 0;
+    int flags = VM_FLAGS_ANYWHERE;
+    if (usage != -1)
+        flags |= usage;
+    vm_map(current_task(), &address, size, (size - 1), flags, MEMORY_OBJECT_NULL, 0, FALSE, PROT_READ | PROT_WRITE, PROT_READ | PROT_WRITE | PROT_EXEC, VM_INHERIT_DEFAULT);
+    return PageAllocation(reinterpret_cast<void*>(address), size);
+#elif HAVE(POSIX_MEMALIGN)
+    void* address;
+    posix_memalign(&address, size, size);
+    return PageAllocation(address, size);
+#else
+    size_t extra = size - pageSize();
+
+    // Check for overflow.
+    if ((size + extra) < size)
+        return PageAllocation(0, size);
+
+#if OS(DARWIN) && !defined(BUILDING_ON_TIGER)
+    int fd = usage;
+#else
+    int fd = -1;
+#endif
+    void* mmapResult = mmap(0, size + extra, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, fd, 0);
+    if (mmapResult == MAP_FAILED)
+        return PageAllocation(0, size);
+    uintptr_t address = reinterpret_cast<uintptr_t>(mmapResult);
+
+    size_t adjust = 0;
+    if ((address & (size - 1)))
+        adjust = size - (address & (size - 1));
+    if (adjust > 0)
+        munmap(reinterpret_cast<char*>(address), adjust);
+    if (adjust < extra)
+        munmap(reinterpret_cast<char*>(address + adjust + size), extra - adjust);
+    address += adjust;
+
+    return PageAllocation(reinterpret_cast<void*>(address), size);
+#endif
+}
+
+inline void PageAllocation::systemDeallocate(bool)
+{
+    int result = munmap(m_base, m_size);
+    ASSERT_UNUSED(result, !result);
+    m_base = 0;
+}
+
+inline size_t PageAllocation::systemPageSize()
+{
+    return getpagesize();
+}
+
+
+#elif HAVE(VIRTUALALLOC)
+
+
+inline PageAllocation PageAllocation::systemAllocate(size_t size, Usage, bool writable, bool executable)
+{
+    DWORD protection = executable ?
+        (writable ? PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_READ) :
+        (writable ? PAGE_READWRITE : PAGE_READONLY);
+    return PageAllocation(VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, protection), size);
+}
+
+#if HAVE(ALIGNED_MALLOC)
+inline PageAllocation PageAllocation::systemAllocateAligned(size_t size, Usage usage)
+{
+#if COMPILER(MINGW) && !COMPILER(MINGW64)
+    void* address = __mingw_aligned_malloc(size, size);
+#else
+    void* address = _aligned_malloc(size, size);
+#endif
+    memset(address, 0, size);
+    return PageAllocation(address, size);
+}
+#endif
+
+inline void PageAllocation::systemDeallocate(bool committed)
+{
+#if OS(WINCE)
+    if (committed)
+        VirtualFree(m_base, m_size, MEM_DECOMMIT);
+#else
+    UNUSED_PARAM(committed);
+#endif
+    VirtualFree(m_base, 0, MEM_RELEASE); 
+    m_base = 0;
+}
+
+inline size_t PageAllocation::systemPageSize()
+{
+    static size_t size = 0;
+    SYSTEM_INFO system_info;
+    GetSystemInfo(&system_info);
+    size = system_info.dwPageSize;
+    return size;
+}
+
+
+#elif OS(SYMBIAN)
+
+
+inline PageAllocation PageAllocation::systemAllocate(size_t size, Usage usage, bool writable, bool executable)
+{
+    RChunk* rchunk = new RChunk();
+    if (executable)
+        rchunk->CreateLocalCode(size, size);
+    else
+        rchunk->CreateLocal(size, size);
+    return PageAllocation(rchunk->Base(), size, rchunk);
+}
+
+inline void PageAllocation::systemDeallocate(bool)
+{
+    m_chunk->Close();
+    delete m_chunk;
+    m_base = 0;
+}
+
+inline size_t PageAllocation::systemPageSize()
+{
+    static TInt page_size = 0;
+    UserHal::PageSizeInBytes(page_size);
+    return page_size;
+}
+
+
+#endif
+
+
+}
+
+using WTF::PageAllocation;
+
+#endif // PageAllocation_h