00b5363b5d62de8811f6becc6483b991802f7fdc
[WebKit-https.git] / JavaScriptCore / wtf / PageAllocation.h
1 /*
2  * Copyright (C) 2010 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 PageAllocation_h
27 #define PageAllocation_h
28
29 #include <wtf/UnusedParam.h>
30 #include <wtf/VMTags.h>
31
32 #if OS(SYMBIAN)
33 #include <e32std.h>
34 #endif
35
36 #if HAVE(MMAP)
37 #define PAGE_ALLOCATION_ALLOCATE_AT 1
38 #else
39 #define PAGE_ALLOCATION_ALLOCATE_AT 0
40 #endif
41
42 namespace WTF {
43
44 class PageAllocation {
45 public:
46     enum Usage {
47         UnknownUsage = -1,
48         FastMallocPages = VM_TAG_FOR_TCMALLOC_MEMORY,
49         JSGCHeapPages = VM_TAG_FOR_COLLECTOR_MEMORY,
50         JSVMStackPages = VM_TAG_FOR_REGISTERFILE_MEMORY,
51         JSJITCodePages = VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY,
52     };
53
54     PageAllocation()
55         : m_base(0)
56         , m_size(0)
57 #if OS(SYMBIAN)
58         , m_chunk(0)
59 #endif
60     {
61     }
62
63     // Create a PageAllocation object representing a sub-region of an existing allocation;
64     // deallocate should never be called on an object represnting a subregion, only on the
65     // initial allocation.
66     PageAllocation(void* base, size_t size, const PageAllocation& parent)
67         : m_base(base)
68         , m_size(size)
69 #if OS(SYMBIAN)
70         , m_chunk(parent.chunk)
71 #endif
72     {
73 #if defined(NDEBUG) && !OS(SYMBIAN)
74         UNUSED_PARAM(parent);
75 #endif
76         ASSERT(base >= parent.m_base);
77         ASSERT(size <= parent.m_size);
78         ASSERT(static_cast<char*>(base) + size <= static_cast<char*>(parent.m_base) + parent.m_size);
79     }
80
81     void* base() const { return m_base; }
82     size_t size() const { return m_size; }
83
84     bool operator!() const { return !m_base; }
85
86     bool commit(void*, size_t, bool writable = true, bool executable = false) const;
87     void decommit(void*, size_t) const;
88     void deallocate();
89
90     static PageAllocation allocate(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
91     static PageAllocation reserve(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
92 #if PAGE_ALLOCATION_ALLOCATE_AT
93     static PageAllocation allocateAt(void* address, bool fixed, size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
94     static PageAllocation reserveAt(void* address, bool fixed, size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
95 #endif
96     static size_t pagesize();
97
98 private:
99 #if OS(SYMBIAN)
100     PageAllocation(void* base, size_t size, RChunk* chunk)
101         : m_base(base)
102         , m_size(size)
103         , m_chunk(chunk)
104     {
105     }
106 #else
107     PageAllocation(void* base, size_t size)
108         : m_base(base)
109         , m_size(size)
110     {
111     }
112 #endif
113
114     void* m_base;
115     size_t m_size;
116 #if OS(SYMBIAN)
117     RChunk* m_chunk;
118 #endif
119 };
120
121 }
122
123 using WTF::PageAllocation;
124
125 #endif // PageAllocation_h