LCOV - app.info - js/src/assembler/jit/ExecutableAllocatorPosix.cpp

LCOV - code coverage report
| Current view: | directory - js/src/assembler/jit - ExecutableAllocatorPosix.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 11 | 10 | 90.9 %
| Date: | 2012-06-02 | Functions: | 3 | 3 | 100.0 %

           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                 : #include "ExecutableAllocator.h"
          27                 :
          28                 : #if ENABLE_ASSEMBLER && WTF_OS_UNIX && !WTF_OS_SYMBIAN
          29                 :
          30                 : #include <sys/mman.h>
          31                 : #include <unistd.h>
          32                 : #include <wtf/VMTags.h>
          33                 :
          34                 : namespace JSC {
          35                 :
          36           11298 : size_t ExecutableAllocator::determinePageSize()
          37                 : {
          38           11298 :     return getpagesize();
          39                 : }
          40                 :
          41           19342 : ExecutablePool::Allocation ExecutableAllocator::systemAlloc(size_t n)
          42                 : {
          43           19342 :     void* allocation = mmap(NULL, n, INITIAL_PROTECTION_FLAGS, MAP_PRIVATE | MAP_ANON, VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY, 0);
          44           19342 :     if (allocation == MAP_FAILED)
          45               0 :         allocation = NULL;
          46           19342 :     ExecutablePool::Allocation alloc = { reinterpret_cast<char*>(allocation), n };
          47                 :     return alloc;
          48                 : }
          49                 :
          50           19341 : void ExecutableAllocator::systemRelease(const ExecutablePool::Allocation& alloc)
          51                 : {
          52           19341 :     int result = munmap(alloc.pages, alloc.size);
          53           19341 :     ASSERT_UNUSED(result, !result);
          54           19341 : }
          55                 :
          56                 : #if WTF_ENABLE_ASSEMBLER_WX_EXCLUSIVE
          57                 : void ExecutableAllocator::reprotectRegion(void* start, size_t size, ProtectionSetting setting)
          58                 : {
          59                 :     if (!pageSize)
          60                 :         intializePageSize();
          61                 :
          62                 :     // Calculate the start of the page containing this region,
          63                 :     // and account for this extra memory within size.
          64                 :     intptr_t startPtr = reinterpret_cast<intptr_t>(start);
          65                 :     intptr_t pageStartPtr = startPtr & ~(pageSize - 1);
          66                 :     void* pageStart = reinterpret_cast<void*>(pageStartPtr);
          67                 :     size += (startPtr - pageStartPtr);
          68                 :
          69                 :     // Round size up
          70                 :     size += (pageSize - 1);
          71                 :     size &= ~(pageSize - 1);
          72                 :
          73                 :     mprotect(pageStart, size, (setting == Writable) ? PROTECTION_FLAGS_RW : PROTECTION_FLAGS_RX);
          74                 : }
          75                 : #endif
          76                 :
          77                 : #if WTF_CPU_ARM_TRADITIONAL && WTF_OS_LINUX && WTF_COMPILER_RVCT
          78                 : __asm void ExecutableAllocator::cacheFlush(void* code, size_t size)
          79                 : {
          80                 :     ARM
          81                 :     push {r7}
          82                 :     add r1, r1, r0
          83                 :     mov r7, #0xf0000
          84                 :     add r7, r7, #0x2
          85                 :     mov r2, #0x0
          86                 :     svc #0x0
          87                 :     pop {r7}
          88                 :     bx lr
          89                 : }
          90                 : #endif
          91                 :
          92                 : }
          93                 :
          94                 : #endif // HAVE(ASSEMBLER)

Generated by: LCOV version 1.7