LCOV - app.info - js/src/yarr/OSAllocator.h

LCOV - code coverage report
| Current view: | directory - js/src/yarr - OSAllocator.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 7 | 7 | 100.0 %
| Date: | 2012-07-07 | Functions: | 2 | 2 | 100.0 %

           1                 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
           2                 :  * vim: set ts=8 sw=4 et tw=99 ft=cpp:
           3                 :  *
           4                 :  * ***** BEGIN LICENSE BLOCK *****
           5                 :  * Copyright (C) 2010 Apple Inc. All rights reserved.
           6                 :  *
           7                 :  * Redistribution and use in source and binary forms, with or without
           8                 :  * modification, are permitted provided that the following conditions
           9                 :  * are met:
          10                 :  * 1. Redistributions of source code must retain the above copyright
          11                 :  *    notice, this list of conditions and the following disclaimer.
          12                 :  * 2. Redistributions in binary form must reproduce the above copyright
          13                 :  *    notice, this list of conditions and the following disclaimer in the
          14                 :  *    documentation and/or other materials provided with the distribution.
          15                 :  *
          16                 :  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
          17                 :  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
          18                 :  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
          19                 :  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
          20                 :  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
          21                 :  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
          22                 :  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
          23                 :  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
          24                 :  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          25                 :  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
          26                 :  * THE POSSIBILITY OF SUCH DAMAGE.
          27                 :  *
          28                 :  * ***** END LICENSE BLOCK ***** */
          29                 :
          30                 : #ifndef OSAllocator_h
          31                 : #define OSAllocator_h
          32                 :
          33                 : #include <stdlib.h>
          34                 : #include "wtfbridge.h"
          35                 : #include "assembler/wtf/VMTags.h"
          36                 : #include "assembler/wtf/Assertions.h"
          37                 :
          38                 : namespace WTF {
          39                 :
          40                 : class OSAllocator {
          41                 : public:
          42                 :     enum Usage {
          43                 :         UnknownUsage = -1,
          44                 :         FastMallocPages = VM_TAG_FOR_TCMALLOC_MEMORY,
          45                 :         JSGCHeapPages = VM_TAG_FOR_COLLECTOR_MEMORY,
          46                 :         JSVMStackPages = VM_TAG_FOR_REGISTERFILE_MEMORY,
          47                 :         JSJITCodePages = VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY
          48                 :     };
          49                 :
          50                 :     // These methods are symmetric; reserveUncommitted allocates VM in an uncommitted state,
          51                 :     // releaseDecommitted should be called on a region of VM allocated by a single reservation,
          52                 :     // the memory must all currently be in a decommitted state.
          53                 :     static void* reserveUncommitted(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
          54                 :     static void releaseDecommitted(void*, size_t);
          55                 :
          56                 :     // These methods are symmetric; they commit or decommit a region of VM (uncommitted VM should
          57                 :     // never be accessed, since the OS may not have attached physical memory for these regions).
          58                 :     // Clients should only call commit on uncommitted regions and decommit on committed regions.
          59                 :     static void commit(void*, size_t, bool writable, bool executable);
          60                 :     static void decommit(void*, size_t);
          61                 :
          62                 :     // These methods are symmetric; reserveAndCommit allocates VM in an committed state,
          63                 :     // decommitAndRelease should be called on a region of VM allocated by a single reservation,
          64                 :     // the memory must all currently be in a committed state.
          65                 :     static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
          66                 :     static void decommitAndRelease(void* base, size_t size);
          67                 :
          68                 :     // These methods are akin to reserveAndCommit/decommitAndRelease, above - however rather than
          69                 :     // committing/decommitting the entire region additional parameters allow a subregion to be
          70                 :     // specified.
          71                 :     static void* reserveAndCommit(size_t reserveSize, size_t commitSize, Usage = UnknownUsage, bool writable = true, bool executable = false);
          72                 :     static void decommitAndRelease(void* releaseBase, size_t releaseSize, void* decommitBase, size_t decommitSize);
          73                 : };
          74                 :
          75                 : inline void* OSAllocator::reserveAndCommit(size_t reserveSize, size_t commitSize, Usage usage, bool writable, bool executable)
          76                 : {
          77                 :     void* base = reserveUncommitted(reserveSize, usage, writable, executable);
          78                 :     commit(base, commitSize, writable, executable);
          79                 :     return base;
          80                 : }
          81                 :
          82           31359 : inline void OSAllocator::decommitAndRelease(void* releaseBase, size_t releaseSize, void* decommitBase, size_t decommitSize)
          83                 : {
          84           31359 :     ASSERT(decommitBase >= releaseBase && (static_cast<char*>(decommitBase) + decommitSize) <= (static_cast<char*>(releaseBase) + releaseSize));
          85                 : #if WTF_OS_WINCE || WTF_OS_SYMBIAN
          86                 :     // On most platforms we can actually skip this final decommit; releasing the VM will
          87                 :     // implicitly decommit any physical memory in the region. This is not true on WINCE.
          88                 :     // On Symbian, this makes implementation simpler and better aligned with the RChunk API
          89                 :     decommit(decommitBase, decommitSize);
          90                 : #endif
          91           31359 :     releaseDecommitted(releaseBase, releaseSize);
          92           31359 : }
          93                 :
          94           31359 : inline void OSAllocator::decommitAndRelease(void* base, size_t size)
          95                 : {
          96           31359 :     decommitAndRelease(base, size, base, size);
          97           31359 : }
          98                 :
          99                 : } // namespace WTF
         100                 :
         101                 : using WTF::OSAllocator;
         102                 :
         103                 : #endif // OSAllocator_h

Generated by: LCOV version 1.7