Initialize bmalloc::DebugHeap::m_pageSize for non-Darwin builds.
[WebKit-https.git] / Source / bmalloc / bmalloc / DebugHeap.cpp
1 /*
2  * Copyright (C) 2016-2018 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 "DebugHeap.h"
27
28 #include "Algorithm.h"
29 #include "BAssert.h"
30 #include "BPlatform.h"
31 #include "VMAllocate.h"
32 #include <cstdlib>
33 #include <thread>
34
35 namespace bmalloc {
36     
37 #if BOS(DARWIN)
38
39 DebugHeap::DebugHeap(std::lock_guard<Mutex>&)
40     : m_zone(malloc_create_zone(0, 0))
41     , m_pageSize(vmPageSize())
42 {
43     malloc_set_zone_name(m_zone, "WebKit Using System Malloc");
44 }
45
46 void* DebugHeap::malloc(size_t size)
47 {
48     void* result = malloc_zone_malloc(m_zone, size);
49     if (!result)
50         BCRASH();
51     return result;
52 }
53
54 void* DebugHeap::memalign(size_t alignment, size_t size, bool crashOnFailure)
55 {
56     void* result = malloc_zone_memalign(m_zone, alignment, size);
57     if (!result && crashOnFailure)
58         BCRASH();
59     return result;
60 }
61
62 void* DebugHeap::realloc(void* object, size_t size)
63 {
64     void* result = malloc_zone_realloc(m_zone, object, size);
65     if (!result)
66         BCRASH();
67     return result;
68 }
69
70 void DebugHeap::free(void* object)
71 {
72     malloc_zone_free(m_zone, object);
73 }
74
75 #else
76
77 DebugHeap::DebugHeap(std::lock_guard<Mutex>&)
78     : m_pageSize(vmPageSize())
79 {
80 }
81
82 void* DebugHeap::malloc(size_t size)
83 {
84     void* result = ::malloc(size);
85     if (!result)
86         BCRASH();
87     return result;
88 }
89
90 void* DebugHeap::memalign(size_t alignment, size_t size, bool crashOnFailure)
91 {
92     void* result;
93     if (posix_memalign(&result, alignment, size)) {
94         if (crashOnFailure)
95             BCRASH();
96         return nullptr;
97     }
98     return result;
99 }
100
101 void* DebugHeap::realloc(void* object, size_t size)
102 {
103     void* result = ::realloc(object, size);
104     if (!result)
105         BCRASH();
106     return result;
107 }
108
109 void DebugHeap::free(void* object)
110 {
111     ::free(object);
112 }
113     
114 #endif
115
116 // FIXME: This looks an awful lot like the code in wtf/Gigacage.cpp for large allocation.
117 // https://bugs.webkit.org/show_bug.cgi?id=175086
118
119 void* DebugHeap::memalignLarge(size_t alignment, size_t size)
120 {
121     alignment = roundUpToMultipleOf(m_pageSize, alignment);
122     size = roundUpToMultipleOf(m_pageSize, size);
123     void* result = tryVMAllocate(alignment, size);
124     if (!result)
125         return nullptr;
126     {
127         std::lock_guard<std::mutex> locker(m_lock);
128         m_sizeMap[result] = size;
129     }
130     return result;
131 }
132
133 void DebugHeap::freeLarge(void* base)
134 {
135     if (!base)
136         return;
137     
138     size_t size;
139     {
140         std::lock_guard<std::mutex> locker(m_lock);
141         size = m_sizeMap[base];
142         size_t numErased = m_sizeMap.erase(base);
143         RELEASE_BASSERT(numErased == 1);
144     }
145     
146     vmDeallocate(base, size);
147 }
148
149 } // namespace bmalloc