1 /* 2 * Copyright (C) 2008 Apple Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #ifndef ExecutableAllocator_h 27 #define ExecutableAllocator_h 28 29 #include <stddef.h> // for ptrdiff_t 30 #include <limits> 31 #include <wtf/Assertions.h> 32 #include <wtf/PassRefPtr.h> 33 #include <wtf/RefCounted.h> 34 #include <wtf/UnusedParam.h> 35 #include <wtf/Vector.h> 36 37 #if OS(IPHONE_OS) 38 #include <libkern/OSCacheControl.h> 39 #include <sys/mman.h> 40 #endif 41 42 #if OS(SYMBIAN) 43 #include <e32std.h> 44 #endif 45 46 #if OS(WINCE) 47 // From pkfuncs.h (private header file from the Platform Builder) 48 #define CACHE_SYNC_ALL 0x07F 49 extern "C" __declspec(dllimport) void CacheRangeFlush(LPVOID pAddr, DWORD dwLength, DWORD dwFlags); 50 #endif 51 52 #define JIT_ALLOCATOR_PAGE_SIZE (ExecutableAllocator::pageSize) 53 #define JIT_ALLOCATOR_LARGE_ALLOC_SIZE (ExecutableAllocator::pageSize * 4) 54 55 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE) 56 #define PROTECTION_FLAGS_RW (PROT_READ | PROT_WRITE) 57 #define PROTECTION_FLAGS_RX (PROT_READ | PROT_EXEC) 58 #define INITIAL_PROTECTION_FLAGS PROTECTION_FLAGS_RX 59 #else 60 #define INITIAL_PROTECTION_FLAGS (PROT_READ | PROT_WRITE | PROT_EXEC) 61 #endif 62 63 namespace JSC { 64 65 inline size_t roundUpAllocationSize(size_t request, size_t granularity) 66 { 67 if ((std::numeric_limits<size_t>::max() - granularity) <= request) 68 CRASH(); // Allocation is too large 69 70 // Round up to next page boundary 71 size_t size = request + (granularity - 1); 72 size = size & ~(granularity - 1); 73 ASSERT(size >= request); 74 return size; 75 } 76 77 } 78 79 #if ENABLE(ASSEMBLER) 80 81 namespace JSC { 82 83 class ExecutablePool : public RefCounted<ExecutablePool> { 84 private: 85 struct Allocation { 86 char* pages; 87 size_t size; 88 #if OS(SYMBIAN) 89 RChunk* chunk; 90 #endif 91 }; 92 typedef Vector<Allocation, 2> AllocationList; 93 94 public: 95 static PassRefPtr<ExecutablePool> create(size_t n) 96 { 97 return adoptRef(new ExecutablePool(n)); 98 } 99 100 void* alloc(size_t n) 101 { 102 ASSERT(m_freePtr <= m_end); 103 104 // Round 'n' up to a multiple of word size; if all allocations are of 105 // word sized quantities, then all subsequent allocations will be aligned. 106 n = roundUpAllocationSize(n, sizeof(void*)); 107 108 if (static_cast<ptrdiff_t>(n) < (m_end - m_freePtr)) { 109 void* result = m_freePtr; 110 m_freePtr += n; 111 return result; 112 } 113 114 // Insufficient space to allocate in the existing pool 115 // so we need allocate into a new pool 116 return poolAllocate(n); 117 } 118 119 ~ExecutablePool() 120 { 121 AllocationList::const_iterator end = m_pools.end(); 122 for (AllocationList::const_iterator ptr = m_pools.begin(); ptr != end; ++ptr) 123 ExecutablePool::systemRelease(*ptr); 124 } 125 126 size_t available() const { return (m_pools.size() > 1) ? 0 : m_end - m_freePtr; } 127 128 private: 129 static Allocation systemAlloc(size_t n); 130 static void systemRelease(const Allocation& alloc); 131 132 ExecutablePool(size_t n); 133 134 void* poolAllocate(size_t n); 135 136 char* m_freePtr; 137 char* m_end; 138 AllocationList m_pools; 139 }; 140 141 class ExecutableAllocator { 142 enum ProtectionSeting { Writable, Executable }; 143 144 public: 145 static size_t pageSize; 146 ExecutableAllocator() 147 { 148 if (!pageSize) 149 intializePageSize(); 150 m_smallAllocationPool = ExecutablePool::create(JIT_ALLOCATOR_LARGE_ALLOC_SIZE); 151 } 152 153 PassRefPtr<ExecutablePool> poolForSize(size_t n) 154 { 155 // Try to fit in the existing small allocator 156 if (n < m_smallAllocationPool->available()) 157 return m_smallAllocationPool; 158 159 // If the request is large, we just provide a unshared allocator 160 if (n > JIT_ALLOCATOR_LARGE_ALLOC_SIZE) 161 return ExecutablePool::create(n); 162 163 // Create a new allocator 164 RefPtr<ExecutablePool> pool = ExecutablePool::create(JIT_ALLOCATOR_LARGE_ALLOC_SIZE); 165 166 // If the new allocator will result in more free space than in 167 // the current small allocator, then we will use it instead 168 if ((pool->available() - n) > m_smallAllocationPool->available()) 169 m_smallAllocationPool = pool; 170 return pool.release(); 171 } 172 173 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE) 174 static void makeWritable(void* start, size_t size) 175 { 176 reprotectRegion(start, size, Writable); 177 } 178 179 static void makeExecutable(void* start, size_t size) 180 { 181 reprotectRegion(start, size, Executable); 182 } 183 #else 184 static void makeWritable(void*, size_t) {} 185 static void makeExecutable(void*, size_t) {} 186 #endif 187 188 189 #if CPU(X86) || CPU(X86_64) 190 static void cacheFlush(void*, size_t) 191 { 192 } 193 #elif CPU(ARM_THUMB2) && OS(IPHONE_OS) 194 static void cacheFlush(void* code, size_t size) 195 { 196 sys_dcache_flush(code, size); 197 sys_icache_invalidate(code, size); 198 } 199 #elif CPU(ARM_THUMB2) && OS(LINUX) 200 static void cacheFlush(void* code, size_t size) 201 { 202 asm volatile ( 203 "push {r7}\n" 204 "mov r0, %0\n" 205 "mov r1, %1\n" 206 "movw r7, #0x2\n" 207 "movt r7, #0xf\n" 208 "movs r2, #0x0\n" 209 "svc 0x0\n" 210 "pop {r7}\n" 211 : 212 : "r" (code), "r" (reinterpret_cast<char*>(code) + size) 213 : "r0", "r1", "r2"); 214 } 215 #elif OS(SYMBIAN) 216 static void cacheFlush(void* code, size_t size) 217 { 218 User::IMB_Range(code, static_cast<char*>(code) + size); 219 } 220 #elif CPU(ARM_TRADITIONAL) && OS(LINUX) 221 static void cacheFlush(void* code, size_t size) 222 { 223 asm volatile ( 224 "push {r7}\n" 225 "mov r0, %0\n" 226 "mov r1, %1\n" 227 "mov r7, #0xf0000\n" 228 "add r7, r7, #0x2\n" 229 "mov r2, #0x0\n" 230 "svc 0x0\n" 231 "pop {r7}\n" 232 : 233 : "r" (code), "r" (reinterpret_cast<char*>(code) + size) 234 : "r0", "r1", "r2"); 235 } 236 #elif OS(WINCE) 237 static void cacheFlush(void* code, size_t size) 238 { 239 CacheRangeFlush(code, size, CACHE_SYNC_ALL); 240 } 241 #else 242 #error "The cacheFlush support is missing on this platform." 243 #endif 244 245 private: 246 247 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE) 248 static void reprotectRegion(void*, size_t, ProtectionSeting); 249 #endif 250 251 RefPtr<ExecutablePool> m_smallAllocationPool; 252 static void intializePageSize(); 253 }; 254 255 inline ExecutablePool::ExecutablePool(size_t n) 256 { 257 size_t allocSize = roundUpAllocationSize(n, JIT_ALLOCATOR_PAGE_SIZE); 258 Allocation mem = systemAlloc(allocSize); 259 m_pools.append(mem); 260 m_freePtr = mem.pages; 261 if (!m_freePtr) 262 CRASH(); // Failed to allocate 263 m_end = m_freePtr + allocSize; 264 } 265 266 inline void* ExecutablePool::poolAllocate(size_t n) 267 { 268 size_t allocSize = roundUpAllocationSize(n, JIT_ALLOCATOR_PAGE_SIZE); 269 270 Allocation result = systemAlloc(allocSize); 271 if (!result.pages) 272 CRASH(); // Failed to allocate 273 274 ASSERT(m_end >= m_freePtr); 275 if ((allocSize - n) > static_cast<size_t>(m_end - m_freePtr)) { 276 // Replace allocation pool 277 m_freePtr = result.pages + n; 278 m_end = result.pages + allocSize; 279 } 280 281 m_pools.append(result); 282 return result.pages; 283 } 284 285 } 286 287 #endif // ENABLE(ASSEMBLER) 288 289 #endif // !defined(ExecutableAllocator) 290
