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