Enable ThinLTO support in Production builds
[WebKit-https.git] / Source / bmalloc / ChangeLog
1 2019-03-22  Keith Rollin  <krollin@apple.com>
2
3         Enable ThinLTO support in Production builds
4         https://bugs.webkit.org/show_bug.cgi?id=190758
5         <rdar://problem/45413233>
6
7         Reviewed by Daniel Bates.
8
9         Enable building with Thin LTO in Production when using Xcode 10.2 or
10         later. This change results in a 1.45% progression in PLT5. Full
11         Production build times increase about 2-3%. Incremental build times
12         are more severely affected, and so LTO is not enabled for local
13         engineering builds.
14
15         LTO is enabled only on macOS for now, until rdar://problem/49013399,
16         which affects ARM builds, is fixed.
17
18         To change the LTO setting when building locally:
19
20         - If building with `make`, specify WK_LTO_MODE={none,thin,full} on the
21           command line.
22         - If building with `build-webkit`, specify --lto-mode={none,thin,full}
23           on the command line.
24         - If building with `build-root`, specify --lto={none,thin,full} on the
25           command line.
26         - If building with Xcode, create a LocalOverrides.xcconfig file at the
27           top level of your repository directory (if needed) and define
28           WK_LTO_MODE to full, thin, or none.
29
30         * Configurations/Base.xcconfig:
31
32 2019-03-21  Michael Saboff  <msaboff@apple.com>
33
34         [BMalloc] No need to delay deallocating chunks based on recent use
35         https://bugs.webkit.org/show_bug.cgi?id=196121
36
37         Reviewed by Mark Lam.
38
39         The "used since last scavenge" logic is not needed for small chunks since their memory isn't decommitted directly.
40         We can deallocate small chunks immediately as that adds them to the LargeRange free list.  That free list employs the
41         "used since last scavenge" logic before the scavenger decommits the backing memory.
42
43         * bmalloc/Chunk.h:
44         (bmalloc::Chunk::usedSinceLastScavenge): Deleted.
45         (bmalloc::Chunk::clearUsedSinceLastScavenge): Deleted.
46         (bmalloc::Chunk::setUsedSinceLastScavenge): Deleted.
47         * bmalloc/Heap.cpp:
48         (bmalloc::Heap::scavenge):
49         (bmalloc::Heap::allocateSmallPage):
50
51 2019-03-21  Brady Eidson  <beidson@apple.com>
52
53         Certain WebProcesses should opt-out of the freezer.
54         <rdar://problem/42846139> and https://bugs.webkit.org/show_bug.cgi?id=196062
55
56         Reviewed by Andy Estes.
57
58         * bmalloc.xcodeproj/project.pbxproj:
59         * bmalloc/darwin/MemoryStatusSPI.h:
60
61 2019-03-19  Michael Catanzaro  <mcatanzaro@igalia.com>
62
63         Unreviewed, fix -Wformat warning
64         https://bugs.webkit.org/show_bug.cgi?id=195895
65         <rdar://problem/48517629>
66
67         * bmalloc/Scavenger.cpp:
68         (bmalloc::Scavenger::threadRunLoop):
69
70 2019-03-18  Michael Saboff  <msaboff@apple.com>
71
72         [BMalloc] Scavenger should react to recent memory activity
73         https://bugs.webkit.org/show_bug.cgi?id=195895
74
75         Reviewed by Geoffrey Garen.
76
77         This change adds a recently used bit to objects that are scavenged.  When an object is allocated, that bit is set.
78         When we scavenge, if the bit is set, we clear it.  If the bit was already clear, we decommit the object.  The timing
79         to scavenging has been changed as well.  We perform our first scavne almost immediately after bmalloc is initialized
80         (10ms later).  Subsequent scavenging is done as a multiple of the time it took to scavenge.  We bound this computed
81         time between a minimum and maximum.  Through empirical testing, the multiplier, minimum and maximum are
82         150x, 100ms and 10,000ms respectively.  For mini-mode, when the JIT is disabled, we use much more aggressive values of
83         50x, 25ms and 500ms.
84
85         Eliminated partial scavenging since this change allows for any scavenge to be partial or full based on recent use of
86         the objects on the various free lists.
87
88         * bmalloc/Chunk.h:
89         (bmalloc::Chunk::usedSinceLastScavenge):
90         (bmalloc::Chunk::clearUsedSinceLastScavenge):
91         (bmalloc::Chunk::setUsedSinceLastScavenge):
92         * bmalloc/Heap.cpp:
93         (bmalloc::Heap::scavenge):
94         (bmalloc::Heap::allocateSmallChunk):
95         (bmalloc::Heap::allocateSmallPage):
96         (bmalloc::Heap::splitAndAllocate):
97         (bmalloc::Heap::tryAllocateLarge):
98         (bmalloc::Heap::scavengeToHighWatermark): Deleted.
99         * bmalloc/Heap.h:
100         * bmalloc/IsoDirectory.h:
101         * bmalloc/IsoDirectoryInlines.h:
102         (bmalloc::passedNumPages>::takeFirstEligible):
103         (bmalloc::passedNumPages>::scavenge):
104         (bmalloc::passedNumPages>::scavengeToHighWatermark): Deleted.
105         * bmalloc/IsoHeapImpl.h:
106         * bmalloc/IsoHeapImplInlines.h:
107         (bmalloc::IsoHeapImpl<Config>::scavengeToHighWatermark): Deleted.
108         * bmalloc/LargeRange.h:
109         (bmalloc::LargeRange::LargeRange):
110         (bmalloc::LargeRange::usedSinceLastScavenge):
111         (bmalloc::LargeRange::clearUsedSinceLastScavenge):
112         (bmalloc::LargeRange::setUsedSinceLastScavenge):
113         (): Deleted.
114         * bmalloc/Scavenger.cpp:
115         (bmalloc::Scavenger::Scavenger):
116         (bmalloc::Scavenger::threadRunLoop):
117         (bmalloc::Scavenger::timeSinceLastPartialScavenge): Deleted.
118         (bmalloc::Scavenger::partialScavenge): Deleted.
119         * bmalloc/Scavenger.h:
120         * bmalloc/SmallPage.h:
121         (bmalloc::SmallPage::usedSinceLastScavenge):
122         (bmalloc::SmallPage::clearUsedSinceLastScavenge):
123         (bmalloc::SmallPage::setUsedSinceLastScavenge):
124
125 2019-03-14  Yusuke Suzuki  <ysuzuki@apple.com>
126
127         [bmalloc] Add StaticPerProcess for known types to save pages
128         https://bugs.webkit.org/show_bug.cgi?id=195691
129
130         Reviewed by Mark Lam.
131
132         As initial memory footprint of VM + JSGlobalObject becomes 488KB dirty size in fast malloc memory (w/ JSC_useJIT=0 and Malloc=1), pages for PerProcess is costly.
133         For example, under Malloc=1 mode, we still need to allocate PerProcess<DebugHeap> and PerProcess<Environment>. And sizeof(Environment) is only 1 (bool flag), and
134         sizeof(DebugHeap) is 120. But we are allocating 1 pages for them. Since page size in iOS is 16KB, this 121B consumes 16KB dirty memory, and it is not negligible
135         size if we keep in mind that the current fast malloc heap size is 488KB. Putting them into the __DATA section, close to the other mutable data, we can avoid allocating
136         this page.
137
138         This patch revives the SafePerProcess concept in r228107. We add "StaticPerProcess<T>", which allocates underlying storage statically in the __DATA section instead of
139         allocating it at runtime. And we use this StaticPerProcess<T> for types where (1) T is known a priori, and (2) sizeof(T) is not huge.
140
141         * bmalloc.xcodeproj/project.pbxproj:
142         * bmalloc/AllIsoHeaps.cpp:
143         * bmalloc/AllIsoHeaps.h:
144         * bmalloc/Allocator.cpp:
145         (bmalloc::Allocator::Allocator):
146         * bmalloc/Cache.cpp:
147         (bmalloc::Cache::Cache):
148         * bmalloc/CryptoRandom.cpp:
149         (bmalloc::cryptoRandom):
150         * bmalloc/Deallocator.cpp:
151         (bmalloc::Deallocator::Deallocator):
152         * bmalloc/DebugHeap.cpp:
153         * bmalloc/DebugHeap.h:
154         (bmalloc::DebugHeap::tryGet):
155         * bmalloc/Environment.cpp:
156         * bmalloc/Environment.h:
157         * bmalloc/Gigacage.cpp:
158         (Gigacage::Callback::Callback):
159         (Gigacage::Callback::function):
160         (bmalloc::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks):
161         (Gigacage::disablePrimitiveGigacage):
162         (Gigacage::addPrimitiveDisableCallback):
163         (Gigacage::removePrimitiveDisableCallback):
164         (Gigacage::shouldBeEnabled):
165         (Gigacage::bmalloc::Callback::Callback): Deleted.
166         (Gigacage::bmalloc::Callback::function): Deleted.
167         (Gigacage::bmalloc::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
168         * bmalloc/Heap.cpp:
169         (bmalloc::Heap::Heap):
170         (bmalloc::Heap::tryAllocateLarge):
171         * bmalloc/IsoDirectoryInlines.h:
172         (bmalloc::passedNumPages>::takeFirstEligible):
173         (bmalloc::passedNumPages>::didBecome):
174         * bmalloc/IsoHeapImpl.cpp:
175         (bmalloc::IsoHeapImplBase::addToAllIsoHeaps):
176         * bmalloc/IsoPage.cpp:
177         (bmalloc::IsoPageBase::allocatePageMemory):
178         * bmalloc/IsoTLS.cpp:
179         (bmalloc::IsoTLS::IsoTLS):
180         (bmalloc::IsoTLS::ensureEntries):
181         (bmalloc::IsoTLS::forEachEntry):
182         * bmalloc/IsoTLSEntry.cpp:
183         (bmalloc::IsoTLSEntry::IsoTLSEntry):
184         * bmalloc/IsoTLSInlines.h:
185         (bmalloc::IsoTLS::allocateSlow):
186         (bmalloc::IsoTLS::deallocateSlow):
187         * bmalloc/IsoTLSLayout.cpp:
188         * bmalloc/IsoTLSLayout.h:
189         * bmalloc/Scavenger.cpp:
190         (bmalloc::Scavenger::Scavenger):
191         (bmalloc::dumpStats):
192         (bmalloc::Scavenger::scavenge):
193         (bmalloc::Scavenger::partialScavenge):
194         (bmalloc::Scavenger::freeableMemory):
195         (bmalloc::Scavenger::footprint):
196         * bmalloc/Scavenger.h:
197         * bmalloc/StaticPerProcess.h: Added.
198         * bmalloc/VMHeap.cpp:
199         * bmalloc/VMHeap.h:
200         * bmalloc/Zone.h:
201         * bmalloc/bmalloc.cpp:
202         (bmalloc::api::scavenge):
203         (bmalloc::api::isEnabled):
204         (bmalloc::api::setScavengerThreadQOSClass):
205         (bmalloc::api::enableMiniMode):
206         * test/testbmalloc.cpp:
207         (assertEmptyPointerSet):
208         (assertHasObjects):
209         (assertHasOnlyObjects):
210         (assertClean):
211
212 2019-03-13  Yoshiaki Jitsukawa  <yoshiaki.jitsukawa@sony.com>
213
214         [bmalloc] Use MADV_FREE on FreeBSD
215         https://bugs.webkit.org/show_bug.cgi?id=195665
216
217         Reviewed by Geoffrey Garen.
218
219         * bmalloc/BPlatform.h:
220
221         Introduce BOS_FREEBSD, which is equivalent to WTF_OS_FREEBSD
222
223         * bmalloc/VMAllocate.h:
224         (bmalloc::vmDeallocatePhysicalPages):
225
226         Use MADV_FREE instead of MADV_DONTNEED if BOS(FREEBSD), since on FreeBSD,
227         unlike on Linux, MADV_DONTNEED doesn't let the OS discard the contents of
228         the pages.
229
230 2019-03-13  Sam Weinig  <sam@webkit.org>
231
232         Fix testbmalloc build
233         https://bugs.webkit.org/show_bug.cgi?id=195660
234
235         Reviewed by Geoffrey Garen.
236
237         * bmalloc.xcodeproj/project.pbxproj:
238         Link Foundation in when building testbmalloc. Since bmalloc requires Foundation, and is a static
239         library, all clients of bmalloc are required to link it themselves.
240         
241         * bmalloc/IsoPageInlines.h:
242         * bmalloc/StdLibExtras.h: Added.
243         (bmalloc::bitwise_cast):
244         Add bitwise_cast implementation, and use it in IsoPageInlines.h. It is a layering violation
245         to expect the one from WTF to be available, as seems to have been the case.
246
247 2019-03-12  Robin Morisset  <rmorisset@apple.com>
248
249         A lot more classes have padding that can be reduced by reordering their fields
250         https://bugs.webkit.org/show_bug.cgi?id=195579
251
252         Reviewed by Mark Lam.
253
254         * bmalloc/Heap.h:
255         * bmalloc/Scavenger.h:
256
257 2019-03-05  Yusuke Suzuki  <ysuzuki@apple.com>
258
259         [bmalloc] Bmalloc DebugHeap should have dump and scavenge features
260         https://bugs.webkit.org/show_bug.cgi?id=195305
261
262         Reviewed by Saam Barati.
263
264         As the same to bmalloc, bmalloc::DebugHeap should have scavenge feature to make it scavengable if we want.
265         We also add DebugHeap::dump feature which dumps system malloc data in the WebKit Malloc zone.
266
267         * bmalloc/DebugHeap.cpp:
268         (bmalloc::DebugHeap::scavenge):
269         (bmalloc::DebugHeap::dump):
270         * bmalloc/DebugHeap.h:
271         * bmalloc/bmalloc.cpp:
272         (bmalloc::api::scavenge):
273
274 2019-02-23  Keith Miller  <keith_miller@apple.com>
275
276         Add new mac target numbers
277         https://bugs.webkit.org/show_bug.cgi?id=194955
278
279         Reviewed by Tim Horton.
280
281         * Configurations/Base.xcconfig:
282         * Configurations/DebugRelease.xcconfig:
283
284 2019-02-19  Yusuke Suzuki  <ysuzuki@apple.com>
285
286         [bmalloc] bmalloc::Heap is allocated even though we use system malloc mode
287         https://bugs.webkit.org/show_bug.cgi?id=194836
288
289         Reviewed by Mark Lam.
290
291         Previously, bmalloc::Heap holds DebugHeap, and delegates allocation and deallocation to debug heap.
292         However, bmalloc::Heap is large. We would like to avoid initialization of bmalloc::Heap under the
293         system malloc mode.
294
295         This patch extracts out DebugHeap from bmalloc::Heap, and logically puts this in a boundary of
296         bmalloc::api. bmalloc::api delegates allocation and deallocation to DebugHeap if DebugHeap is enabled.
297         Otherwise, using bmalloc's usual mechanism. The challenge is that we would like to keep bmalloc fast
298         path fast.
299
300         1. For IsoHeaps, we use the similar techniques done in Cache. If the debug mode is enabled, we always go
301            to the slow path of the IsoHeap allocation, and keep IsoTLS::get() returning nullptr. In the slow path,
302            we just fallback to the usual bmalloc::api::tryMalloc implementation. This is efficient because bmalloc
303            continues using the fast path.
304
305         2. For the other APIs, like freeLargeVirtual, we just put DebugHeap check because this API itself takes fair
306            amount of time. Then debug heap check does not matter.
307
308         * bmalloc/Allocator.cpp:
309         (bmalloc::Allocator::reallocateImpl):
310         * bmalloc/Cache.cpp:
311         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
312         (bmalloc::Cache::allocateSlowCaseNullCache):
313         (bmalloc::Cache::deallocateSlowCaseNullCache):
314         (bmalloc::Cache::tryReallocateSlowCaseNullCache):
315         (bmalloc::Cache::reallocateSlowCaseNullCache):
316         (): Deleted.
317         (bmalloc::debugHeap): Deleted.
318         * bmalloc/DebugHeap.cpp:
319         * bmalloc/DebugHeap.h:
320         (bmalloc::DebugHeap::tryGet):
321         * bmalloc/Heap.cpp:
322         (bmalloc::Heap::Heap):
323         (bmalloc::Heap::footprint):
324         (bmalloc::Heap::tryAllocateLarge):
325         (bmalloc::Heap::deallocateLarge):
326         * bmalloc/Heap.h:
327         (bmalloc::Heap::debugHeap): Deleted.
328         * bmalloc/IsoTLS.cpp:
329         (bmalloc::IsoTLS::IsoTLS):
330         (bmalloc::IsoTLS::isUsingDebugHeap): Deleted.
331         (bmalloc::IsoTLS::debugMalloc): Deleted.
332         (bmalloc::IsoTLS::debugFree): Deleted.
333         * bmalloc/IsoTLS.h:
334         * bmalloc/IsoTLSInlines.h:
335         (bmalloc::IsoTLS::allocateSlow):
336         (bmalloc::IsoTLS::deallocateSlow):
337         * bmalloc/ObjectType.cpp:
338         (bmalloc::objectType):
339         * bmalloc/ObjectType.h:
340         * bmalloc/Scavenger.cpp:
341         (bmalloc::Scavenger::Scavenger):
342         * bmalloc/bmalloc.cpp:
343         (bmalloc::api::tryLargeZeroedMemalignVirtual):
344         (bmalloc::api::freeLargeVirtual):
345         (bmalloc::api::scavenge):
346         (bmalloc::api::isEnabled):
347         (bmalloc::api::setScavengerThreadQOSClass):
348         (bmalloc::api::commitAlignedPhysical):
349         (bmalloc::api::decommitAlignedPhysical):
350         (bmalloc::api::enableMiniMode):
351
352 2019-02-20  Andy Estes  <aestes@apple.com>
353
354         [Xcode] Add SDKVariant.xcconfig to various Xcode projects
355         https://bugs.webkit.org/show_bug.cgi?id=194869
356
357         Rubber-stamped by Jer Noble.
358
359         * bmalloc.xcodeproj/project.pbxproj:
360
361 2019-02-20  Yusuke Suzuki  <ysuzuki@apple.com>
362
363         [bmalloc] DebugHeap::malloc does not have "try" version.
364         https://bugs.webkit.org/show_bug.cgi?id=194837
365
366         Reviewed by Mark Lam.
367
368         Since DebugHeap::malloc does not have "try" version, our tryAllocate implementation does not work well with DebugHeap.
369         This patch adds crashOnFailure flag to DebugHeap::malloc.
370
371         * bmalloc/Cache.cpp:
372         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
373         (bmalloc::Cache::allocateSlowCaseNullCache):
374         * bmalloc/DebugHeap.cpp:
375         (bmalloc::DebugHeap::malloc):
376         * bmalloc/DebugHeap.h:
377         * bmalloc/IsoTLS.cpp:
378         (bmalloc::IsoTLS::debugMalloc):
379
380 2019-02-20  Yusuke Suzuki  <ysuzuki@apple.com>
381
382         [bmalloc] bmalloc::Cache should not be instantiated if we are using system malloc
383         https://bugs.webkit.org/show_bug.cgi?id=194811
384
385         Reviewed by Mark Lam.
386
387         bmalloc::Cache is very large. It is 13KB. Since it exists per HeapKind, it takes 40KB.
388         But this is meaningless if we are under the system malloc mode by using "Malloc=1". We
389         found that it continues using so much dirty memory region even under the system malloc mode.
390         This patch avoids instantiation of bmalloc::Cache under the system malloc mode.
391
392         * bmalloc/Allocator.cpp:
393         (bmalloc::Allocator::Allocator):
394         (bmalloc::Allocator::tryAllocate):
395         (bmalloc::Allocator::allocateImpl):
396         (bmalloc::Allocator::reallocateImpl):
397         (bmalloc::Allocator::allocateSlowCase):
398         Allocator is a per Cache object. So we no longer need to keep m_debugHeap. If debug heap is enabled,
399         Allocator is never created.
400
401         * bmalloc/Allocator.h:
402         * bmalloc/Cache.cpp:
403         (bmalloc::debugHeap):
404         (bmalloc::Cache::Cache):
405         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
406         (bmalloc::Cache::allocateSlowCaseNullCache):
407         (bmalloc::Cache::deallocateSlowCaseNullCache):
408         (bmalloc::Cache::tryReallocateSlowCaseNullCache):
409         (bmalloc::Cache::reallocateSlowCaseNullCache):
410         * bmalloc/Cache.h:
411         (bmalloc::Cache::tryAllocate):
412         (bmalloc::Cache::tryReallocate):
413         If the debug heap mode is enabled, we keep Cache::getFast() returning nullptr. And in the slow path case, we use debugHeap.
414         This makes bmalloc fast path fast, while we avoid Cache instantiation.
415
416         * bmalloc/Deallocator.cpp:
417         (bmalloc::Deallocator::Deallocator):
418         (bmalloc::Deallocator::scavenge):
419         (bmalloc::Deallocator::deallocateSlowCase):
420         * bmalloc/Deallocator.h:
421         Ditto for Deallocator.
422
423         * bmalloc/bmalloc.cpp:
424         (bmalloc::api::isEnabled):
425         We used `getFastCase()` for Heap. But it is basically wrong since we do not have any guarantee that someone already initializes
426         Heap when this is called. Previously, luckily, Cache is initialized, and Cache initialized Heap. But Cache initialization is removed
427         for system malloc mode and now PerProcess<PerHeapKind<Heap>>::getFastCase() returns nullptr at an early phase. This patch just uses
428         Environment::isDebugHeapEnabled() instead.
429
430 2019-02-20  Commit Queue  <commit-queue@webkit.org>
431
432         Unreviewed, rolling out r241789.
433         https://bugs.webkit.org/show_bug.cgi?id=194856
434
435         GuardMalloc crashes (Requested by yusukesuzuki on #webkit).
436
437         Reverted changeset:
438
439         "[bmalloc] bmalloc::Cache should not be instantiated if we are
440         using system malloc"
441         https://bugs.webkit.org/show_bug.cgi?id=194811
442         https://trac.webkit.org/changeset/241789
443
444 2019-02-19  Yusuke Suzuki  <ysuzuki@apple.com>
445
446         [bmalloc] bmalloc::Cache should not be instantiated if we are using system malloc
447         https://bugs.webkit.org/show_bug.cgi?id=194811
448
449         Reviewed by Mark Lam.
450
451         bmalloc::Cache is very large. It is 13KB. Since it exists per HeapKind, it takes 40KB.
452         But this is meaningless if we are under the system malloc mode by using "Malloc=1". We
453         found that it continues using so much dirty memory region even under the system malloc mode.
454         This patch avoids instantiation of bmalloc::Cache under the system malloc mode.
455
456         * bmalloc/Allocator.cpp:
457         (bmalloc::Allocator::Allocator):
458         (bmalloc::Allocator::tryAllocate):
459         (bmalloc::Allocator::allocateImpl):
460         (bmalloc::Allocator::reallocateImpl):
461         (bmalloc::Allocator::allocateSlowCase):
462         Allocator is a per Cache object. So we no longer need to keep m_debugHeap. If debug heap is enabled,
463         Allocator is never created.
464
465         * bmalloc/Allocator.h:
466         * bmalloc/Cache.cpp:
467         (bmalloc::debugHeap):
468         (bmalloc::Cache::Cache):
469         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
470         (bmalloc::Cache::allocateSlowCaseNullCache):
471         (bmalloc::Cache::deallocateSlowCaseNullCache):
472         (bmalloc::Cache::tryReallocateSlowCaseNullCache):
473         (bmalloc::Cache::reallocateSlowCaseNullCache):
474         * bmalloc/Cache.h:
475         (bmalloc::Cache::tryAllocate):
476         (bmalloc::Cache::tryReallocate):
477         If the debug heap mode is enabled, we keep Cache::getFast() returning nullptr. And in the slow path case, we use debugHeap.
478         This makes bmalloc fast path fast, while we avoid Cache instantiation.
479
480         * bmalloc/Deallocator.cpp:
481         (bmalloc::Deallocator::Deallocator):
482         (bmalloc::Deallocator::scavenge):
483         (bmalloc::Deallocator::deallocateSlowCase):
484         * bmalloc/Deallocator.h:
485         Ditto for Deallocator.
486
487 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
488
489         [bmalloc] NSBundle-based application name check should be executed after debug-heap environment variable check
490         https://bugs.webkit.org/show_bug.cgi?id=194694
491
492         Reviewed by Mark Lam.
493
494         Interestingly, NSBundle allocates fair amount of memory and keeps it for a process-long time. For example, it
495         allocates global NSConcreteHashTable, which takes 2.5KB. This patch changes the order of gigacage-check, we
496         first check "Malloc=1" status, and then check the process name through NSBundle. This allows us to remove NSBundle
497         related allocation in JSC initialization in the system malloc mode.
498
499         * bmalloc/Gigacage.cpp:
500         (Gigacage::shouldBeEnabled):
501
502 2019-02-15  Yusuke Suzuki  <ysuzuki@apple.com>
503
504         [bmalloc] Do not start scavenger thread if we use system malloc
505         https://bugs.webkit.org/show_bug.cgi?id=194674
506
507         Reviewed by Mark Lam.
508
509         We always start the scavenger thread even if system malloc is used by the environment variable like "Malloc=1".
510         Because bmalloc allocation goes to the system malloc if "Malloc=1" is set, we do not need to scavenge. This patch
511         changes it not to start the scavenger thread.
512
513         * bmalloc/Scavenger.cpp:
514         (bmalloc::Scavenger::Scavenger):
515
516 2019-02-12  Commit Queue  <commit-queue@webkit.org>
517
518         Unreviewed, rolling out r241182.
519         https://bugs.webkit.org/show_bug.cgi?id=194547
520
521         causes a 2-3% Speedometer2 regression. (Requested by
522         keith_miller on #webkit).
523
524         Reverted changeset:
525
526         "bmalloc uses more memory on iOS compared to macOS due to
527         physical page size differences"
528         https://bugs.webkit.org/show_bug.cgi?id=192389
529         https://trac.webkit.org/changeset/241182
530
531 2019-02-07  Michael Saboff  <msaboff@apple.com>
532
533         bmalloc uses more memory on iOS compared to macOS due to physical page size differences
534         https://bugs.webkit.org/show_bug.cgi?id=192389
535
536         Reviewed by Geoffrey Garen.
537
538         Changed small line allocations to be in smallPageSize "virtual page" multiples instead of physical
539         page size increments for sizes less that the physical page size.  This required changing the small
540         page commit / decommit code to work in full physical page increments.  For page classes that are
541         physical page size and larger, there isn't any functional change.
542
543         When scavenging page classes smaller than the physical page size, we need to consider whether or
544         not the adjacent small pages on the same physical page are also free before decommiting that
545         containing page.  When we need to commit more memory, we commit the whole page, and add any
546         adjacent virtual pages that were fully committed as well.
547
548         * bmalloc/Chunk.h:
549         (bmalloc::forEachPage):
550         * bmalloc/Heap.cpp:
551         (bmalloc::Heap::initializeLineMetadata):
552         (bmalloc::Heap::initializePageMetadata):
553         (bmalloc::Heap::scavenge):
554         (bmalloc::__attribute__):
555         (bmalloc::Heap::commitSmallPagesInPhysicalPage):
556         (bmalloc::Heap::allocateSmallPage):
557         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
558         * bmalloc/Heap.h:
559         * bmalloc/SmallPage.h:
560         (bmalloc::SmallPage::refCount):
561
562 2019-01-18  Keith Miller  <keith_miller@apple.com>
563
564         gigacage slide should randomize both start and end
565         https://bugs.webkit.org/show_bug.cgi?id=193601
566
567         Reviewed by Yusuke Suzuki.
568
569         This patch makes it so that the gigacade slide has an arbitrary
570         distance from the end as well as the start. This is done by
571         picking a random size then based on that size picking an random
572         starting offset.
573
574         * bmalloc/Gigacage.h:
575         * bmalloc/Heap.cpp:
576         (bmalloc::Heap::Heap):
577
578 2019-01-18  Jer Noble  <jer.noble@apple.com>
579
580         SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
581         https://bugs.webkit.org/show_bug.cgi?id=189553
582
583         Reviewed by Tim Horton.
584
585         * Configurations/Base.xcconfig:
586         * Configurations/SDKVariant.xcconfig: Added.
587
588 2019-01-18  Keith Miller  <keith_miller@apple.com>
589
590         Gigacages should start allocations from a slide
591         https://bugs.webkit.org/show_bug.cgi?id=193523
592
593         Reviewed by Mark Lam.
594
595         This patch makes it so that Gigacage Heaps slide the start of the
596         cage by some random amount. We still ensure that there is always
597         at least 4/2GB, on MacOS/iOS respectively, of VA space available
598         for allocation.
599
600         Also, this patch changes some macros into constants since macros
601         are the devil.
602
603         * bmalloc/Gigacage.cpp:
604         (Gigacage::bmalloc::protectGigacageBasePtrs):
605         (Gigacage::bmalloc::unprotectGigacageBasePtrs):
606         (Gigacage::bmalloc::runwaySize):
607         (Gigacage::ensureGigacage):
608         (Gigacage::shouldBeEnabled):
609         * bmalloc/Gigacage.h:
610         (Gigacage::name):
611         (Gigacage::gigacageSizeToMask):
612         (Gigacage::size):
613         (Gigacage::mask):
614         (Gigacage::basePtr):
615         (Gigacage::ensureGigacage):
616         (Gigacage::wasEnabled):
617         (Gigacage::isCaged):
618         (Gigacage::isEnabled):
619         (Gigacage::caged):
620         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
621         (Gigacage::canPrimitiveGigacageBeDisabled):
622         (Gigacage::disablePrimitiveGigacage):
623         (Gigacage::addPrimitiveDisableCallback):
624         (Gigacage::removePrimitiveDisableCallback):
625         * bmalloc/Heap.cpp:
626         (bmalloc::Heap::Heap):
627         * bmalloc/Sizes.h:
628         (bmalloc::Sizes::maskSizeClass):
629         (bmalloc::Sizes::maskObjectSize):
630         (bmalloc::Sizes::logSizeClass):
631         (bmalloc::Sizes::logObjectSize):
632         (bmalloc::Sizes::sizeClass):
633         (bmalloc::Sizes::objectSize):
634         (bmalloc::Sizes::pageSize):
635
636 2019-01-18  Matt Lewis  <jlewis3@apple.com>
637
638         Unreviewed, rolling out r240160.
639
640         This broke multiple internal builds.
641
642         Reverted changeset:
643
644         "Gigacages should start allocations from a slide"
645         https://bugs.webkit.org/show_bug.cgi?id=193523
646         https://trac.webkit.org/changeset/240160
647
648 2019-01-18  Keith Miller  <keith_miller@apple.com>
649
650         Gigacages should start allocations from a slide
651         https://bugs.webkit.org/show_bug.cgi?id=193523
652
653         Reviewed by Mark Lam.
654
655         This patch makes it so that Gigacage Heaps slide the start of the
656         cage by some random amount. We still ensure that there is always
657         at least 4/2GB, on MacOS/iOS respectively, of VA space available
658         for allocation.
659
660         Also, this patch changes some macros into constants since macros
661         are the devil.
662
663         * bmalloc/Gigacage.cpp:
664         (Gigacage::bmalloc::protectGigacageBasePtrs):
665         (Gigacage::bmalloc::unprotectGigacageBasePtrs):
666         (Gigacage::bmalloc::runwaySize):
667         (Gigacage::ensureGigacage):
668         (Gigacage::shouldBeEnabled):
669         * bmalloc/Gigacage.h:
670         (Gigacage::name):
671         (Gigacage::gigacageSizeToMask):
672         (Gigacage::size):
673         (Gigacage::mask):
674         (Gigacage::basePtr):
675         (Gigacage::ensureGigacage):
676         (Gigacage::wasEnabled):
677         (Gigacage::isCaged):
678         (Gigacage::caged):
679         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
680         (Gigacage::disablePrimitiveGigacage):
681         (Gigacage::addPrimitiveDisableCallback):
682         (Gigacage::removePrimitiveDisableCallback):
683         * bmalloc/Heap.cpp:
684         (bmalloc::Heap::Heap):
685         * bmalloc/Sizes.h:
686         (bmalloc::Sizes::maskSizeClass):
687         (bmalloc::Sizes::maskObjectSize):
688         (bmalloc::Sizes::logSizeClass):
689         (bmalloc::Sizes::logObjectSize):
690         (bmalloc::Sizes::sizeClass):
691         (bmalloc::Sizes::objectSize):
692         (bmalloc::Sizes::pageSize):
693
694 2019-01-17  Truitt Savell  <tsavell@apple.com>
695
696         Unreviewed, rolling out r240124.
697
698         This commit broke an internal build.
699
700         Reverted changeset:
701
702         "SDK_VARIANT build destinations should be separate from non-
703         SDK_VARIANT builds"
704         https://bugs.webkit.org/show_bug.cgi?id=189553
705         https://trac.webkit.org/changeset/240124
706
707 2019-01-17  Jer Noble  <jer.noble@apple.com>
708
709         SDK_VARIANT build destinations should be separate from non-SDK_VARIANT builds
710         https://bugs.webkit.org/show_bug.cgi?id=189553
711
712         Reviewed by Tim Horton.
713
714         * Configurations/Base.xcconfig:
715         * Configurations/SDKVariant.xcconfig: Added.
716
717 2019-01-16  Keith Miller  <keith_miller@apple.com>
718
719         bmalloc should use JSC VM tag for gigacage
720         https://bugs.webkit.org/show_bug.cgi?id=193496
721
722         Reviewed by Mark Lam.
723
724         This patch moves the VMTag info from WTF to bmalloc so that we can
725         tag gigacage memory with the unused JSC memory tag. The JSC memory
726         tag was previously used for wasm but since wasm is now allocated
727         out of the primitive cage it was unused.
728
729         * bmalloc.xcodeproj/project.pbxproj:
730         * bmalloc/BVMTags.h: Copied from Source/WTF/wtf/VMTags.h.
731         * bmalloc/Gigacage.cpp:
732         (Gigacage::ensureGigacage):
733         * bmalloc/VMAllocate.h:
734         (bmalloc::tryVMAllocate):
735         (bmalloc::vmZeroAndPurge):
736
737 2019-01-09  Mark Lam  <mark.lam@apple.com>
738
739         Gigacage disabling checks should handle the GIGACAGE_ALLOCATION_CAN_FAIL case properly.
740         https://bugs.webkit.org/show_bug.cgi?id=193292
741         <rdar://problem/46485450>
742
743         Reviewed by Yusuke Suzuki.
744
745         Previously, when GIGACAGE_ALLOCATION_CAN_FAIL is true, we allow the Gigacage to
746         be disabled if we fail to allocate memory for it.  However, Gigacage::primitiveGigacageDisabled()
747         still always assumes that the Gigacage is always enabled after ensureGigacage() is
748         called.
749
750         This patch updates Gigacage::primitiveGigacageDisabled() to allow the Gigacage to
751         already be disabled if GIGACAGE_ALLOCATION_CAN_FAIL is true and wasEnabled() is
752         false.
753
754         In this patch, we also put the wasEnabled flag in the 0th slot of the
755         g_gigacageBasePtrs buffer to ensure that it is also protected against writes just
756         like the Gigacage base pointers.
757
758         To achieve this, we do the following:
759         1. Added a reservedForFlags field in struct BasePtrs.
760         2. Added a ReservedForFlagsAndNotABasePtr Gigacage::Kind.
761         3. Added assertions to ensure that the BasePtrs::primitive is at the offset
762            matching the offset computed from Gigacage::Primitive.  Ditto for
763            BasePtrs::jsValue and Gigacage::JSValue.
764         4. Added assertions to ensure that Gigacage::ReservedForFlagsAndNotABasePtr is not
765            used for fetching a Gigacage base pointer.
766         5. Added RELEASE_BASSERT_NOT_REACHED() to implement such assertions in bmalloc.
767
768         No test added because this issue requires Gigacage allocation to fail in order to
769         manifest.  I've tested it manually by modifying the code locally to force an
770         allocation failure.
771
772         * bmalloc/BAssert.h:
773         * bmalloc/Gigacage.cpp:
774         (Gigacage::ensureGigacage):
775         (Gigacage::primitiveGigacageDisabled):
776         * bmalloc/Gigacage.h:
777         (Gigacage::wasEnabled):
778         (Gigacage::setWasEnabled):
779         (Gigacage::name):
780         (Gigacage::basePtr):
781         (Gigacage::size):
782         * bmalloc/HeapKind.h:
783         (bmalloc::heapKind):
784
785 2018-12-15  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
786
787         Unreviewed, suppress warnings in Linux
788
789         * bmalloc/Gigacage.cpp:
790
791 2018-12-14  Keith Miller  <keith_miller@apple.com>
792
793         Gigacage runway should immediately follow the primitive cage
794         https://bugs.webkit.org/show_bug.cgi?id=192733
795
796         Reviewed by Saam Barati.
797
798         This patch makes sure that the Gigacage runway is always
799         immediately after the primitive cage. Since writing outside the
800         primitive gigacage is likely to be more dangerous than the JSValue
801         cage. The ordering of the cages is still random however.
802
803         * bmalloc/Gigacage.cpp:
804         (Gigacage::ensureGigacage):
805
806 2018-12-13  Mark Lam  <mark.lam@apple.com>
807
808         Verify that tryLargeZeroedMemalignVirtual()'s aligned size and alignment values are valid.
809         https://bugs.webkit.org/show_bug.cgi?id=192682
810         <rdar://problem/37751522>
811
812         Reviewed by Saam Barati.
813
814         * bmalloc/bmalloc.cpp:
815         (bmalloc::api::tryLargeZeroedMemalignVirtual):
816
817 2018-11-21  Dominik Infuehr  <dinfuehr@igalia.com>
818
819         Enable JIT on ARM/Linux
820         https://bugs.webkit.org/show_bug.cgi?id=191548
821
822         Reviewed by Yusuke Suzuki.
823
824         * bmalloc/IsoPageInlines.h:
825         (bmalloc::IsoPage<Config>::startAllocating):
826
827 2018-11-01  Jiewen Tan  <jiewen_tan@apple.com>
828
829         Replace CommonRandom SPI with API
830         https://bugs.webkit.org/show_bug.cgi?id=191178
831         <rdar://problem/45722391>
832
833         Reviewed by Brent Fulgham.
834
835         * bmalloc/CryptoRandom.cpp:
836         (bmalloc::ARC4RandomNumberGenerator::stir):
837
838 2018-10-29  Mark Lam  <mark.lam@apple.com>
839
840         Correctly detect string overflow when using the 'Function' constructor.
841         https://bugs.webkit.org/show_bug.cgi?id=184883
842         <rdar://problem/36320331>
843
844         Reviewed by Saam Barati.
845
846         * bmalloc/Allocator.cpp:
847         (bmalloc::Allocator::reallocate):
848         (bmalloc::Allocator::tryReallocate):
849         (bmalloc::Allocator::reallocateImpl):
850         * bmalloc/Allocator.h:
851         * bmalloc/Cache.h:
852         (bmalloc::Cache::tryReallocate):
853         * bmalloc/DebugHeap.cpp:
854         (bmalloc::DebugHeap::realloc):
855         * bmalloc/DebugHeap.h:
856         * bmalloc/bmalloc.h:
857         (bmalloc::api::tryRealloc):
858
859 2018-10-25  Ross Kirsling  <ross.kirsling@sony.com>
860
861         Cleanup: inline constexpr is redundant as constexpr implies inline
862         https://bugs.webkit.org/show_bug.cgi?id=190819
863
864         Reviewed by Mark Lam.
865
866         * bmalloc/Algorithm.h:
867         (bmalloc::max):
868         (bmalloc::min):
869         (bmalloc::mask):
870         (bmalloc::test):
871         (bmalloc::isPowerOfTwo):
872         (bmalloc::roundDownToMultipleOf):
873         (bmalloc::sizeOf):
874         (bmalloc::bitCount):
875         (bmalloc::log2):
876         * bmalloc/Bits.h:
877         (bmalloc::bitsArrayLength):
878         * bmalloc/Sizes.h:
879         (bmalloc::Sizes::maskSizeClass):
880
881 2018-10-24  Alexey Proskuryakov  <ap@apple.com>
882
883         Add BPLATFORM(IOS_FAMILY)
884         https://bugs.webkit.org/show_bug.cgi?id=190878
885
886         Reviewed by Saam Barati.
887
888         * bmalloc/AvailableMemory.cpp:
889         (bmalloc::memorySizeAccordingToKernel):
890         (bmalloc::computeAvailableMemory):
891         * bmalloc/AvailableMemory.h:
892         (bmalloc::isUnderMemoryPressure):
893         * bmalloc/BPlatform.h:
894         * bmalloc/Gigacage.h:
895         * bmalloc/Logging.cpp:
896         (bmalloc::logVMFailure):
897         * bmalloc/VMAllocate.h:
898         (bmalloc::vmPageSizePhysical):
899         * bmalloc/bmalloc.h:
900         * bmalloc/darwin/MemoryStatusSPI.h:
901
902 2018-10-12  Ryan Haddad  <ryanhaddad@apple.com>
903
904         Unreviewed, rolling out r237063.
905
906         Caused layout test fast/dom/Window/window-postmessage-clone-
907         deep-array.html to fail on macOS and iOS Debug bots.
908
909         Reverted changeset:
910
911         "[JSC] Remove gcc warnings on mips and armv7"
912         https://bugs.webkit.org/show_bug.cgi?id=188598
913         https://trac.webkit.org/changeset/237063
914
915 2018-10-11  Guillaume Emont  <guijemont@igalia.com>
916
917         [JSC] Remove gcc warnings on mips and armv7
918         https://bugs.webkit.org/show_bug.cgi?id=188598
919
920         Reviewed by Mark Lam.
921
922         Add bitwise_cast (from WTF) and use it instead of reinterpret_cast in
923         a couple places where reinterpret_cast triggers a warning about
924         alignment even though we know that alignment is correct.
925
926         * bmalloc/Algorithm.h:
927         (bmalloc::bitwise_cast): Copied from WTF/wtf/StdLibextras.h
928         * bmalloc/IsoDirectoryPageInlines.h:
929         (bmalloc::IsoDirectoryPage<Config>::pageFor):
930         * bmalloc/IsoPageInlines.h:
931         (bmalloc::IsoPage<Config>::startAllocating):
932
933 2018-10-03  Dan Bernstein  <mitz@apple.com>
934
935         bmalloc part of [Xcode] Update some build settings as recommended by Xcode 10
936         https://bugs.webkit.org/show_bug.cgi?id=190250
937
938         Reviewed by Alex Christensen.
939
940         * Configurations/Base.xcconfig: Enabled CLANG_WARN_COMMA, CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS,
941           and CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF.
942
943         * bmalloc.xcodeproj/project.pbxproj: Let Xcode update LastUpgradeCheck.
944
945 2018-09-25  Alex Christensen  <achristensen@webkit.org>
946
947         Allow for suffixes to com.apple.WebKit.WebContent
948         https://bugs.webkit.org/show_bug.cgi?id=189972
949
950         Reviewed by Chris Dumez.
951
952         * bmalloc/ProcessCheck.mm:
953         (bmalloc::gigacageEnabledForProcess):
954
955 2018-09-24  Fujii Hironori  <Hironori.Fujii@sony.com>
956
957         Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
958         https://bugs.webkit.org/show_bug.cgi?id=189733
959
960         Reviewed by Michael Catanzaro.
961
962         * bmalloc/BCompiler.h:
963
964 2018-08-27  Keith Rollin  <krollin@apple.com>
965
966         Unreviewed build fix -- disable LTO for production builds
967
968         * Configurations/Base.xcconfig:
969
970 2018-08-27  Keith Rollin  <krollin@apple.com>
971
972         Build system support for LTO
973         https://bugs.webkit.org/show_bug.cgi?id=187785
974         <rdar://problem/42353132>
975
976         Reviewed by Dan Bernstein.
977
978         Update Base.xcconfig and DebugRelease.xcconfig to optionally enable
979         LTO.
980
981         * Configurations/Base.xcconfig:
982         * Configurations/DebugRelease.xcconfig:
983
984 2018-08-16  Tomas Popela  <tpopela@redhat.com>
985
986         bmalloc: Coverity scan issues
987         https://bugs.webkit.org/show_bug.cgi?id=186763
988
989         Reviewed by Saam Barati.
990
991         * bmalloc/DebugHeap.h: Initialize the m_pageSize variable.
992         * bmalloc/IsoTLS.cpp:
993         (bmalloc::IsoTLS::ensureEntries): Check the return value of
994         pthread_key_create return().
995         * bmalloc/VMAllocate.h:
996         (bmalloc::vmPageSize): Correctly check the return value of sysconf().
997
998 2018-07-27  Mark Lam  <mark.lam@apple.com>
999
1000         Initialize bmalloc::DebugHeap::m_pageSize for non-Darwin builds.
1001         https://bugs.webkit.org/show_bug.cgi?id=188132
1002         <rdar://problem/40401599>
1003
1004         Reviewed by Saam Barati.
1005
1006         * bmalloc/DebugHeap.cpp:
1007         (bmalloc::DebugHeap::DebugHeap):
1008
1009 2018-07-27  Saam Barati  <sbarati@apple.com>
1010
1011         Explicitly handle memlimit_active < 0
1012         https://bugs.webkit.org/show_bug.cgi?id=188125
1013
1014         Reviewed by Mark Lam.
1015
1016         This may come up during development when someone wants the limit
1017         to be "infinite".
1018
1019         * bmalloc/AvailableMemory.cpp:
1020         (bmalloc::jetsamLimit):
1021
1022 2018-07-27  Saam Barati  <sbarati@apple.com>
1023
1024         Use SPI to compute the jetsam limit on iOS instead of hardcoding 840MB
1025         https://bugs.webkit.org/show_bug.cgi?id=188091
1026         <rdar://problem/42647697>
1027
1028         Reviewed by Simon Fraser.
1029
1030         We want bmalloc to dynamically adapt to the jetsam limit of the process
1031         it's running in. WTF::ramSize() is based off bmalloc's availableMemory,
1032         so it will now reflect the result of the real jetsam limit when we can
1033         read it.
1034         
1035         Reading the jetsam limit requires an entitlement, so this patch opts in
1036         the WebContent/Storage/Network processes. We fall back to 840MB (the
1037         old hard coded value) when the SPI call fails (e.g, when we're in a
1038         process without the proper entitlement).
1039
1040         * bmalloc.xcodeproj/project.pbxproj:
1041         * bmalloc/AvailableMemory.cpp:
1042         (bmalloc::jetsamLimit):
1043         (bmalloc::computeAvailableMemory):
1044         * bmalloc/darwin/MemoryStatusSPI.h: Added.
1045
1046 2018-07-24  Saam Barati  <sbarati@apple.com>
1047
1048         Revert back to using phys_footprint to calculate isUnderMemoryPressure()
1049         https://bugs.webkit.org/show_bug.cgi?id=187919
1050         <rdar://problem/42552888>
1051
1052         Reviewed by Simon Fraser.
1053
1054         Currently on iOS, bmalloc will run the scavenger more frequently when it detects
1055         that the process is under memory pressure. However, it only uses bmalloc's
1056         own footprint as a percentage of the HW available memory to determine if
1057         the process is under memory pressure. This is a change I recently made
1058         in an effort to run the scavenger less when bmalloc wasn't contributing
1059         to the dirty footprint in the process. However, this fails to run the
1060         scavenger eagerly when the process in question has a heap split
1061         between a lot of dirty bmalloc memory as well as a lot of dirty memory
1062         from elsewhere. We also have evidence that we may have increased jetsams
1063         in the Web Content process. Since my original change was not a measurable
1064         speedup, this patch reverts isUnderMemoryPressure() to its previous
1065         behavior of using phys_footprint to determine if 75% of the available 
1066         HW memory is being used.
1067
1068         * bmalloc/AvailableMemory.cpp:
1069         (bmalloc::memoryStatus):
1070
1071 2019-07-12  Michael Saboff  <msaboff@apple.com>
1072
1073         Disable IsoHeaps when Gigacage is off
1074         https://bugs.webkit.org/show_bug.cgi?id=187160
1075
1076         Reviewed by Saam Barati.
1077
1078         Relanding change sets 233547 and 233550 with the added fix that Gigacage is also
1079         enabled for DumpRenderTree.
1080
1081         Updated determineMallocFallbackState to base enabling of Iso Heaps on Gigacage 
1082         being enabled.  We do this because if Gigacage is disabled, it may be due to lack
1083         of address space.
1084
1085         To work around a compiler issue uncovered by the change above, I added explicit
1086         instantiation of PerThread's static variables.  Defined the same explicit
1087         instantiated static variables with export scope in the new file PerThread.cpp
1088         to eliminate separate variables allocations in each linked framework / library.
1089
1090         * CMakeLists.txt:
1091         * bmalloc.xcodeproj/project.pbxproj:
1092         * bmalloc/IsoTLS.cpp:
1093         (bmalloc::IsoTLS::determineMallocFallbackState):
1094         * bmalloc/PerThread.cpp: Added.
1095         * bmalloc/PerThread.h:
1096         * bmalloc/ProcessCheck.mm:
1097         (bmalloc::gigacageEnabledForProcess):
1098
1099 2018-07-09  Commit Queue  <commit-queue@webkit.org>
1100
1101         Unreviewed, rolling out r233547 and r233550.
1102         https://bugs.webkit.org/show_bug.cgi?id=187497
1103
1104         Introduced flakiness for media/fullscreen-* tests on mac-wk1
1105         (Requested by ryanhaddad on #webkit).
1106
1107         Reverted changesets:
1108
1109         "Disable IsoHeaps when Gigacage is off"
1110         https://bugs.webkit.org/show_bug.cgi?id=187160
1111         https://trac.webkit.org/changeset/233547
1112
1113         "Build fix (r233547): Disable IsoHeaps when Gigacage is off"
1114         https://bugs.webkit.org/show_bug.cgi?id=187160
1115         https://trac.webkit.org/changeset/233550
1116
1117 2018-07-05  David Kilzer  <ddkilzer@apple.com>
1118
1119         Build fix (r233547): Disable IsoHeaps when Gigacage is off
1120         <https://webkit.org/b/187160>
1121
1122         * bmalloc/PerThread.cpp: Add #if !HAVE_PTHREAD_MACHDEP_H/#endif
1123         around variables only used when that macro is 0.  Include what
1124         you use: Cache.h and Heap.h.
1125         * bmalloc/PerThread.h: Include <memory> for std::once_flag.
1126
1127 2018-07-05  Michael Saboff  <msaboff@apple.com>
1128
1129         Disable IsoHeaps when Gigacage is off
1130         https://bugs.webkit.org/show_bug.cgi?id=187160
1131
1132         Reviewed by Saam Barati.
1133
1134         Updated determineMallocFallbackState to base enabling of Iso Heaps on Gigacage 
1135         being enabled.  We do this because if Gigacage is disabled, it may be due to lack
1136         of address space.
1137
1138         To work around a compiler issue uncovered by the change above, I added explicit
1139         instantiation of PerThread's static variables.  Defined the same explicit
1140         instantiated static variables with export scope in the new file PerThread.cpp
1141         to eliminate separate variables allocations in each linked framework / library.
1142
1143         * CMakeLists.txt:
1144         * bmalloc.xcodeproj/project.pbxproj:
1145         * bmalloc/IsoTLS.cpp:
1146         (bmalloc::IsoTLS::determineMallocFallbackState):
1147         * bmalloc/PerThread.cpp: Added.
1148         * bmalloc/PerThread.h:
1149
1150 2018-07-04  Tim Horton  <timothy_horton@apple.com>
1151
1152         Introduce PLATFORM(IOSMAC)
1153         https://bugs.webkit.org/show_bug.cgi?id=187315
1154
1155         Reviewed by Dan Bernstein.
1156
1157         * Configurations/Base.xcconfig:
1158
1159 2018-06-29  Ryan Haddad  <ryanhaddad@apple.com>
1160
1161         Unreviewed, rolling out r233347.
1162
1163         Causes crashes during WK1 tests.
1164
1165         Reverted changeset:
1166
1167         "Disable IsoHeaps when Gigacage is off"
1168         https://bugs.webkit.org/show_bug.cgi?id=187160
1169         https://trac.webkit.org/changeset/233347
1170
1171 2018-06-28  Michael Saboff  <msaboff@apple.com>
1172
1173         Disable IsoHeaps when Gigacage is off
1174         https://bugs.webkit.org/show_bug.cgi?id=187160
1175
1176         Reviewed by Saam Barati.
1177
1178         If Gigacage is disabled, it may be due to lack of address space.
1179         Therefore we should also turn off IsoHeaps since it uses more virtual
1180         address space as well.
1181
1182         * bmalloc/IsoTLS.cpp:
1183         (bmalloc::IsoTLS::determineMallocFallbackState):
1184
1185 2018-06-27  Simon Fraser  <simon.fraser@apple.com>
1186
1187         https://hackernoon.com/ uses lots of layer backing store
1188         https://bugs.webkit.org/show_bug.cgi?id=186909
1189         rdar://problem/40257540
1190
1191         Reviewed by Tim Horton.
1192         
1193         Drive-by typo fix.
1194
1195         * bmalloc/Scavenger.cpp:
1196         (bmalloc::dumpStats):
1197
1198 2018-06-26  Saam Barati  <sbarati@apple.com>
1199
1200         Unreviewed followup. Fix the watchos build after r233192.
1201
1202         This patch also correct the changelog entry below to have the correct
1203         bug and title info.
1204
1205         * bmalloc/ProcessCheck.mm:
1206
1207 2018-06-26  Saam Barati  <sbarati@apple.com>
1208
1209         Switch to system malloc on iOS when nano malloc is disabled
1210         https://bugs.webkit.org/show_bug.cgi?id=186322
1211         <rdar://problem/41140257>
1212
1213         Reviewed by Keith Miller.
1214
1215         We have evidence showing that processes with small heaps using the
1216         JS API are more space efficient when using system malloc. Our main
1217         hypothesis as to why this is, is that when dealing with small heaps,
1218         one malloc can be more efficient at optimizing memory usage than
1219         two mallocs.
1220
1221         * bmalloc/BPlatform.h:
1222         * bmalloc/Environment.cpp:
1223         (bmalloc::isNanoMallocEnabled):
1224         (bmalloc::Environment::computeIsDebugHeapEnabled):
1225         * bmalloc/ProcessCheck.h:
1226         (bmalloc::shouldProcessUnconditionallyUseBmalloc):
1227         * bmalloc/ProcessCheck.mm:
1228         (bmalloc::shouldProcessUnconditionallyUseBmalloc):
1229
1230 2018-06-24  Yusuke Suzuki  <utatane.tea@gmail.com>
1231
1232         [bmalloc][Linux] Remove static initializers for PerProcess<>::s_object
1233         https://bugs.webkit.org/show_bug.cgi?id=186966
1234
1235         Reviewed by Anders Carlsson.
1236
1237         chrome/tools/linux/dump-static-initializers.py can dump static initializers
1238         in the binary and we found that PerProcess<>::s_object initialization is done
1239         by static initializers in GCC + Linux environments. The example is the following.
1240
1241         Scavenger.cpp (initializer offset 0x38c210 size 0x3e)
1242             _GLOBAL__sub_I_Scavenger.cpp+0x1e
1243             _GLOBAL__sub_I_Scavenger.cpp+0x2d
1244             _GLOBAL__sub_I_Scavenger.cpp+0x3c
1245             _GLOBAL__sub_I_Scavenger.cpp+0xf
1246             guard variable for bmalloc::PerProcess<bmalloc::AllIsoHeaps>::s_object@@Base-0x3f0d8
1247             guard variable for bmalloc::PerProcess<bmalloc::Environment>::s_object@@Base-0x3f0e8
1248             guard variable for bmalloc::PerProcess<bmalloc::PerHeapKind<bmalloc::Heap> >::s_object@@Base-0x3c600
1249             guard variable for bmalloc::PerProcess<bmalloc::Scavenger>::s_object@@Base-0x38ce8
1250
1251         We can remove this by initializing `nullptr`, which leads to constexpr initialization.
1252         After this change, Linux JSCOnly libJavaScriptCore.so has no static initializers.
1253
1254         * bmalloc/PerProcess.h:
1255
1256 2018-06-09  Dan Bernstein  <mitz@apple.com>
1257
1258         [Xcode] Clean up and modernize some build setting definitions
1259         https://bugs.webkit.org/show_bug.cgi?id=186463
1260
1261         Reviewed by Sam Weinig.
1262
1263         * Configurations/Base.xcconfig: Removed definition for macOS 10.11.
1264         * Configurations/DebugRelease.xcconfig: Ditto.
1265
1266 2018-06-07  Darin Adler  <darin@apple.com>
1267
1268         [Cocoa] Turn on ARC for the single Objective-C++ source file in bmalloc
1269         https://bugs.webkit.org/show_bug.cgi?id=186398
1270
1271         Reviewed by Saam Barati.
1272
1273         * Configurations/Base.xcconfig: Turn on ARC.
1274         * bmalloc/ProcessCheck.mm:
1275         (bmalloc::gigacageEnabledForProcess): Removed the globals from this function,
1276         since it's only called once. If it was called more than once, we could optimize
1277         that with a single boolean global rather than two strings and two booleans.
1278
1279 2018-06-07  David Kilzer  <ddkilzer@apple.com>
1280
1281         bmalloc: Fix 'noreturn' warnings when compiling with -std=gnu++17
1282         <https://webkit.org/b/186400>
1283
1284         Reviewed by Saam Barati.
1285
1286         Fixes the following warnings when compiling with gnu++17:
1287
1288             Source/bmalloc/bmalloc/Scavenger.cpp:363:1: error: function 'threadRunLoop' could be declared with attribute 'noreturn' [-Werror,-Wmissing-noreturn]
1289             {
1290             ^
1291             Source/bmalloc/bmalloc/Scavenger.cpp:358:1: error: function 'threadEntryPoint' could be declared with attribute 'noreturn' [-Werror,-Wmissing-noreturn]
1292             {
1293             ^
1294
1295         * bmalloc/BCompiler.h:
1296         (BCOMPILER): Add support for the BCOMPILER() macro, then add
1297         BCOMPILER(GCC_OR_CLANG).  Taken from Source/WTF/wtf/Compiler.h.
1298         (BNO_RETURN): Implement 'norerturn' support using the new
1299         BCOMPILER() macros.  Taken from Source/WTF/wtf/Compiler.h.
1300         * bmalloc/Scavenger.cpp:
1301         (bmalloc::Scavenger::threadRunLoop): Remove the workaround that
1302         tricked older compilers into thinking the while() loop wasn't
1303         infinite.
1304         * bmalloc/Scavenger.h:
1305         (bmalloc::Scavenger::threadEntryPoint): Add BNO_RETURN attribute.
1306         (bmalloc::Scavenger::threadRunLoop): Ditto.
1307
1308 2018-05-29  Saam Barati  <sbarati@apple.com>
1309
1310         JSC should put bmalloc's scavenger into mini mode
1311         https://bugs.webkit.org/show_bug.cgi?id=185988
1312
1313         Reviewed by Michael Saboff.
1314
1315         We expose an API for putting bmalloc into mini mode. All that means now
1316         is that we'll run the scavenger more aggressively.
1317
1318         * bmalloc/Scavenger.cpp:
1319         (bmalloc::Scavenger::enableMiniMode):
1320         (bmalloc::Scavenger::threadRunLoop):
1321         * bmalloc/Scavenger.h:
1322         * bmalloc/Sizes.h:
1323         * bmalloc/bmalloc.cpp:
1324         (bmalloc::api::enableMiniMode):
1325         * bmalloc/bmalloc.h:
1326
1327 2018-05-29  Geoffrey Garen  <ggaren@apple.com>
1328
1329         Fixed the bmalloc build
1330         https://bugs.webkit.org/show_bug.cgi?id=186025
1331
1332         Reviewed by Sam Weinig.
1333
1334         * bmalloc.xcodeproj/project.pbxproj: Link Foundation because the 
1335         gigacage check needs it.
1336
1337 2018-05-23  Antti Koivisto  <antti@apple.com>
1338
1339         Increase the simulated memory size on PLATFORM(IOS_SIMULATOR) from 512MB to 1024MB
1340         https://bugs.webkit.org/show_bug.cgi?id=185908
1341
1342         Reviewed by Geoffrey Garen.
1343
1344         We don't support 512MB devices anymore. This will make the simulator behave more
1345         like a real device.
1346
1347         * bmalloc/AvailableMemory.cpp:
1348         (bmalloc::memorySizeAccordingToKernel):
1349
1350         Factor to a function.
1351         Don't use availableMemoryGuess for the simulator value as it is not a guess.
1352
1353         (bmalloc::computeAvailableMemory):
1354
1355         Apply the same adjustments to the simulated value too.
1356
1357 2018-05-22  Ryan Haddad  <ryanhaddad@apple.com>
1358
1359         Unreviewed, rolling out r232052.
1360
1361         Breaks internal builds.
1362
1363         Reverted changeset:
1364
1365         "Use more C++17"
1366         https://bugs.webkit.org/show_bug.cgi?id=185176
1367         https://trac.webkit.org/changeset/232052
1368
1369 2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
1370
1371         Define GIGACAGE_ALLOCATION_CAN_FAIL on Linux
1372         https://bugs.webkit.org/show_bug.cgi?id=183329
1373
1374         Reviewed by Michael Catanzaro.
1375
1376         We specify `GIGACAGE_ALLOCATION_CAN_FAIL 1` in Linux since
1377         Linux can fail to `mmap` if `vm.overcommit_memory = 2`.
1378         Users can enable Gigacage if users enable overcommit_memory.
1379
1380         * bmalloc/Gigacage.h:
1381
1382 2018-05-21  Yusuke Suzuki  <utatane.tea@gmail.com>
1383
1384         Use more C++17
1385         https://bugs.webkit.org/show_bug.cgi?id=185176
1386
1387         Reviewed by JF Bastien.
1388
1389         Add BNO_RETURN.
1390
1391         * Configurations/Base.xcconfig:
1392         * bmalloc/BCompiler.h:
1393         * bmalloc/Scavenger.h:
1394
1395 2018-05-06  Yusuke Suzuki  <utatane.tea@gmail.com>
1396
1397         [JSC] Remove "using namespace std;" from JSC, bmalloc, WTF
1398         https://bugs.webkit.org/show_bug.cgi?id=185362
1399
1400         Reviewed by Sam Weinig.
1401
1402         * bmalloc/Allocator.cpp:
1403         * bmalloc/Deallocator.cpp:
1404
1405 2018-05-03  Filip Pizlo  <fpizlo@apple.com>
1406
1407         Strings should not be allocated in a gigacage
1408         https://bugs.webkit.org/show_bug.cgi?id=185218
1409
1410         Reviewed by Saam Barati.
1411         
1412         This removes the string gigacage.
1413         
1414         Putting strings in a gigacage prevents read gadgets. The other things that get to be in gigacages
1415         are there to prevent read-write gadgets.
1416         
1417         Also, putting strings in a gigacage seems to have been a bigger regression than putting other
1418         things in gigacages.
1419         
1420         Therefore, to maximize the benefit/cost ratio of gigacages, we should evict strings from them. If
1421         we want to throw away perf for security, there are more beneficial things to sacrifice.
1422
1423         * bmalloc/Gigacage.h:
1424         (Gigacage::name):
1425         (Gigacage::basePtr):
1426         (Gigacage::size):
1427         (Gigacage::forEachKind):
1428         * bmalloc/HeapKind.h:
1429         (bmalloc::isGigacage):
1430         (bmalloc::gigacageKind):
1431         (bmalloc::heapKind):
1432         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
1433         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
1434
1435 2018-04-30  Yusuke Suzuki  <utatane.tea@gmail.com>
1436
1437         Use WordLock instead of std::mutex for Threading
1438         https://bugs.webkit.org/show_bug.cgi?id=185121
1439
1440         Reviewed by Geoffrey Garen.
1441
1442         Add constexpr to explicitly describe that bmalloc::Mutex constructor is constexpr.
1443
1444         * bmalloc/Mutex.h:
1445
1446 2018-04-23  Ting-Wei Lan  <lantw44@gmail.com>
1447
1448         Include stdio.h before using stderr
1449         https://bugs.webkit.org/show_bug.cgi?id=184872
1450
1451         Reviewed by Yusuke Suzuki.
1452
1453         * bmalloc/PerProcess.cpp:
1454         * bmalloc/Scavenger.cpp:
1455
1456 2018-04-21  Yusuke Suzuki  <utatane.tea@gmail.com>
1457
1458         Unreviewed, follow-up patch after r230474
1459         https://bugs.webkit.org/show_bug.cgi?id=166684
1460
1461         Add "JavaScriptCore" to Darwin name. And use short name "BMScavenger"
1462         for Linux since adding "JavaScriptCore" makes the name too long for Linux.
1463
1464         * bmalloc/Scavenger.cpp:
1465         (bmalloc::Scavenger::threadRunLoop):
1466
1467 2018-04-18  Jer Noble  <jer.noble@apple.com>
1468
1469         Don't put build products into WK_ALTERNATE_WEBKIT_SDK_PATH for engineering builds
1470         https://bugs.webkit.org/show_bug.cgi?id=184762
1471
1472         Reviewed by Dan Bernstein.
1473
1474         * Configurations/Base.xcconfig:
1475
1476 2018-04-20  Daniel Bates  <dabates@apple.com>
1477
1478         Remove code for compilers that did not support NSDMI for aggregates
1479         https://bugs.webkit.org/show_bug.cgi?id=184599
1480
1481         Reviewed by Per Arne Vollan.
1482
1483         Remove workaround for earlier Visual Studio versions that did not support non-static data
1484         member initializers (NSDMI) for aggregates. We have since updated all the build.webkit.org
1485         and EWS bots to a newer version that supports this feature.
1486
1487         * bmalloc/BPlatform.h:
1488         * bmalloc/List.h:
1489         (bmalloc::ListNode::ListNode): Deleted.
1490         (bmalloc::List::iterator::iterator): Deleted.
1491
1492 2018-04-19  David Kilzer  <ddkilzer@apple.com>
1493
1494         Enable Objective-C weak references
1495         <https://webkit.org/b/184789>
1496         <rdar://problem/39571716>
1497
1498         Reviewed by Dan Bernstein.
1499
1500         * Configurations/Base.xcconfig:
1501         (CLANG_ENABLE_OBJC_WEAK): Enable.
1502
1503 2018-04-12  Saam Barati  <sbarati@apple.com>
1504
1505         Lessen partial scavenge interval on x86-64
1506         https://bugs.webkit.org/show_bug.cgi?id=184577
1507
1508         Rubber-stamped by Filip Pizlo.
1509
1510         I initially made the scavenge interval longer because I had thought the
1511         shorter interval caused a JetStream regression. I was mistaken though.
1512         I was looking at the wrong commit range when analyzing perf data.
1513         
1514         This patch shortens the interval, but still keeps x86-64 50% longer than
1515         other architectures. We know that scavenging frequently on Mac is less
1516         important to overall system performance than it is on iOS.
1517
1518         * bmalloc/Scavenger.cpp:
1519         (bmalloc::Scavenger::threadRunLoop):
1520
1521 2018-04-12  Saam Barati  <sbarati@apple.com>
1522
1523         Raise the partial scavenge interval even more on x86-64
1524         https://bugs.webkit.org/show_bug.cgi?id=184551
1525
1526         Rubber-stamped by Filip Pizlo.
1527
1528         The JetStream regression didn't recover from my previous patch.
1529         This is another attempt to get it to recover perf.
1530
1531         * bmalloc/Scavenger.cpp:
1532         (bmalloc::Scavenger::threadRunLoop):
1533
1534 2018-04-11  Saam Barati  <sbarati@apple.com>
1535
1536         raise partial scavenge interval on x86-64
1537         https://bugs.webkit.org/show_bug.cgi?id=184521
1538
1539         Rubber-stamped by Filip Pizlo.
1540
1541         This patch is an attempt to recover the 1-3% JetStream regression
1542         my initial partial scavenging patch introduced on some Macs.
1543
1544         * bmalloc/Scavenger.cpp:
1545         (bmalloc::Scavenger::threadRunLoop):
1546
1547 2018-04-10  Saam Barati  <sbarati@apple.com>
1548
1549         IsoHeapImpl::scavenge* needs to grab the lock
1550         https://bugs.webkit.org/show_bug.cgi?id=184461
1551
1552         Reviewed by Filip Pizlo.
1553
1554         Another thread could be modifying the linked list that the scavenge* methods traverse.
1555
1556         * bmalloc/IsoHeapImplInlines.h:
1557         (bmalloc::IsoHeapImpl<Config>::scavenge):
1558         (bmalloc::IsoHeapImpl<Config>::scavengeToHighWatermark):
1559
1560 2018-04-10  Saam Barati  <sbarati@apple.com>
1561
1562         bmalloc should do partial scavenges more frequently
1563         https://bugs.webkit.org/show_bug.cgi?id=184176
1564
1565         Reviewed by Filip Pizlo.
1566
1567         This patch adds the ability for bmalloc to do a partial scavenge.
1568         bmalloc will now do a partial scavenge with some frequency even
1569         when the heap is growing.
1570         
1571         For Heap, this means tracking the high water mark of where the Heap
1572         has allocated since the last scavenge. Partial scavenging is just
1573         decommitting entries in the LargeMap that are past this high water
1574         mark. Because we allocate in first fit order out of LargeMap, tracking
1575         the high water mark is a good heuristic of how much memory a partial
1576         scavenge should decommit.
1577         
1578         For IsoHeaps, each IsoDirectory also keeps track of its high water mark
1579         for the furthest page it allocates into. Similar to Heap, we scavenge pages
1580         past that high water mark. IsoHeapImpl then tracks the high water mark
1581         for the IsoDirectory it allocates into. We then scavenge all directories 
1582         including and past the directory high water mark. This includes scavenging
1583         the inline directory when its the only thing we allocate out of since
1584         the last scavenge.
1585         
1586         This patch also adds some other capabilities to bmalloc:
1587         
1588         Heaps and IsoHeaps now track how much memory is freeable. Querying
1589         this number is now cheap.
1590         
1591         Heaps no longer hold the global lock when decommitting large ranges.
1592         Instead, that range is just marked as non eligible to be allocated.
1593         Then, without the lock held, the scavenger will decommit those ranges.
1594         Once this is done, the scavenger will then reacquire the lock and mark
1595         these ranges as eligible. This lessens lock contention between the
1596         scavenger and the allocation slow path since threads that are taking an
1597         allocation slow path can now allocate concurrently to the scavenger's
1598         decommits. The main consideration in adding this functionality is that
1599         a large allocation may fail while the scavenger is in the process of
1600         decommitting memory. When the Heap fails to allocate a large range when
1601         the scavenger is in the middle of a decommit, Heap will wait for the
1602         Scavenger to finish and then it will try to allocate a large range again.
1603         
1604         Decommitting from Heap now aggregates the ranges to decommit and tries to
1605         merge them together to lower the number of calls to vmDeallocatePhysicalPages.
1606         This is analogous to what IsoHeaps already do.
1607
1608         * bmalloc.xcodeproj/project.pbxproj:
1609         * bmalloc/Allocator.cpp:
1610         (bmalloc::Allocator::tryAllocate):
1611         (bmalloc::Allocator::allocateImpl):
1612         (bmalloc::Allocator::reallocate):
1613         (bmalloc::Allocator::refillAllocatorSlowCase):
1614         (bmalloc::Allocator::allocateLarge):
1615         * bmalloc/BulkDecommit.h: Added.
1616         (bmalloc::BulkDecommit::addEager):
1617         (bmalloc::BulkDecommit::addLazy):
1618         (bmalloc::BulkDecommit::processEager):
1619         (bmalloc::BulkDecommit::processLazy):
1620         (bmalloc::BulkDecommit::add):
1621         (bmalloc::BulkDecommit::process):
1622         * bmalloc/Deallocator.cpp:
1623         (bmalloc::Deallocator::scavenge):
1624         (bmalloc::Deallocator::processObjectLog):
1625         (bmalloc::Deallocator::deallocateSlowCase):
1626         * bmalloc/Deallocator.h:
1627         (bmalloc::Deallocator::lineCache):
1628         * bmalloc/Heap.cpp:
1629         (bmalloc::Heap::freeableMemory):
1630         (bmalloc::Heap::markAllLargeAsEligibile):
1631         (bmalloc::Heap::decommitLargeRange):
1632         (bmalloc::Heap::scavenge):
1633         (bmalloc::Heap::scavengeToHighWatermark):
1634         (bmalloc::Heap::deallocateLineCache):
1635         (bmalloc::Heap::allocateSmallChunk):
1636         (bmalloc::Heap::deallocateSmallChunk):
1637         (bmalloc::Heap::allocateSmallPage):
1638         (bmalloc::Heap::deallocateSmallLine):
1639         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
1640         (bmalloc::Heap::allocateSmallBumpRangesByObject):
1641         (bmalloc::Heap::splitAndAllocate):
1642         (bmalloc::Heap::tryAllocateLarge):
1643         (bmalloc::Heap::allocateLarge):
1644         (bmalloc::Heap::isLarge):
1645         (bmalloc::Heap::largeSize):
1646         (bmalloc::Heap::shrinkLarge):
1647         (bmalloc::Heap::deallocateLarge):
1648         (bmalloc::Heap::externalCommit):
1649         (bmalloc::Heap::externalDecommit):
1650         * bmalloc/Heap.h:
1651         (bmalloc::Heap::allocateSmallBumpRanges):
1652         (bmalloc::Heap::derefSmallLine):
1653         * bmalloc/IsoDirectory.h:
1654         * bmalloc/IsoDirectoryInlines.h:
1655         (bmalloc::passedNumPages>::takeFirstEligible):
1656         (bmalloc::passedNumPages>::didBecome):
1657         (bmalloc::passedNumPages>::didDecommit):
1658         (bmalloc::passedNumPages>::scavengePage):
1659         (bmalloc::passedNumPages>::scavenge):
1660         (bmalloc::passedNumPages>::scavengeToHighWatermark):
1661         (bmalloc::passedNumPages>::freeableMemory): Deleted.
1662         * bmalloc/IsoHeapImpl.h:
1663         * bmalloc/IsoHeapImplInlines.h:
1664         (bmalloc::IsoHeapImpl<Config>::takeFirstEligible):
1665         (bmalloc::IsoHeapImpl<Config>::scavenge):
1666         (bmalloc::IsoHeapImpl<Config>::scavengeToHighWatermark):
1667         (bmalloc::IsoHeapImpl<Config>::freeableMemory):
1668         (bmalloc::IsoHeapImpl<Config>::isNowFreeable):
1669         (bmalloc::IsoHeapImpl<Config>::isNoLongerFreeable):
1670         * bmalloc/LargeMap.cpp:
1671         (bmalloc::LargeMap::remove):
1672         (bmalloc::LargeMap::markAllAsEligibile):
1673         * bmalloc/LargeMap.h:
1674         (bmalloc::LargeMap::size):
1675         (bmalloc::LargeMap::at):
1676         * bmalloc/LargeRange.h:
1677         (bmalloc::LargeRange::setEligible):
1678         (bmalloc::LargeRange::isEligibile const):
1679         (bmalloc::canMerge):
1680         * bmalloc/ObjectType.cpp:
1681         (bmalloc::objectType):
1682         * bmalloc/Scavenger.cpp:
1683         (bmalloc::PrintTime::PrintTime):
1684         (bmalloc::PrintTime::~PrintTime):
1685         (bmalloc::PrintTime::print):
1686         (bmalloc::Scavenger::timeSinceLastFullScavenge):
1687         (bmalloc::Scavenger::timeSinceLastPartialScavenge):
1688         (bmalloc::Scavenger::scavenge):
1689         (bmalloc::Scavenger::partialScavenge):
1690         (bmalloc::Scavenger::freeableMemory):
1691         (bmalloc::Scavenger::threadRunLoop):
1692         * bmalloc/Scavenger.h:
1693         * bmalloc/SmallLine.h:
1694         (bmalloc::SmallLine::refCount):
1695         (bmalloc::SmallLine::ref):
1696         (bmalloc::SmallLine::deref):
1697         * bmalloc/SmallPage.h:
1698         (bmalloc::SmallPage::refCount):
1699         (bmalloc::SmallPage::hasFreeLines const):
1700         (bmalloc::SmallPage::setHasFreeLines):
1701         (bmalloc::SmallPage::ref):
1702         (bmalloc::SmallPage::deref):
1703         * bmalloc/bmalloc.cpp:
1704         (bmalloc::api::tryLargeZeroedMemalignVirtual):
1705         (bmalloc::api::freeLargeVirtual):
1706
1707 2018-04-09  Yusuke Suzuki  <utatane.tea@gmail.com>
1708
1709         [bmalloc] Name Scavenger thread "bmalloc scavenger"
1710         https://bugs.webkit.org/show_bug.cgi?id=166684
1711
1712         Reviewed by Saam Barati.
1713
1714         We name the thread for bmalloc Scavenger "bmalloc scavenger".
1715         It is useful for debugging. In Linux environment, it will be
1716         shown in GDB.
1717
1718         * bmalloc/Scavenger.cpp:
1719         (bmalloc::Scavenger::threadRunLoop):
1720         (bmalloc::Scavenger::setName):
1721         * bmalloc/Scavenger.h:
1722
1723 2018-04-09  Michael Catanzaro  <mcatanzaro@igalia.com>
1724
1725         Rename UNUSED to BUNUSED
1726         https://bugs.webkit.org/show_bug.cgi?id=184093
1727
1728         Reviewed by Yusuke Suzuki.
1729
1730         * bmalloc/BAssert.h:
1731         * bmalloc/VMAllocate.h:
1732         (bmalloc::vmValidate):
1733         (bmalloc::vmValidatePhysical):
1734
1735 2018-04-08  Yusuke Suzuki  <utatane.tea@gmail.com>
1736
1737         Use alignas instead of compiler-specific attributes
1738         https://bugs.webkit.org/show_bug.cgi?id=183508
1739
1740         Reviewed by Mark Lam.
1741
1742         Use alignas for g_gigacageBasePtr. We also add reinterpret_cast to fix
1743         compile errors in ARMv7 and MIPS JSCOnly ports.
1744
1745         * bmalloc/Gigacage.cpp:
1746         * bmalloc/Gigacage.h:
1747         (Gigacage::basePtrs):
1748
1749 2018-04-06  Saam Barati  <sbarati@apple.com>
1750
1751         bmalloc virtual allocation API should not treat memory it vends as dirty with respect to how it drives the scavenger
1752         https://bugs.webkit.org/show_bug.cgi?id=184342
1753
1754         Reviewed by Mark Lam.
1755
1756         Currently, the only user of this API is Wasm. Ideally, Wasm would tell
1757         us exactly which page is dirtied. We should really do that at some point:
1758         https://bugs.webkit.org/show_bug.cgi?id=184207
1759         
1760         However, until we do that, it's better to treat none of the virtual memory
1761         we vend as dirty, versus what we do now, which is treat it all as dirty.
1762         This dirty memory tracking helps drive the scavenger, so on iOS, having the
1763         scavenger think its under memory pressure because of memory it can't free isn't
1764         useful.
1765
1766         * bmalloc/bmalloc.cpp:
1767         (bmalloc::api::tryLargeZeroedMemalignVirtual):
1768         (bmalloc::api::freeLargeVirtual):
1769         * bmalloc/bmalloc.h:
1770
1771 2018-04-05  Saam Barati  <sbarati@apple.com>
1772
1773         IsoHeapImpl not IsoHeapImplBase should add itself to AllIsoHeaps
1774         https://bugs.webkit.org/show_bug.cgi?id=184174
1775
1776         Reviewed by Filip Pizlo.
1777
1778         Otherwise, another thread may see a non-fully formed IsoHeapImpl.
1779
1780         * bmalloc/IsoHeapImpl.cpp:
1781         (bmalloc::IsoHeapImplBase::IsoHeapImplBase):
1782         (bmalloc::IsoHeapImplBase::addToAllIsoHeaps):
1783         * bmalloc/IsoHeapImpl.h:
1784         * bmalloc/IsoHeapImplInlines.h:
1785         (bmalloc::IsoHeapImpl<Config>::IsoHeapImpl):
1786
1787 2018-04-05  Yusuke Suzuki  <utatane.tea@gmail.com>
1788
1789         bmalloc StaticMutex's constructor should be constexpr
1790         https://bugs.webkit.org/show_bug.cgi?id=180600
1791
1792         Reviewed by Mark Lam.
1793
1794         StaticMutex and Mutex can be unified. This patch changes std::atomic_flag in StaticMutex
1795         to std::atomic<bool> to add constexpr constructor to StaticMutex. Then, StaticMutex can
1796         be initialized in static storage without calling any static initializers.
1797         And we also rename StaticMutex to Mutex simply.
1798
1799         * CMakeLists.txt:
1800         * bmalloc.xcodeproj/project.pbxproj:
1801         * bmalloc/AllIsoHeaps.cpp:
1802         (bmalloc::AllIsoHeaps::AllIsoHeaps):
1803         * bmalloc/AllIsoHeaps.h:
1804         * bmalloc/Allocator.cpp:
1805         (bmalloc::Allocator::tryAllocate):
1806         (bmalloc::Allocator::allocateImpl):
1807         (bmalloc::Allocator::reallocate):
1808         (bmalloc::Allocator::refillAllocatorSlowCase):
1809         (bmalloc::Allocator::allocateLarge):
1810         * bmalloc/CryptoRandom.cpp:
1811         (bmalloc::ARC4RandomNumberGenerator::ARC4RandomNumberGenerator):
1812         * bmalloc/Deallocator.cpp:
1813         (bmalloc::Deallocator::scavenge):
1814         (bmalloc::Deallocator::processObjectLog):
1815         (bmalloc::Deallocator::deallocateSlowCase):
1816         * bmalloc/Deallocator.h:
1817         (bmalloc::Deallocator::lineCache):
1818         * bmalloc/DebugHeap.cpp:
1819         (bmalloc::DebugHeap::DebugHeap):
1820         * bmalloc/DebugHeap.h:
1821         * bmalloc/Environment.cpp:
1822         (bmalloc::Environment::Environment):
1823         * bmalloc/Environment.h:
1824         * bmalloc/Gigacage.cpp:
1825         (Gigacage::disablePrimitiveGigacage):
1826         (Gigacage::addPrimitiveDisableCallback):
1827         (Gigacage::removePrimitiveDisableCallback):
1828         * bmalloc/Heap.cpp:
1829         (bmalloc::Heap::Heap):
1830         (bmalloc::Heap::freeableMemory):
1831         (bmalloc::Heap::scavenge):
1832         (bmalloc::Heap::deallocateLineCache):
1833         (bmalloc::Heap::allocateSmallChunk):
1834         (bmalloc::Heap::allocateSmallPage):
1835         (bmalloc::Heap::deallocateSmallLine):
1836         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
1837         (bmalloc::Heap::allocateSmallBumpRangesByObject):
1838         (bmalloc::Heap::splitAndAllocate):
1839         (bmalloc::Heap::tryAllocateLarge):
1840         (bmalloc::Heap::allocateLarge):
1841         (bmalloc::Heap::isLarge):
1842         (bmalloc::Heap::largeSize):
1843         (bmalloc::Heap::shrinkLarge):
1844         (bmalloc::Heap::deallocateLarge):
1845         (bmalloc::Heap::externalCommit):
1846         (bmalloc::Heap::externalDecommit):
1847         * bmalloc/Heap.h:
1848         (bmalloc::Heap::mutex):
1849         (bmalloc::Heap::allocateSmallBumpRanges):
1850         (bmalloc::Heap::derefSmallLine):
1851         * bmalloc/IsoDeallocator.h:
1852         * bmalloc/IsoHeap.h:
1853         * bmalloc/IsoTLSDeallocatorEntry.h:
1854         * bmalloc/IsoTLSDeallocatorEntryInlines.h:
1855         (bmalloc::IsoTLSDeallocatorEntry<Config>::IsoTLSDeallocatorEntry):
1856         * bmalloc/IsoTLSInlines.h:
1857         (bmalloc::IsoTLS::ensureHeap):
1858         * bmalloc/IsoTLSLayout.cpp:
1859         (bmalloc::IsoTLSLayout::IsoTLSLayout):
1860         (bmalloc::IsoTLSLayout::add):
1861         * bmalloc/IsoTLSLayout.h:
1862         * bmalloc/Mutex.cpp: Renamed from Source/bmalloc/bmalloc/StaticMutex.cpp.
1863         (bmalloc::Mutex::lockSlowCase):
1864         * bmalloc/Mutex.h:
1865         (bmalloc::sleep):
1866         (bmalloc::waitUntilFalse):
1867         (bmalloc::Mutex::try_lock):
1868         (bmalloc::Mutex::lock):
1869         (bmalloc::Mutex::unlock):
1870         (bmalloc::Mutex::Mutex): Deleted.
1871         * bmalloc/ObjectType.cpp:
1872         (bmalloc::objectType):
1873         * bmalloc/PerProcess.cpp:
1874         (bmalloc::getPerProcessData):
1875         * bmalloc/PerProcess.h:
1876         (bmalloc::PerProcess::mutex):
1877         (bmalloc::PerProcess::getSlowCase):
1878         * bmalloc/Scavenger.cpp:
1879         (bmalloc::Scavenger::Scavenger):
1880         (bmalloc::Scavenger::scavenge):
1881         (bmalloc::Scavenger::freeableMemory):
1882         * bmalloc/Scavenger.h:
1883         * bmalloc/SmallLine.h:
1884         (bmalloc::SmallLine::refCount):
1885         (bmalloc::SmallLine::ref):
1886         (bmalloc::SmallLine::deref):
1887         * bmalloc/SmallPage.h:
1888         (bmalloc::SmallPage::refCount):
1889         (bmalloc::SmallPage::hasFreeLines const):
1890         (bmalloc::SmallPage::setHasFreeLines):
1891         (bmalloc::SmallPage::ref):
1892         (bmalloc::SmallPage::deref):
1893         * bmalloc/StaticMutex.h: Removed.
1894         * bmalloc/VMHeap.cpp:
1895         (bmalloc::VMHeap::VMHeap):
1896         * bmalloc/VMHeap.h:
1897         * bmalloc/Zone.cpp:
1898         (bmalloc::Zone::Zone):
1899         * bmalloc/Zone.h:
1900         * bmalloc/bmalloc.cpp:
1901         (bmalloc::api::tryLargeZeroedMemalignVirtual):
1902         (bmalloc::api::freeLargeVirtual):
1903         (bmalloc::api::isEnabled):
1904         (bmalloc::api::setScavengerThreadQOSClass):
1905         * bmalloc/bmalloc.h:
1906
1907 2018-04-04  Konstantin Tokarev  <annulen@yandex.ru>
1908
1909         Enable Gigacage unconditionally when building JSCOnly on macOS (build fix)
1910         https://bugs.webkit.org/show_bug.cgi?id=184301
1911
1912         Reviewed by Yusuke Suzuki.
1913
1914         bmalloc/ProcessCheck.mm implements specific behavior for Mac and iOS ports,
1915         which is guarded with BPLATFORM(COCOA). if we don't enable BPLATFORM(MAC)
1916         or BPLATFORM(IOS) in JSCOnly, then BPLATFORM(COCOA) won't be defined
1917         as well, and code path from ProcessCheck.mm will not be taken.
1918
1919         * CMakeLists.txt: Exclude ProcessCheck.mm from port-independent file
1920         list.
1921         * PlatformMac.cmake: Build ProcessCheck.mm for Mac port.
1922         * bmalloc/BPlatform.h: Don't enable BPLATFORM(MAC) or BPLATFORM(IOS)
1923         when building JSCOnly port.
1924
1925 2018-04-03  Saam Barati  <sbarati@apple.com>
1926
1927         totalPhysicalSize calculation when splitting a range must account for double rounding effects
1928         https://bugs.webkit.org/show_bug.cgi?id=184275
1929
1930         Reviewed by Mark Lam.
1931
1932         The rounding error could happen when we split a range where the
1933         range's total physical size equals the range's total size. The
1934         rounding may cause the left size to lose a byte, and the right
1935         size to gain a byte. This caused the right side to be a byte
1936         large than its size.
1937
1938         * bmalloc/LargeRange.h:
1939         (bmalloc::LargeRange::LargeRange):
1940         (bmalloc::LargeRange::split const):
1941
1942 2018-04-02  Saam Barati  <sbarati@apple.com>
1943
1944         bmalloc should compute its own estimate of its footprint
1945         https://bugs.webkit.org/show_bug.cgi?id=184121
1946
1947         Reviewed by Filip Pizlo.
1948
1949         This patch makes it so that bmalloc keeps track of its own physical
1950         footprint.
1951         
1952         Doing this for IsoHeaps is trivial. It allocates/deallocates fixed
1953         page sizes at a time. IsoHeapImpl just updates a count every time
1954         a page is committed/decommitted.
1955         
1956         Making Heap keep its footprint was a bit trickier because of how
1957         LargeRange is constructed. Before this patch, LargeRange kept track
1958         of the amount of physical memory at the start of its range. This
1959         patch extends large range to also keep track of the total physical memory
1960         in the range just for footprint bookkeeping. This was needed to make
1961         Heap's footprint come close to resembling reality, because as we merge and split
1962         large ranges, the start physical size often becomes wildly inaccurate.
1963         The total physical size number stored in LargeRange is still just an
1964         estimate. It's possible that as ranges are split, that the total physical
1965         size split amongst the two ranges doesn't resemble reality. This can
1966         happen when the total physical size is really all in one end of the split,
1967         but we mark it as being proportionally split amongst the resulting two
1968         ranges. In practice, I did not notice this being a problem. The footprint
1969         estimate tracks reality very closely (in my testing, within less than 1MB for
1970         heaps with sizes upwards of 1GB). The other nice thing about total physical
1971         size is that even if it diverges from reality in terms of how memory is
1972         using up physical RAM, it stays internally consistent inside bmalloc's
1973         own data structures.
1974         
1975         The main oversight of this patch is how it deals with Wasm memory. All Wasm
1976         memory will be viewed by bmalloc as taking up physical space even when it
1977         may not be. Wasm memory starts off as taking up purely virtual pages. When a
1978         page is first accessed, only then will the OS page it in and cause it to use
1979         physical RAM. I opened a bug to come up with a solution to this problem:
1980         https://bugs.webkit.org/show_bug.cgi?id=184207
1981
1982         * bmalloc.xcodeproj/project.pbxproj:
1983         * bmalloc/AvailableMemory.cpp:
1984         (bmalloc::memoryStatus):
1985         * bmalloc/BPlatform.h:
1986         * bmalloc/Heap.cpp:
1987         (bmalloc::Heap::Heap):
1988         (bmalloc::Heap::freeableMemory):
1989         (bmalloc::Heap::footprint):
1990         (bmalloc::Heap::scavenge):
1991         (bmalloc::Heap::deallocateSmallChunk):
1992         (bmalloc::Heap::allocateSmallPage):
1993         (bmalloc::Heap::splitAndAllocate):
1994         (bmalloc::Heap::tryAllocateLarge):
1995         (bmalloc::Heap::shrinkLarge):
1996         (bmalloc::Heap::deallocateLarge):
1997         (bmalloc::Heap::externalCommit):
1998         (bmalloc::Heap::externalDecommit):
1999         * bmalloc/Heap.h:
2000         * bmalloc/IsoDirectory.h:
2001         * bmalloc/IsoDirectoryInlines.h:
2002         (bmalloc::passedNumPages>::takeFirstEligible):
2003         (bmalloc::passedNumPages>::didDecommit):
2004         (bmalloc::passedNumPages>::freeableMemory):
2005         * bmalloc/IsoHeapImpl.h:
2006         * bmalloc/IsoHeapImplInlines.h:
2007         (bmalloc::IsoHeapImpl<Config>::freeableMemory):
2008         (bmalloc::IsoHeapImpl<Config>::footprint):
2009         (bmalloc::IsoHeapImpl<Config>::didCommit):
2010         (bmalloc::IsoHeapImpl<Config>::didDecommit):
2011         * bmalloc/LargeRange.h:
2012         (bmalloc::LargeRange::LargeRange):
2013         (bmalloc::LargeRange::startPhysicalSize const):
2014         (bmalloc::LargeRange::setStartPhysicalSize):
2015         (bmalloc::LargeRange::totalPhysicalSize const):
2016         (bmalloc::LargeRange::setTotalPhysicalSize):
2017         (bmalloc::merge):
2018         (bmalloc::LargeRange::split const):
2019         (bmalloc::LargeRange::physicalSize const): Deleted.
2020         (bmalloc::LargeRange::setPhysicalSize): Deleted.
2021         * bmalloc/PhysicalPageMap.h: Added.
2022         This class is added for debugging purposes. It's useful when hacking
2023         on the code that calculates the footprint to use this map as a sanity
2024         check. It's just a simple implementation that has a set of all the committed pages.
2025
2026         (bmalloc::PhysicalPageMap::commit):
2027         (bmalloc::PhysicalPageMap::decommit):
2028         (bmalloc::PhysicalPageMap::footprint):
2029         (bmalloc::PhysicalPageMap::forEachPhysicalPage):
2030         * bmalloc/Scavenger.cpp:
2031         (bmalloc::dumpStats):
2032         (bmalloc::Scavenger::scavenge):
2033         (bmalloc::Scavenger::freeableMemory):
2034         This is here just for debugging for now. But we should implement an
2035         efficient version of this to use when driving when to run the
2036         scavenger.
2037
2038         (bmalloc::Scavenger::footprint):
2039         (bmalloc::Scavenger::threadRunLoop):
2040         * bmalloc/Scavenger.h:
2041         * bmalloc/VMAllocate.h:
2042         (bmalloc::physicalPageSizeSloppy):
2043         * bmalloc/VMHeap.cpp:
2044         (bmalloc::VMHeap::tryAllocateLargeChunk):
2045         * bmalloc/bmalloc.cpp:
2046         (bmalloc::api::commitAlignedPhysical):
2047         (bmalloc::api::decommitAlignedPhysical):
2048         * bmalloc/bmalloc.h:
2049
2050 2018-03-28  Commit Queue  <commit-queue@webkit.org>
2051
2052         Unreviewed, rolling out r230005.
2053         https://bugs.webkit.org/show_bug.cgi?id=184115
2054
2055         "it caused a huge regression on iOS" (Requested by saamyjoon
2056         on #webkit).
2057
2058         Reverted changeset:
2059
2060         "memoryStatus() is wrong in certain testing scenarios on iOS"
2061         https://bugs.webkit.org/show_bug.cgi?id=184050
2062         https://trac.webkit.org/changeset/230005
2063
2064 2018-03-27  Saam Barati  <sbarati@apple.com>
2065
2066         memoryStatus() is wrong in certain testing scenarios on iOS
2067         https://bugs.webkit.org/show_bug.cgi?id=184050
2068         <rdar://problem/37959258>
2069
2070         Rubber-stamped by Mark Lam.
2071
2072         This switches us from using "phys_footprint" to using "internal + compressed"
2073         when computing the dirty memory in the current process. There are iOS testing
2074         scenarios where phys_footprint doesn't give us a reliable answer. In my testing,
2075         "internal + compressed" tracks phys_footprint closely (when phys_footprint is
2076         working). They're usually within much less than 1% of each other. We're making
2077         this change to ensure testing in our iOS infrastructure is valid.
2078         
2079         I opened a bug to move back to phys_footprint when it's feasible:
2080         https://bugs.webkit.org/show_bug.cgi?id=184050
2081
2082         * bmalloc/AvailableMemory.cpp:
2083         (bmalloc::memoryStatus):
2084
2085 2018-03-20  Tim Horton  <timothy_horton@apple.com>
2086
2087         Add and adopt WK_PLATFORM_NAME and adjust default feature defines
2088         https://bugs.webkit.org/show_bug.cgi?id=183758
2089         <rdar://problem/38017644>
2090
2091         Reviewed by Dan Bernstein.
2092
2093         * Configurations/Base.xcconfig:
2094
2095 2018-03-16  Filip Pizlo  <fpizlo@apple.com>
2096
2097         Put the DOM in IsoHeaps
2098         https://bugs.webkit.org/show_bug.cgi?id=183546
2099
2100         Reviewed by Simon Fraser.
2101         
2102         Make it easy to runtime-disable IsoHeaps.
2103
2104         * bmalloc/Allocator.h:
2105         * bmalloc/IsoTLS.cpp:
2106         (bmalloc::IsoTLS::determineMallocFallbackState):
2107         * bmalloc/IsoTLS.h:
2108         * bmalloc/IsoTLSInlines.h:
2109         (bmalloc::IsoTLS::allocateSlow):
2110         (bmalloc::IsoTLS::deallocateSlow):
2111
2112 2018-03-16  Michael Catanzaro  <mcatanzaro@igalia.com>
2113
2114         Improve error message when Gigacage cannot allocate virtual memory
2115         https://bugs.webkit.org/show_bug.cgi?id=183329
2116
2117         Reviewed by Filip Pizlo.
2118
2119         We've discovered that Deja Dup monitor sets a virtual memory limit, breaking Gigacage. Since
2120         it runs in the background on a fresh out-of-the-box install of Ubuntu, this is not good.
2121         That will have to be fixed by Deja Dup, but there is concern that other applications might
2122         try this, or that users will set a virtual memory limit for the entire desktop session. Of
2123         particular concern is the possibility that users might have copypasted a ulimit line into
2124         a session startup script without understanding it. Let's try to make it slightly easier to
2125         understand what's going wrong.
2126
2127         * bmalloc/Gigacage.cpp:
2128         (Gigacage::ensureGigacage):
2129
2130 2018-03-13  Tim Horton  <timothy_horton@apple.com>
2131
2132         Add and adopt WK_ALTERNATE_FRAMEWORKS_DIR in WTF and bmalloc
2133         https://bugs.webkit.org/show_bug.cgi?id=183576
2134         <rdar://problem/38396766>
2135
2136         Reviewed by Dan Bernstein.
2137
2138         * Configurations/Base.xcconfig:
2139         * Configurations/bmalloc.xcconfig:
2140         * Configurations/mbmalloc.xcconfig:
2141
2142 2018-03-10  Filip Pizlo  <fpizlo@apple.com>
2143
2144         PerProcess<> should be safe by default
2145         https://bugs.webkit.org/show_bug.cgi?id=183545
2146
2147         Reviewed by Yusuke Suzuki.
2148         
2149         This makes PerProcess<> safe by default, so we don't need SafePerProcess<>.
2150         
2151         The new PerProcess<> design relies on a hash-consing mechanism for PerProcess<> storage based
2152         on the __PRETTY_FUNCTION__ from inside PerProcess<>, which captures the instantiated type in
2153         the string. Therefore, this can be used to runtime-coalesce PerProcess<> instances based on
2154         type.
2155         
2156         I expect this to be perf-neutral. It's an important prerequisite to more bmalloc work, since I
2157         don't want to have more PerProcess<> vs SafePerProcess<> bugs, and SafePerProcess<> can't be
2158         used for everything (I don't see how to use it for isoheaps).
2159
2160         * CMakeLists.txt:
2161         * bmalloc.xcodeproj/project.pbxproj:
2162         * bmalloc/Heap.cpp:
2163         (bmalloc::Heap::Heap):
2164         * bmalloc/IsoDirectoryInlines.h:
2165         (bmalloc::passedNumPages>::takeFirstEligible):
2166         (bmalloc::passedNumPages>::didBecome):
2167         * bmalloc/PerProcess.cpp: Added.
2168         (bmalloc::stringHash):
2169         (bmalloc::allocate):
2170         (bmalloc::getPerProcessData):
2171         * bmalloc/PerProcess.h:
2172         (bmalloc::PerProcess::mutex):
2173         (bmalloc::PerProcess::coalesce):
2174         (bmalloc::PerProcess::getSlowCase):
2175         (): Deleted.
2176         * bmalloc/Scavenger.cpp:
2177         * bmalloc/Scavenger.h:
2178         * bmalloc/bmalloc.cpp:
2179         (bmalloc::api::scavenge):
2180         (bmalloc::api::setScavengerThreadQOSClass):
2181
2182 2018-03-10  Commit Queue  <commit-queue@webkit.org>
2183
2184         Unreviewed, rolling out r229436.
2185         https://bugs.webkit.org/show_bug.cgi?id=183542
2186
2187         seems to have regressed wasm compile times by 10% (Requested
2188         by pizlo-mbp on #webkit).
2189
2190         Reverted changeset:
2191
2192         "bmalloc mutex should be adaptive"
2193         https://bugs.webkit.org/show_bug.cgi?id=177839
2194         https://trac.webkit.org/changeset/229436
2195
2196 2018-03-08  Filip Pizlo  <fpizlo@apple.com>
2197
2198         bmalloc mutex should be adaptive
2199         https://bugs.webkit.org/show_bug.cgi?id=177839
2200
2201         Reviewed by Michael Saboff.
2202         
2203         This pulls the WordLock algorithm into bmalloc, mostly by copy-pasting the code. We need to
2204         copy paste because sometimes we build WTF without bmalloc, so WTF cannot rely on bmalloc for
2205         anything other than malloc.
2206
2207         Reland after failing to reproduce the WasmBench crash that caused it to get rolled out. Maybe that fixed
2208         itself somehow?
2209
2210         * bmalloc/Algorithm.h:
2211         (bmalloc::compareExchangeWeak):
2212         (bmalloc::compareExchangeStrong):
2213         * bmalloc/PerThread.h:
2214         * bmalloc/StaticMutex.cpp:
2215         (bmalloc::StaticMutex::lockSlow):
2216         (bmalloc::StaticMutex::unlockSlow):
2217         (bmalloc::StaticMutex::lockSlowCase): Deleted.
2218         * bmalloc/StaticMutex.h:
2219         (bmalloc::StaticMutex::try_lock):
2220         (bmalloc::StaticMutex::isLocked const):
2221         (bmalloc::StaticMutex::init):
2222         (bmalloc::StaticMutex::tryLock):
2223         (bmalloc::StaticMutex::lock):
2224         (bmalloc::StaticMutex::unlock):
2225         (bmalloc::sleep): Deleted.
2226         (bmalloc::waitUntilFalse): Deleted.
2227
2228 2018-02-16  Filip Pizlo  <fpizlo@apple.com>
2229
2230         Unreviewed, roll out r228306 (custom memcpy/memset) because the bots say that it was not a
2231         progression.
2232
2233         * bmalloc/Algorithm.h:
2234         (bmalloc::fastCopy): Deleted.
2235         (bmalloc::fastZeroFill): Deleted.
2236         * bmalloc/Allocator.cpp:
2237         (bmalloc::Allocator::reallocate):
2238         * bmalloc/Bits.h:
2239         (bmalloc::BitsWordOwner::operator=):
2240         (bmalloc::BitsWordOwner::clearAll):
2241         (bmalloc::BitsWordOwner::set):
2242         * bmalloc/IsoPageInlines.h:
2243         (bmalloc::IsoPage<Config>::IsoPage):
2244         * bmalloc/Vector.h:
2245         (bmalloc::Vector<T>::reallocateBuffer):
2246
2247 2018-02-09  Carlos Alberto Lopez Perez  <clopez@igalia.com>
2248
2249         Improve of string.h include after r228317.
2250         https://bugs.webkit.org/show_bug.cgi?id=182642
2251
2252         Reviewed by Mark Lam.
2253
2254         * bmalloc/Algorithm.h: Avoid an architecture-specific #include.
2255
2256 2018-02-09  Carlos Alberto Lopez Perez  <clopez@igalia.com>
2257
2258         Fix build for !BCPU(X86_64) after r228306
2259         https://bugs.webkit.org/show_bug.cgi?id=182563
2260
2261         Unreviewed build fix.
2262
2263         * bmalloc/Algorithm.h:
2264
2265 2018-02-08  Filip Pizlo  <fpizlo@apple.com>
2266
2267         Experiment with alternative implementation of memcpy/memset
2268         https://bugs.webkit.org/show_bug.cgi?id=182563
2269
2270         Reviewed by Michael Saboff and Mark Lam.
2271         
2272         Add a faster x86_64-specific implementation of memcpy and memset. Ideally, this would just be
2273         implemented in WTF, but we have to copy it into bmalloc since bmalloc sits below WTF on the
2274         stack.
2275
2276         * bmalloc/Algorithm.h:
2277         (bmalloc::fastCopy):
2278         (bmalloc::fastZeroFill):
2279         * bmalloc/Allocator.cpp:
2280         (bmalloc::Allocator::reallocate):
2281         * bmalloc/Bits.h:
2282         (bmalloc::BitsWordOwner::operator=):
2283         (bmalloc::BitsWordOwner::clearAll):
2284         (bmalloc::BitsWordOwner::set):
2285         * bmalloc/IsoPageInlines.h:
2286         (bmalloc::IsoPage<Config>::IsoPage):
2287         * bmalloc/Vector.h:
2288         (bmalloc::Vector<T>::reallocateBuffer):
2289
2290 2018-02-05  JF Bastien  <jfbastien@apple.com>
2291
2292         Gigacage: enable only for WebContent process and token executables
2293         https://bugs.webkit.org/show_bug.cgi?id=182457
2294         <rdar://problem/35875011>
2295
2296         Reviewed by Keith Miller.
2297
2298         Gigacage is a solid security improvement, but it's probably best
2299         to roll it out incrementally to the most valuable targets first
2300         and progressively try out more and more over time rather than
2301         outright enabling it everywhere. We've gotten some reports that it
2302         has some side-effects that weren't expected, so for now let's
2303         enable it for the WebContent process, JSC, and other executables
2304         we know, and then later we'll enable more gigacage uses.
2305
2306         For now I've chosen the following bundles:
2307
2308           - com.apple.WebKit.WebContent.Development
2309           - com.apple.WebKit.WebContent
2310           - com.apple.WebProcess
2311
2312         And the following processes:
2313
2314           - jsc
2315           - wasm
2316           - anything starting with "test", to match the JSC tests
2317
2318         I tried a different approach first, where I add a function to turn
2319         gigacage on or off and crash if gigacage is initialized without
2320         having been told what to do. Doing this in ChildProcess and a
2321         bunch of the process initialization methods isn't sufficient. I
2322         got MiniBrowser working, but some other builds use static globals
2323         which themselves use hash and string which are allocate with
2324         bmalloc and therefore which initialize gigacage before main is
2325         called and before the process gets a chance to opt in our out. It
2326         gets tricky with API calls too, because we have to do the right
2327         thing in any entry an API user could plausibly use, even the
2328         private ones, so I endend up having to initialize gigacage in e.g.
2329         WebPreferencesExperimentalFeatures.cpp.erb.
2330
2331         Another approach could be to create a free-for-all gigacage
2332         entitlement, and opt-in the processes we want..
2333
2334         As a follow-up we can also check that gigacage allocation always
2335         succeeds if it was allowed for that process. With my change I
2336         expect it to always succeed.
2337
2338         * CMakeLists.txt:
2339         * bmalloc.xcodeproj/project.pbxproj:
2340         * bmalloc/BPlatform.h:
2341         * bmalloc/Gigacage.cpp:
2342         (Gigacage::shouldBeEnabled):
2343         * bmalloc/ProcessCheck.h: Added.
2344         (bmalloc::gigacageEnabledForProcess):
2345         * bmalloc/ProcessCheck.mm: Added.
2346         (bmalloc::gigacageEnabledForProcess):
2347
2348 2018-02-05  Joseph Pecoraro  <pecoraro@apple.com>
2349
2350         Multiple bmalloc scavenger threads is unexpected
2351         https://bugs.webkit.org/show_bug.cgi?id=182474
2352         <rdar://problem/37175526>
2353
2354         Reviewed by Filip Pizlo.
2355
2356         * bmalloc/Heap.cpp:
2357         (bmalloc::Heap::Heap):
2358         * bmalloc/IsoDirectoryInlines.h:
2359         (bmalloc::passedNumPages>::takeFirstEligible):
2360         (bmalloc::passedNumPages>::didBecome):
2361         * bmalloc/bmalloc.cpp:
2362         (bmalloc::api::scavenge):
2363         (bmalloc::api::setScavengerThreadQOSClass):
2364         Switch to SafePerProcess for Scavenger to ensure one instance
2365         for the entire process.
2366
2367         * bmalloc/PerProcess.h:
2368         (bmalloc::PerProcess::get):
2369         (bmalloc::PerProcess::getFastCase):
2370         (bmalloc::PerProcess::getSlowCase):
2371         (bmalloc::SafePerProcess::get):
2372         (bmalloc::SafePerProcess::getFastCase):
2373         (bmalloc::SafePerProcess::getSlowCase):
2374         Duplicate the class with a version that can ensure
2375         single instances by requiring exporting symbols that
2376         can be created with macros.
2377
2378         * bmalloc/Scavenger.cpp:
2379         * bmalloc/Scavenger.h:
2380         Export symbols to ensure all images get the same instance.
2381
2382 2018-01-31  Saam Barati  <sbarati@apple.com>
2383
2384         Replace tryLargeMemalignVirtual with tryLargeZeroedMemalignVirtual and use it to allocate large zeroed memory in Wasm
2385         https://bugs.webkit.org/show_bug.cgi?id=182064
2386         <rdar://problem/36840132>
2387
2388         Reviewed by Geoffrey Garen.
2389
2390         This patch replaces the tryLargeMemalignVirtual API with tryLargeZeroedMemalignVirtual.
2391         By doing that, we're able to remove the AllocationKind enum. To zero the memory,
2392         tryLargeZeroedMemalignVirtual uses mmap(... MAP_ANON ...) over previously mmapped
2393         memory. This both purges the any resident memory for the virtual range and ensures
2394         that the pages in the range are zeroed. Most OSs should implement this by taking a
2395         page fault and zero filling on first access. Therefore, this API is returning pages
2396         that will result in page faults on first access. Hence, the name 'virtual' in the API.
2397         This API differs from the old API in that users of it need not call madvise themselves.
2398         The memory is ready to go.
2399
2400         * bmalloc.xcodeproj/project.pbxproj:
2401         * bmalloc/AllocationKind.h: Removed.
2402         * bmalloc/DebugHeap.cpp:
2403         (bmalloc::DebugHeap::memalignLarge):
2404         (bmalloc::DebugHeap::freeLarge):
2405         * bmalloc/DebugHeap.h:
2406         * bmalloc/Heap.cpp:
2407         (bmalloc::Heap::splitAndAllocate):
2408         (bmalloc::Heap::tryAllocateLarge):
2409         (bmalloc::Heap::allocateLarge):
2410         (bmalloc::Heap::shrinkLarge):
2411         (bmalloc::Heap::deallocateLarge):
2412         * bmalloc/Heap.h:
2413         * bmalloc/IsoPage.cpp:
2414         (bmalloc::IsoPageBase::allocatePageMemory):
2415         * bmalloc/VMAllocate.h:
2416         (bmalloc::vmZeroAndPurge):
2417         * bmalloc/VMHeap.cpp:
2418         (bmalloc::VMHeap::tryAllocateLargeChunk):
2419         * bmalloc/VMHeap.h:
2420         * bmalloc/bmalloc.cpp:
2421         (bmalloc::api::tryLargeZeroedMemalignVirtual):
2422         (bmalloc::api::freeLargeVirtual):
2423         (bmalloc::api::tryLargeMemalignVirtual): Deleted.
2424         * bmalloc/bmalloc.h:
2425
2426 2018-01-19  Keith Miller  <keith_miller@apple.com>
2427
2428         HaveInternalSDK includes should be "#include?"
2429         https://bugs.webkit.org/show_bug.cgi?id=179670
2430
2431         Reviewed by Dan Bernstein.
2432
2433         * Configurations/Base.xcconfig:
2434
2435 2018-01-18  Dan Bernstein  <mitz@apple.com>
2436
2437         [Xcode] Streamline and future-proof target-macOS-version-dependent build setting definitions
2438         https://bugs.webkit.org/show_bug.cgi?id=181803
2439
2440         Reviewed by Tim Horton.
2441
2442         * Configurations/Base.xcconfig: Updated.
2443         * Configurations/DebugRelease.xcconfig: Ditto.
2444
2445 2018-01-16  Michael Catanzaro  <mcatanzaro@igalia.com>
2446
2447         mbmalloc should only be built in developer mode
2448         https://bugs.webkit.org/show_bug.cgi?id=181654
2449
2450         Reviewed by Carlos Garcia Campos.
2451
2452         * CMakeLists.txt:
2453
2454 2018-01-15  Michael Catanzaro  <mcatanzaro@igalia.com>
2455
2456         Improve use of ExportMacros
2457         https://bugs.webkit.org/show_bug.cgi?id=181652
2458
2459         Reviewed by Konstantin Tokarev.
2460
2461         Disable BEXPORT on Linux ports.
2462
2463         * bmalloc/BExport.h: Check for BUSE(EXPORT_MACROS).
2464         * bmalloc/BPlatform.h: Add BUSE(EXPORT_MACROS) and define it on macOS and iOS.
2465
2466 2017-12-20  Ting-Wei Lan  <lantw44@gmail.com>
2467
2468         Include stdio.h before using stderr and _IONBF
2469         https://bugs.webkit.org/show_bug.cgi?id=181046
2470
2471         Reviewed by Alex Christensen.
2472
2473         * bmalloc/IsoTLS.cpp:
2474
2475 2017-12-14  David Kilzer  <ddkilzer@apple.com>
2476
2477         Enable -Wstrict-prototypes for WebKit
2478         <https://webkit.org/b/180757>
2479         <rdar://problem/36024132>
2480
2481         Rubber-stamped by Joseph Pecoraro.
2482
2483         * Configurations/Base.xcconfig:
2484         (CLANG_WARN_STRICT_PROTOTYPES): Add. Set to YES.
2485
2486 2017-12-14  Saam Barati  <sbarati@apple.com>
2487
2488         logVMFailure should not simulate crash on iOS
2489         https://bugs.webkit.org/show_bug.cgi?id=180790
2490
2491         Reviewed by JF Bastien.
2492
2493         The Gigacage allocation on iOS is expected to fail in certain circumstances. 
2494         Let's not simulate a crash on failure because since this is expected behavior.
2495
2496         * bmalloc/VMAllocate.h:
2497         (bmalloc::tryVMAllocate):
2498
2499 2017-12-11  Tim Horton  <timothy_horton@apple.com>
2500
2501         Stop using deprecated target conditional for simulator builds
2502         https://bugs.webkit.org/show_bug.cgi?id=180662
2503         <rdar://problem/35136156>
2504
2505         Reviewed by Simon Fraser.
2506
2507         * bmalloc/BPlatform.h:
2508
2509 2017-12-08  Saam Barati  <sbarati@apple.com>
2510
2511         Enable gigacage on iOS with a 32GB runway and ensure it doesn't break WasmBench
2512         https://bugs.webkit.org/show_bug.cgi?id=178557
2513
2514         Reviewed by Mark Lam.
2515
2516         * bmalloc/Algorithm.h:
2517         (bmalloc::isPowerOfTwo):
2518         * bmalloc/Gigacage.cpp:
2519         * bmalloc/Gigacage.h:
2520
2521 2017-12-05  Andy Estes  <aestes@apple.com>
2522
2523         [Darwin] Simplify use of TargetConditionals
2524         https://bugs.webkit.org/show_bug.cgi?id=180455
2525         <rdar://problem/35142971>
2526
2527         Reviewed by Tim Horton.
2528
2529         There's no need to check if TARGET_* macros are defined on Darwin platforms, since
2530         TargetConditionals.h always defines them. Also, we can simplify
2531         (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR) to TARGET_OS_IPHONE.
2532
2533         * bmalloc/BPlatform.h:
2534
2535 2017-12-05  Filip Pizlo  <fpizlo@apple.com>
2536
2537         bmalloc IsoHeap needs to allow a thread to deallocate some size for the first time
2538         https://bugs.webkit.org/show_bug.cgi?id=180443
2539
2540         Reviewed by Saam Barati.
2541
2542         It's true that we can expect a heap to already be initialized if we try to deallocate in it.  But it
2543         may not have its deallocator initialized on this thread yet.
2544         
2545         This is easily fixed by adding a null check on the deallocate path. That's probably not going to
2546         change perf at all. But doing that allows me to get rid of a lot of weird stuff I previously did to
2547         avoid that null check, like creating a dummy TLS in the DebugHeap case.
2548
2549         * bmalloc/IsoTLS.cpp:
2550         (bmalloc::IsoTLS::debugFree):
2551         (bmalloc::IsoTLS::deallocateSlow): Deleted.
2552         * bmalloc/IsoTLS.h:
2553         * bmalloc/IsoTLSInlines.h:
2554         (bmalloc::IsoTLS::allocateImpl):
2555         (bmalloc::IsoTLS::allocateSlow):
2556         (bmalloc::IsoTLS::deallocateImpl):
2557         (bmalloc::IsoTLS::deallocateSlow):
2558         (bmalloc::IsoTLS::ensureHeapAndEntries):
2559
2560 2017-12-01  Michael Saboff  <msaboff@apple.com>
2561
2562         Gigacage should not be enabled for ARM64_32
2563         https://bugs.webkit.org/show_bug.cgi?id=180265
2564
2565         Reviewed by Saam Barati.
2566
2567         Disabled Gigacage for ARM64_32.
2568         In the process, restructured Gigacage::shouldBeEnabled() with GIGACAGE_ENABLED set
2569         to 0 to avoid a dead code compiler warning.
2570
2571         * bmalloc/Gigacage.cpp:
2572         (Gigacage::shouldBeEnabled):
2573         * bmalloc/Gigacage.h:
2574
2575 2017-11-29  JF Bastien  <jfbastien@apple.com>
2576
2577         WTF / bmalloc: don't write to 0xbbadbeef when ASAN is looking
2578         https://bugs.webkit.org/show_bug.cgi?id=180175
2579
2580         Reviewed by Mark Lam.
2581
2582         ASAN knows that 0xbbadbeef is a bbad aaddress, and tells us so
2583         when we write to it, say in an assert. That creates bbad error
2584         reports where ASAN thinks we write to an invalid address, instead
2585         of thinking that we hit an assertion. In some cases, tooling that
2586         use fuzzers aggregate similar issues, and think that we just have
2587         the one bug and not a bunch of different asserts.
2588
2589         At the same time, bmalloc's version of CRASH just writes to
2590         0xbbadbeef and assumes that's invalid and will crash, which isn't
2591         necessarily true on non-Mac platforms. WTF's version then makes
2592         sure there's a crash, so bmalloc should do the same.
2593
2594         * bmalloc.xcodeproj/project.pbxproj:
2595         * bmalloc/BAssert.h:
2596         * bmalloc/BCompiler.h: Added.
2597         * bmalloc/BPlatform.h:
2598
2599 2017-11-27  Filip Pizlo  <fpizlo@apple.com>
2600
2601         Don't crash in forEachEntry when DebugHeap is enabled.
2602
2603         Unreviewed, fixing crashes on leaks bots by removing an assertion.
2604
2605         * bmalloc/IsoTLS.cpp:
2606         (bmalloc::IsoTLS::forEachEntry):
2607         * test/testbmalloc.cpp: Make this test work with DebugHeap so I can catch this kind of problem in the future.
2608
2609 2017-11-16  Filip Pizlo  <fpizlo@apple.com>
2610
2611         Isolated Heaps caused an increase in reported leaks on the bots
2612         https://bugs.webkit.org/show_bug.cgi?id=179463
2613
2614         Reviewed by Darin Adler.
2615         
2616         This fixes the way isoheaps interact with system tools:
2617         
2618         - Opts into the VMHeap API so that the leaks tool can find isoheap memory.
2619         
2620         - Opts into the DebugHeap/Environment APIs so that we turn off isoheap allocation if memory
2621           debugging options are in use.
2622
2623         * bmalloc.xcodeproj/project.pbxproj:
2624         * bmalloc/DebugHeap.h:
2625         * bmalloc/IsoHeap.h:
2626         * bmalloc/IsoPage.cpp: Added.
2627         (bmalloc::IsoPageBase::allocatePageMemory):
2628         * bmalloc/IsoPage.h:
2629         * bmalloc/IsoPageInlines.h:
2630         (bmalloc::IsoPage<Config>::tryCreate):
2631         * bmalloc/IsoTLS.cpp:
2632         (bmalloc::IsoTLS::deallocateSlow):
2633         (bmalloc::IsoTLS::ensureEntries):
2634         (bmalloc::IsoTLS::isUsingDebugHeap):
2635         (bmalloc::IsoTLS::debugMalloc):
2636         * bmalloc/IsoTLS.h:
2637         * bmalloc/IsoTLSInlines.h:
2638         (bmalloc::IsoTLS::allocate):
2639         (bmalloc::IsoTLS::deallocate):
2640         (bmalloc::IsoTLS::allocateImpl):
2641         (bmalloc::IsoTLS::allocateFast):
2642         (bmalloc::IsoTLS::allocateSlow):
2643         (bmalloc::IsoTLS::deallocateImpl):
2644         (bmalloc::IsoTLS::deallocateFast):
2645         (bmalloc::IsoTLS::ensureHeapAndEntries):
2646         (bmalloc::IsoTLS::allocator): Deleted.
2647         (bmalloc::IsoTLS::deallocator): Deleted.
2648         * bmalloc/bmalloc.cpp:
2649         (bmalloc::api::tryLargeMemalignVirtual):
2650         (bmalloc::api::freeLargeVirtual):
2651         (bmalloc::api::scavenge):
2652         (bmalloc::api::isEnabled):
2653         (bmalloc::api::setScavengerThreadQOSClass):
2654         * bmalloc/bmalloc.h:
2655         (bmalloc::api::tryLargeMemalignVirtual): Deleted.
2656         (bmalloc::api::freeLargeVirtual): Deleted.
2657         (bmalloc::api::scavenge): Deleted.
2658         (bmalloc::api::isEnabled): Deleted.
2659         (bmalloc::api::setScavengerThreadQOSClass): Deleted.
2660
2661 2017-11-14  Saam Barati  <sbarati@apple.com>
2662
2663         Make the gigacage runway 32GB
2664         https://bugs.webkit.org/show_bug.cgi?id=175062
2665
2666         Reviewed by Mark Lam.
2667
2668         Making the gigacage runway 32GB defends us against buffer overflows in the
2669         cage reaching memory outside the cage assuming indices are 32-bit unsigned
2670         integers and the type they're indexing into has size <= 8 bytes. This is
2671         exactly the case for many things in JSC. For example, butterfly access in
2672         JSC meet this criteria, as does typed array access.
2673         
2674         The 32GB comes from 8 * 2^32 = 32GB.
2675
2676         * bmalloc/Gigacage.cpp:
2677
2678 2017-11-08  Michael Catanzaro  <mcatanzaro@igalia.com>
2679
2680         Gigacage.cpp:44:46: warning: ‘*’ in boolean context, suggest ‘&&’ instead [-Wint-in-bool-context]
2681         https://bugs.webkit.org/show_bug.cgi?id=179427
2682
2683         Reviewed by Saam Barati.
2684
2685         Tweak the conditional to suppress the warning.
2686
2687         * bmalloc/Gigacage.cpp:
2688         (Gigacage::ensureGigacage):
2689
2690 2017-11-07  Saam Barati  <sbarati@apple.com>
2691
2692         We should PROT_NONE the Gigacage runway so OOB accesses crash
2693         https://bugs.webkit.org/show_bug.cgi?id=179392
2694
2695         Reviewed by Mark Lam.
2696
2697         If we assume that an attacker will exploit JSC and cause OOB accesses,
2698         we should make OOB accesses in the Gigacage runway crash.
2699
2700         * bmalloc/Gigacage.cpp:
2701         (Gigacage::ensureGigacage):
2702
2703 2017-10-31  Filip Pizlo  <fpizlo@apple.com>
2704
2705         bmalloc should support strictly type-segregated isolated heaps
2706         https://bugs.webkit.org/show_bug.cgi?id=178108
2707
2708         Reviewed by Saam Barati, Simon Fraser, and Ryosuke Niwa.
2709         
2710         This introduces a new allocation API in bmalloc called IsoHeap. An IsoHeap is templatized by
2711         type and created in static storage. When unused, it takes only a few words. When you do use
2712         it, each IsoHeap gets a bag of virtual pages unique to it. This prevents use-after-free bugs
2713         in one IsoHeap from affecting any other memory. At worst, two pointers of the same type will
2714         point to the same object even though they should not have.
2715         
2716         IsoHeaps allocate using a first-fit discipline that combines ideas from bmalloc and Riptide
2717         (the JSC GC):
2718         
2719         Like Riptide, it uses a bump'n'pop allocator. What Riptide calls blocks, IsoHeaps calls
2720         pages. Pages are collected into directories. Directories track pages using bitvectors, so
2721         that it's easy to quickly find a completely free page or one that has at least one free
2722         object. I think that the bump'n'pop allocator is as fast as the bmalloc Immix-style (page and
2723         line) allocator, but is better at allocating in holes. It's guaranteed to follow a first-fit
2724         discipline. However, the real reason why I wrote it that was is that this is what I'm more
2725         familiar with. This is a part of the design I want to revisit (bug 179278).
2726         
2727         Like bmalloc, it uses a deallocation log. This means that the internal IsoHeap data
2728         structures can be locked with a coarse-grained lock, since the deallocator only grabs it when
2729         flushing the log. Similarly, the allocator only grabs it when refilling the bump'n'pop
2730         FreeList.
2731         
2732         This adds a unit test for IsoHeaps. In this change, IsoHeaps are adopted only by WebCore's
2733         RenderObject.
2734         
2735         Note that despite the use of GC concepts, it's not a goal to make this code directly sharable
2736         with GC. The GC will probably have to do isolated heaps its own way (likely a special
2737         Subspace or something like that).
2738
2739         * bmalloc.xcodeproj/project.pbxproj:
2740         * bmalloc/Algorithm.h:
2741         (bmalloc::findBitInWord):
2742         * bmalloc/AllIsoHeaps.cpp: Added.
2743         (bmalloc::AllIsoHeaps::AllIsoHeaps):
2744         (bmalloc::AllIsoHeaps::add):
2745         (bmalloc::AllIsoHeaps::head):
2746         * bmalloc/AllIsoHeaps.h: Added.
2747         * bmalloc/AllIsoHeapsInlines.h: Added.
2748         (bmalloc::AllIsoHeaps::forEach):
2749         * bmalloc/BMalloced.h: Added.
2750         * bmalloc/Bits.h: Added.
2751         (bmalloc::bitsArrayLength):
2752         (bmalloc::BitsWordView::BitsWordView):
2753         (bmalloc::BitsWordView::numBits const):
2754         (bmalloc::BitsWordView::word const):
2755         (bmalloc::BitsWordOwner::BitsWordOwner):
2756         (bmalloc::BitsWordOwner::view const):
2757         (bmalloc::BitsWordOwner::operator=):
2758         (bmalloc::BitsWordOwner::setAll):
2759         (bmalloc::BitsWordOwner::clearAll):
2760         (bmalloc::BitsWordOwner::set):
2761         (bmalloc::BitsWordOwner::numBits const):
2762         (bmalloc::BitsWordOwner::arrayLength const):
2763         (bmalloc::BitsWordOwner::word const):
2764         (bmalloc::BitsWordOwner::word):
2765         (bmalloc::BitsWordOwner::words const):
2766         (bmalloc::BitsWordOwner::words):
2767         (bmalloc::BitsAndWords::BitsAndWords):
2768         (bmalloc::BitsAndWords::view const):
2769         (bmalloc::BitsAndWords::numBits const):
2770         (bmalloc::BitsAndWords::word const):
2771         (bmalloc::BitsOrWords::BitsOrWords):
2772         (bmalloc::BitsOrWords::view const):
2773         (bmalloc::BitsOrWords::numBits const):
2774         (bmalloc::BitsOrWords::word const):
2775         (bmalloc::BitsNotWords::BitsNotWords):
2776         (bmalloc::BitsNotWords::view const):
2777         (bmalloc::BitsNotWords::numBits const):
2778         (bmalloc::BitsNotWords::word const):
2779         (bmalloc::BitsImpl::BitsImpl):
2780         (bmalloc::BitsImpl::numBits const):
2781         (bmalloc::BitsImpl::size const):
2782         (bmalloc::BitsImpl::arrayLength const):
2783         (bmalloc::BitsImpl::operator== const):
2784         (bmalloc::BitsImpl::operator!= const):
2785         (bmalloc::BitsImpl::at const):
2786         (bmalloc::BitsImpl::operator[] const):
2787         (bmalloc::BitsImpl::isEmpty const):
2788         (bmalloc::BitsImpl::operator& const):
2789         (bmalloc::BitsImpl::operator| const):
2790         (bmalloc::BitsImpl::operator~ const):
2791         (bmalloc::BitsImpl::forEachSetBit const):
2792         (bmalloc::BitsImpl::forEachClearBit const):
2793         (bmalloc::BitsImpl::forEachBit const):
2794         (bmalloc::BitsImpl::findBit const):
2795         (bmalloc::BitsImpl::findSetBit const):
2796         (bmalloc::BitsImpl::findClearBit const):
2797         (bmalloc::BitsImpl::wordView const):
2798         (bmalloc::BitsImpl::atImpl const):
2799         (bmalloc::Bits::Bits):
2800         (bmalloc::Bits::operator=):
2801         (bmalloc::Bits::resize):
2802         (bmalloc::Bits::setAll):
2803         (bmalloc::Bits::clearAll):
2804         (bmalloc::Bits::setAndCheck):
2805         (bmalloc::Bits::operator|=):
2806         (bmalloc::Bits::operator&=):
2807         (bmalloc::Bits::at const):
2808         (bmalloc::Bits::operator[] const):
2809         (bmalloc::Bits::BitReference::BitReference):
2810         (bmalloc::Bits::BitReference::operator bool const):
2811         (bmalloc::Bits::BitReference::operator=):
2812         (bmalloc::Bits::at):
2813         (bmalloc::Bits::operator[]):
2814         * bmalloc/CryptoRandom.cpp: Replaced with Source/bmalloc/bmalloc/CryptoRandom.cpp.
2815         (bmalloc::cryptoRandom):
2816         * bmalloc/CryptoRandom.h: Replaced with Source/bmalloc/bmalloc/CryptoRandom.h.
2817         * bmalloc/DeferredDecommit.h: Added.
2818         * bmalloc/DeferredDecommitInlines.h: Added.
2819         (bmalloc::DeferredDecommit::DeferredDecommit):
2820         * bmalloc/DeferredTrigger.h: Added.
2821         (bmalloc::DeferredTrigger::DeferredTrigger):
2822         * bmalloc/DeferredTriggerInlines.h: Added.
2823         (bmalloc::DeferredTrigger<trigger>::didBecome):
2824         (bmalloc::DeferredTrigger<trigger>::handleDeferral):
2825         * bmalloc/EligibilityResult.h: Added.
2826         (bmalloc::EligibilityResult::EligibilityResult):
2827         * bmalloc/EligibilityResultInlines.h: Added.
2828         (bmalloc::EligibilityResult<Config>::EligibilityResult):
2829         * bmalloc/FixedVector.h:
2830         * bmalloc/FreeList.cpp: Added.
2831         (bmalloc::FreeList::FreeList):
2832         (bmalloc::FreeList::~FreeList):
2833         (bmalloc::FreeList::clear):
2834         (bmalloc::FreeList::initializeList):
2835         (bmalloc::FreeList::initializeBump):
2836         (bmalloc::FreeList::contains const):
2837         * bmalloc/FreeList.h: Added.
2838         (bmalloc::FreeCell::scramble):
2839         (bmalloc::FreeCell::descramble):
2840         (bmalloc::FreeCell::setNext):
2841         (bmalloc::FreeCell::next const):
2842         (bmalloc::FreeList::allocationWillFail const):
2843         (bmalloc::FreeList::allocationWillSucceed const):
2844         (bmalloc::FreeList::originalSize const):
2845         (bmalloc::FreeList::head const):
2846         * bmalloc/FreeListInlines.h: Added.
2847         (bmalloc::FreeList::allocate):
2848         (bmalloc::FreeList::forEach const):
2849         * bmalloc/IsoAllocator.h: Added.
2850         * bmalloc/IsoAllocatorInlines.h: Added.
2851         (bmalloc::IsoAllocator<Config>::IsoAllocator):
2852         (bmalloc::IsoAllocator<Config>::~IsoAllocator):
2853         (bmalloc::IsoAllocator<Config>::allocate):
2854         (bmalloc::IsoAllocator<Config>::allocateSlow):
2855         (bmalloc::IsoAllocator<Config>::scavenge):
2856         * bmalloc/IsoConfig.h: Added.
2857         * bmalloc/IsoDeallocator.h: Added.
2858         * bmalloc/IsoDeallocatorInlines.h: Added.
2859         (bmalloc::IsoDeallocator<Config>::IsoDeallocator):
2860         (bmalloc::IsoDeallocator<Config>::~IsoDeallocator):
2861         (bmalloc::IsoDeallocator<Config>::deallocate):
2862         (bmalloc::IsoDeallocator<Config>::scavenge):
2863         * bmalloc/IsoDirectory.h: Added.
2864         (bmalloc::IsoDirectoryBaseBase::IsoDirectoryBaseBase):
2865         (bmalloc::IsoDirectoryBaseBase::~IsoDirectoryBaseBase):
2866         (bmalloc::IsoDirectoryBase::heap):
2867         * bmalloc/IsoDirectoryInlines.h: Added.
2868         (bmalloc::IsoDirectoryBase<Config>::IsoDirectoryBase):
2869         (bmalloc::passedNumPages>::IsoDirectory):
2870         (bmalloc::passedNumPages>::takeFirstEligible):
2871         (bmalloc::passedNumPages>::didBecome):
2872         (bmalloc::passedNumPages>::didDecommit):
2873         (bmalloc::passedNumPages>::scavenge):
2874         (bmalloc::passedNumPages>::forEachCommittedPage):
2875         * bmalloc/IsoDirectoryPage.h: Added.
2876         (bmalloc::IsoDirectoryPage::index const):
2877         * bmalloc/IsoDirectoryPageInlines.h: Added.
2878         (bmalloc::IsoDirectoryPage<Config>::IsoDirectoryPage):
2879         (bmalloc::IsoDirectoryPage<Config>::pageFor):
2880         * bmalloc/IsoHeap.h: Added.
2881         (bmalloc::api::IsoHeap::allocatorOffset):
2882         (bmalloc::api::IsoHeap::setAllocatorOffset):
2883         (bmalloc::api::IsoHeap::deallocatorOffset):
2884         (bmalloc::api::IsoHeap::setDeallocatorOffset):
2885         * bmalloc/IsoHeapImpl.cpp: Added.
2886         (bmalloc::IsoHeapImplBase::IsoHeapImplBase):
2887         (bmalloc::IsoHeapImplBase::~IsoHeapImplBase):
2888         (bmalloc::IsoHeapImplBase::scavengeNow):
2889         (bmalloc::IsoHeapImplBase::finishScavenging):
2890         * bmalloc/IsoHeapImpl.h: Added.
2891         * bmalloc/IsoHeapImplInlines.h: Added.
2892         (bmalloc::IsoHeapImpl<Config>::IsoHeapImpl):
2893         (bmalloc::IsoHeapImpl<Config>::takeFirstEligible):
2894         (bmalloc::IsoHeapImpl<Config>::didBecomeEligible):
2895         (bmalloc::IsoHeapImpl<Config>::scavenge):
2896         (bmalloc::IsoHeapImpl<Config>::allocatorOffset):
2897         (bmalloc::IsoHeapImpl<Config>::deallocatorOffset):
2898         (bmalloc::IsoHeapImpl<Config>::numLiveObjects):
2899         (bmalloc::IsoHeapImpl<Config>::numCommittedPages):
2900         (bmalloc::IsoHeapImpl<Config>::forEachDirectory):
2901         (bmalloc::IsoHeapImpl<Config>::forEachCommittedPage):
2902         (bmalloc::IsoHeapImpl<Config>::forEachLiveObject):
2903         * bmalloc/IsoHeapInlines.h: Added.
2904         (bmalloc::api::IsoHeap<Type>::allocate):
2905         (bmalloc::api::IsoHeap<Type>::tryAllocate):
2906         (bmalloc::api::IsoHeap<Type>::deallocate):
2907         (bmalloc::api::IsoHeap<Type>::scavenge):
2908         (bmalloc::api::IsoHeap<Type>::isInitialized):
2909         (bmalloc::api::IsoHeap<Type>::impl):
2910         * bmalloc/IsoPage.h: Added.
2911         (bmalloc::IsoPage::index const):
2912         (bmalloc::IsoPage::directory):
2913         (bmalloc::IsoPage::isInUseForAllocation const):
2914         (bmalloc::IsoPage::indexOfFirstObject):
2915         * bmalloc/IsoPageInlines.h: Added.
2916         (bmalloc::IsoPage<Config>::tryCreate):
2917         (bmalloc::IsoPage<Config>::IsoPage):
2918         (bmalloc::IsoPage<Config>::free):
2919         (bmalloc::IsoPage<Config>::startAllocating):
2920         (bmalloc::IsoPage<Config>::stopAllocating):
2921         (bmalloc::IsoPage<Config>::forEachLiveObject):
2922         * bmalloc/IsoPageTrigger.h: Added.
2923         * bmalloc/IsoTLS.cpp: Added.
2924         (bmalloc::IsoTLS::scavenge):
2925         (bmalloc::IsoTLS::IsoTLS):
2926         (bmalloc::IsoTLS::ensureEntries):
2927         (bmalloc::IsoTLS::destructor):
2928         (bmalloc::IsoTLS::sizeForCapacity):
2929         (bmalloc::IsoTLS::capacityForSize):
2930         (bmalloc::IsoTLS::size):
2931         (bmalloc::IsoTLS::forEachEntry):
2932         * bmalloc/IsoTLS.h: Added.
2933         * bmalloc/IsoTLSAllocatorEntry.h: Added.
2934         * bmalloc/IsoTLSAllocatorEntryInlines.h: Added.
2935         (bmalloc::IsoTLSAllocatorEntry<Config>::IsoTLSAllocatorEntry):
2936         (bmalloc::IsoTLSAllocatorEntry<Config>::~IsoTLSAllocatorEntry):
2937         (bmalloc::IsoTLSAllocatorEntry<Config>::construct):
2938         * bmalloc/IsoTLSDeallocatorEntry.h: Added.
2939         * bmalloc/IsoTLSDeallocatorEntryInlines.h: Added.
2940         (bmalloc::IsoTLSDeallocatorEntry<Config>::IsoTLSDeallocatorEntry):
2941         (bmalloc::IsoTLSDeallocatorEntry<Config>::~IsoTLSDeallocatorEntry):
2942         (bmalloc::IsoTLSDeallocatorEntry<Config>::construct):
2943         * bmalloc/IsoTLSEntry.cpp: Added.
2944         (bmalloc::IsoTLSEntry::IsoTLSEntry):
2945         (bmalloc::IsoTLSEntry::~IsoTLSEntry):
2946         * bmalloc/IsoTLSEntry.h: Added.
2947         (bmalloc::IsoTLSEntry::offset const):
2948         (bmalloc::IsoTLSEntry::alignment const):
2949         (bmalloc::IsoTLSEntry::size const):
2950         (bmalloc::IsoTLSEntry::extent const):
2951         * bmalloc/IsoTLSEntryInlines.h: Added.
2952         (bmalloc::IsoTLSEntry::walkUpToInclusive):
2953         (bmalloc::DefaultIsoTLSEntry<EntryType>::DefaultIsoTLSEntry):
2954         (bmalloc::DefaultIsoTLSEntry<EntryType>::~DefaultIsoTLSEntry):
2955         (bmalloc::DefaultIsoTLSEntry<EntryType>::move):
2956         (bmalloc::DefaultIsoTLSEntry<EntryType>::destruct):
2957         (bmalloc::DefaultIsoTLSEntry<EntryType>::scavenge):
2958         * bmalloc/IsoTLSInlines.h: Added.
2959         (bmalloc::IsoTLS::allocate):
2960         (bmalloc::IsoTLS::deallocate):
2961         (bmalloc::IsoTLS::scavenge):
2962         (bmalloc::IsoTLS::allocator):
2963         (bmalloc::IsoTLS::deallocator):
2964         (bmalloc::IsoTLS::get):
2965         (bmalloc::IsoTLS::set):
2966         (bmalloc::IsoTLS::ensureHeap):
2967         (bmalloc::IsoTLS::ensureHeapAndEntries):
2968         * bmalloc/IsoTLSLayout.cpp: Added.
2969         (bmalloc::IsoTLSLayout::IsoTLSLayout):
2970         (bmalloc::IsoTLSLayout::add):
2971         * bmalloc/IsoTLSLayout.h: Added.
2972         (bmalloc::IsoTLSLayout::head const):
2973         * bmalloc/PerHeapKind.h:
2974         * bmalloc/PerProcess.h:
2975         (bmalloc::PerProcess<T>::getFastCase):
2976         * bmalloc/Scavenger.cpp:
2977         (bmalloc::Scavenger::scavenge):
2978         * bmalloc/Scavenger.h:
2979         * bmalloc/bmalloc.h:
2980         (bmalloc::api::scavengeThisThread):
2981         * test: Added.
2982         * test/testbmalloc.cpp: Added.
2983         (hiddenTruthBecauseNoReturnIsStupid):
2984         (usage):
2985         (assertEmptyPointerSet):
2986         (assertHasObjects):
2987         (assertHasOnlyObjects):
2988         (assertClean):
2989         (testIsoSimple):
2990         (testIsoSimpleScavengeBeforeDealloc):
2991         (testIsoFlipFlopFragmentedPages):
2992         (testIsoFlipFlopFragmentedPagesScavengeInMiddle):
2993         (BisoMalloced::BisoMalloced):
2994         (testBisoMalloced):
2995         (BisoMallocedInline::BisoMallocedInline):
2996         (testBisoMallocedInline):
2997         (run):
2998         (main):
2999
3000 2017-10-30  Zan Dobersek  <zdobersek@igalia.com>
3001
3002         [ARM64][Linux] Re-enable Gigacage
3003         https://bugs.webkit.org/show_bug.cgi?id=178130
3004
3005         Reviewed by Michael Catanzaro.
3006
3007         * bmalloc/Gigacage.h: Re-enable Gigacage on ARM64 Linux.
3008
3009 2017-10-25  Commit Queue  <commit-queue@webkit.org>
3010
3011         Unreviewed, rolling out r222945.
3012         https://bugs.webkit.org/show_bug.cgi?id=178818
3013
3014         "It made WasmBench crash" (Requested by saamyjoon on #webkit).
3015
3016         Reverted changeset:
3017
3018         "bmalloc mutex should be adaptive"
3019         https://bugs.webkit.org/show_bug.cgi?id=177839
3020         https://trac.webkit.org/changeset/222945
3021
3022 2017-10-24  Zan Dobersek  <zdobersek@igalia.com>
3023
3024         [Linux] Enable Gigacage in x64 Linux environment
3025         https://bugs.webkit.org/show_bug.cgi?id=177745
3026         <rdar://problem/34773148>
3027
3028         Reviewed by Yusuke Suzuki.
3029
3030         Re-enable Gigacage on x86_64 Linux platforms after it was disabled in 223877.
3031
3032         The cause for the revert was problems with huge coredumps being generated
3033         while Gigacage was enabled. The feature virtually allocates about 80GB of
3034         memory at the beginning of the process lifetime. This is not a problem in
3035         itself since the memory range is marked as not needed through madvise(),
3036         but all this memory was still included upon core dump generation on Linux.
3037         Since there are reasonable limits enforced upon core dumps, these were
3038         being truncated every time, not yielding any useful information.
3039
3040         To avoid this, on Linux, invocations of madvise() with the MADV_NORMAL and
3041         MADV_DONTNEED advice parameters should be accompanied with respectively
3042         matching MADV_DODUMP and MADV_DONTDUMP madvise() calls. This correctly
3043         avoids core-dumping any memory that's not yet been physically allocated.
3044
3045         * bmalloc/Gigacage.h:
3046         * bmalloc/VMAllocate.h:
3047         (bmalloc::vmDeallocatePhysicalPages):
3048         (bmalloc::vmAllocatePhysicalPages):
3049
3050 2017-10-24  David Kilzer  <ddkilzer@apple.com>
3051
3052         Need to pass non-nil argument to SimulateCrash() in bmalloc::logVMFailure()
3053         <https://webkit.org/b/178740>
3054         <rdar://problem/35154943>
3055
3056         Reviewed by Saam Barati.
3057
3058         * bmalloc/BPlatform.h:
3059         (BUNUSED_PARAM): Define macro.
3060         * bmalloc/Logging.cpp:
3061         (SimulateCrash): Change third argument of SimulateCrash() to
3062         CFStringRef since it's an NSString * in Objective-C.
3063         (bmalloc::logVMFailure): Create a CFStringRef to use as a
3064         description string.  Use new vmSize parameter to log size.
3065         * bmalloc/Logging.h:
3066         (bmalloc::logVMFailure): Update function signature to take a
3067         size_t parameter representing vmSize.
3068         * bmalloc/VMAllocate.h:
3069         (bmalloc::tryVMAllocate): Pass vmSize into logVMFailure().
3070
3071 2017-10-23  Michael Catanzaro  <mcatanzaro@igalia.com>
3072
3073         Unreviewed, roll out r222731
3074         https://bugs.webkit.org/show_bug.cgi?id=177745
3075         <rdar://problem/34773148>
3076
3077         Unfortunately Gigacage has broken core dump generation.
3078
3079         * bmalloc/Gigacage.h:
3080
3081 2017-10-23  Zan Dobersek  <zdobersek@igalia.com>
3082
3083         bmalloc::api::tryLargeMemalignVirtual() shouldn't assert on a failed allocation
3084         https://bugs.webkit.org/show_bug.cgi?id=178654
3085
3086         Reviewed by Geoffrey Garen.
3087
3088         * bmalloc/bmalloc.h:
3089         (bmalloc::api::tryLargeMemalignVirtual): Call Heap::tryAllocateLarge()
3090         instead of Heap::allocateLarge(). The former will return a null pointer
3091         upon a failed allocation, allowing the caller to fail gracefully just as
3092         the API entrypoint implies, while the latter currently provokes a crash
3093         in these circumstances.
3094
3095 2017-10-19  Saam Barati  <sbarati@apple.com>
3096
3097         Runtime disable gigacage on iOS because it broke WasmBench
3098         https://bugs.webkit.org/show_bug.cgi?id=178556
3099
3100         Reviewed by Keith Miller.
3101
3102         * bmalloc/Gigacage.cpp:
3103         (Gigacage::shouldBeEnabled):
3104
3105 2017-10-17  Filip Pizlo  <fpizlo@apple.com>
3106
3107         You can't vmDeallocate null
3108         <rdar://problem/35038926>
3109
3110         Reviewed by Michael Saboff.
3111         
3112         After failing allocation, we would try to deallocate the thing we failed to allocate. The fix is to
3113         not try to deallocate something that is obviously null.
3114
3115         * bmalloc/Gigacage.cpp:
3116         (Gigacage::ensureGigacage):
3117
3118 2017-09-29  Filip Pizlo  <fpizlo@apple.com>
3119
3120         Enable gigacage on iOS
3121         https://bugs.webkit.org/show_bug.cgi?id=177586
3122
3123         Reviewed by JF Bastien.
3124         
3125         Introduce the ability to disable gigacage at runtime if allocation fails. If any step of gigacage
3126         allocation fails, we free all of the gigacages and turn off gigacage support.
3127         
3128         Roll this back in after discussion.
3129
3130         * CMakeLists.txt:
3131         * bmalloc.xcodeproj/project.pbxproj:
3132         * bmalloc/Cache.cpp:
3133         (bmalloc::Cache::scavenge):
3134         * bmalloc/Cache.h:
3135         (bmalloc::Cache::tryAllocate):
3136         (bmalloc::Cache::allocate):
3137         (bmalloc::Cache::deallocate):
3138         (bmalloc::Cache::reallocate):
3139         * bmalloc/Gigacage.cpp:
3140         (Gigacage::ensureGigacage):
3141         (Gigacage::runway):
3142         (Gigacage::totalSize):
3143         (Gigacage::shouldBeEnabled):
3144         (): Deleted.
3145         (Gigacage::Callback::Callback): Deleted.
3146         (Gigacage::Callback::function): Deleted.
3147         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
3148         * bmalloc/Gigacage.h:
3149         (Gigacage::wasEnabled):
3150         (Gigacage::isEnabled):
3151         (Gigacage::runway): Deleted.
3152         (Gigacage::totalSize): Deleted.
3153         * bmalloc/HeapKind.cpp: Added.
3154         (bmalloc::isActiveHeapKind):
3155         (bmalloc::mapToActiveHeapKind):
3156         * bmalloc/HeapKind.h:
3157         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
3158         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
3159         * bmalloc/Scavenger.cpp:
3160         (bmalloc::Scavenger::scavenge):
3161         * bmalloc/bmalloc.h:
3162         (bmalloc::api::tryLargeMemalignVirtual):
3163         (bmalloc::api::freeLargeVirtual):
3164         (bmalloc::api::isEnabled):
3165
3166 2017-10-11  Commit Queue  <commit-queue@webkit.org>
3167
3168         Unreviewed, rolling out r223113 and r223121.
3169         https://bugs.webkit.org/show_bug.cgi?id=178182
3170
3171         Reintroduced 20% regression on Kraken (Requested by rniwa on
3172         #webkit).
3173
3174         Reverted changesets:
3175
3176         "Enable gigacage on iOS"
3177         https://bugs.webkit.org/show_bug.cgi?id=177586
3178         https://trac.webkit.org/changeset/223113
3179
3180         "Use one virtual allocation for all gigacages and their
3181         runways"
3182         https://bugs.webkit.org/show_bug.cgi?id=178050
3183         https://trac.webkit.org/changeset/223121
3184
3185 2017-10-07  Filip Pizlo  <fpizlo@apple.com>
3186
3187         Use one virtual allocation for all gigacages and their runways
3188         https://bugs.webkit.org/show_bug.cgi?id=178050
3189
3190         Reviewed by Saam Barati.
3191
3192         * bmalloc/Gigacage.cpp:
3193         (Gigacage::ensureGigacage):
3194         (Gigacage::runway): Deleted.
3195         (Gigacage::totalSize): Deleted.
3196         * bmalloc/Gigacage.h:
3197
3198 2017-09-29  Filip Pizlo  <fpizlo@apple.com>
3199
3200         Enable gigacage on iOS
3201         https://bugs.webkit.org/show_bug.cgi?id=177586
3202
3203         Reviewed by JF Bastien.
3204         
3205         Introduce the ability to disable gigacage at runtime if allocation fails. If any step of gigacage
3206         allocation fails, we free all of the gigacages and turn off gigacage support.
3207         
3208         Reland this after confirming that the 20% Kraken regression was a one-bot fluke. Local testing on the
3209         same kind of system did not show the regression. Saam and I both tried independently.
3210
3211         * CMakeLists.txt:
3212         * bmalloc.xcodeproj/project.pbxproj:
3213         * bmalloc/Cache.cpp:
3214         (bmalloc::Cache::scavenge):
3215         * bmalloc/Cache.h:
3216         (bmalloc::Cache::tryAllocate):
3217         (bmalloc::Cache::allocate):
3218         (bmalloc::Cache::deallocate):
3219         (bmalloc::Cache::reallocate):
3220         * bmalloc/Gigacage.cpp:
3221         (Gigacage::ensureGigacage):
3222         (Gigacage::runway):
3223         (Gigacage::totalSize):
3224         (Gigacage::shouldBeEnabled):
3225         (): Deleted.
3226         (Gigacage::Callback::Callback): Deleted.
3227         (Gigacage::Callback::function): Deleted.
3228         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
3229         * bmalloc/Gigacage.h:
3230         (Gigacage::wasEnabled):
3231         (Gigacage::isEnabled):
3232         (Gigacage::runway): Deleted.
3233         (Gigacage::totalSize): Deleted.
3234         * bmalloc/HeapKind.cpp: Added.
3235         (bmalloc::isActiveHeapKind):
3236         (bmalloc::mapToActiveHeapKind):
3237         * bmalloc/HeapKind.h:
3238         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
3239         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
3240         * bmalloc/Scavenger.cpp:
3241         (bmalloc::Scavenger::scavenge):
3242         * bmalloc/bmalloc.h:
3243         (bmalloc::api::tryLargeMemalignVirtual):
3244         (bmalloc::api::freeLargeVirtual):
3245         (bmalloc::api::isEnabled):
3246
3247 2017-10-09  Commit Queue  <commit-queue@webkit.org>
3248
3249         Unreviewed, rolling out r223015 and r223025.
3250         https://bugs.webkit.org/show_bug.cgi?id=178093
3251
3252         Regressed Kraken on iOS by 20% (Requested by keith_mi_ on
3253         #webkit).
3254
3255         Reverted changesets:
3256
3257         "Enable gigacage on iOS"
3258         https://bugs.webkit.org/show_bug.cgi?id=177586
3259         http://trac.webkit.org/changeset/223015
3260
3261         "Unreviewed, disable Gigacage on ARM64 Linux"
3262         https://bugs.webkit.org/show_bug.cgi?id=177586
3263         http://trac.webkit.org/changeset/223025
3264
3265 2017-10-07  Yusuke Suzuki  <utatane.tea@gmail.com>
3266
3267         Unreviewed, disable Gigacage on ARM64 Linux
3268         https://bugs.webkit.org/show_bug.cgi?id=177586
3269
3270         Gigacage's LLInt change breaks ARM64 Linux.
3271         Currently we do not have maintainers for this.
3272         Let's simply disable it.
3273
3274         * bmalloc/Gigacage.h:
3275
3276 2017-09-29  Filip Pizlo  <fpizlo@apple.com>
3277
3278         Enable gigacage on iOS
3279         https://bugs.webkit.org/show_bug.cgi?id=177586
3280
3281         Reviewed by JF Bastien.
3282         
3283         Introduce the ability to disable gigacage at runtime if allocation fails. If any step of gigacage
3284         allocation fails, we free all of the gigacages and turn off gigacage support.
3285
3286         * CMakeLists.txt:
3287         * bmalloc.xcodeproj/project.pbxproj:
3288         * bmalloc/Cache.cpp:
3289         (bmalloc::Cache::scavenge):
3290         * bmalloc/Cache.h:
3291         (bmalloc::Cache::tryAllocate):
3292         (bmalloc::Cache::allocate):
3293         (bmalloc::Cache::deallocate):
3294         (bmalloc::Cache::reallocate):
3295         * bmalloc/Gigacage.cpp:
3296         (Gigacage::ensureGigacage):
3297         (Gigacage::runway):
3298         (Gigacage::totalSize):
3299         (Gigacage::shouldBeEnabled):
3300         (): Deleted.
3301         (Gigacage::Callback::Callback): Deleted.
3302         (Gigacage::Callback::function): Deleted.
3303         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks): Deleted.
3304         * bmalloc/Gigacage.h:
3305         (Gigacage::wasEnabled):
3306         (Gigacage::isEnabled):
3307         (Gigacage::runway): Deleted.
3308         (Gigacage::totalSize): Deleted.
3309         * bmalloc/HeapKind.cpp: Added.
3310         (bmalloc::isActiveHeapKind):
3311         (bmalloc::mapToActiveHeapKind):
3312         * bmalloc/HeapKind.h:
3313         (bmalloc::isActiveHeapKindAfterEnsuringGigacage):
3314         (bmalloc::mapToActiveHeapKindAfterEnsuringGigacage):
3315         * bmalloc/Scavenger.cpp:
3316         (bmalloc::Scavenger::scavenge):
3317         * bmalloc/bmalloc.h:
3318         (bmalloc::api::tryLargeMemalignVirtual):
3319         (bmalloc::api::freeLargeVirtual):
3320         (bmalloc::api::isEnabled):
3321
3322 2017-10-05  Filip Pizlo  <fpizlo@apple.com>
3323
3324         Use one Scavenger thread for all Heaps
3325         https://bugs.webkit.org/show_bug.cgi?id=174973
3326
3327         Reviewed by JF Bastien.
3328         
3329         This combines the scavengers from all Heap instances into a single scavenger. It also combines
3330         the accounting for deciding when to run. Each Heap still controls what it means to scavenge
3331         itself (it's all in Heap::scavenge) but the policy decisions are all controlled by Scavenger.
3332         Because Scavenger is also the only thing that needs an AsyncTask, this removes AsyncTask and
3333         moves all of AsyncTask's logic into Scavenger.
3334         
3335         This appears to be a 1% progression on JetStream (with high statistical confidence: p = 0.0049).
3336
3337         * bmalloc.xcodeproj/project.pbxproj:
3338         * bmalloc/AsyncTask.h: Removed.
3339         * bmalloc/Heap.cpp:
3340         (bmalloc::Heap::Heap):
3341         (bmalloc::Heap::allocateSmallChunk):
3342         (bmalloc::Heap::allocateSmallPage):
3343         (bmalloc::Heap::deallocateSmallLine):
3344         (bmalloc::Heap::splitAndAllocate):
3345         (bmalloc::Heap::tryAllocateLarge):
3346         (bmalloc::Heap::shrinkLarge):
3347         (bmalloc::Heap::deallocateLarge):
3348         (bmalloc::Heap::concurrentScavenge): Deleted.
3349         (bmalloc::Heap::scheduleScavengerIfUnderMemoryPressure): Deleted.
3350         (bmalloc::Heap::scheduleScavenger): Deleted.
3351         * bmalloc/Heap.h:
3352         * bmalloc/Scavenger.cpp:
3353         (bmalloc::Scavenger::Scavenger):
3354         (bmalloc::Scavenger::run):
3355         (bmalloc::Scavenger::runHoldingLock):
3356         (bmalloc::Scavenger::runSoon):
3357         (bmalloc::Scavenger::runSoonHoldingLock):
3358         (bmalloc::Scavenger::didStartGrowing):
3359         (bmalloc::Scavenger::scheduleIfUnderMemoryPressure):
3360         (bmalloc::Scavenger::scheduleIfUnderMemoryPressureHoldingLock):
3361         (bmalloc::Scavenger::schedule):
3362         (bmalloc::Scavenger::threadEntryPoint):
3363         (bmalloc::Scavenger::threadRunLoop):
3364         (bmalloc::Scavenger::setSelfQOSClass):
3365         * bmalloc/Scavenger.h:
3366         (bmalloc::Scavenger::willRun):
3367         (bmalloc::Scavenger::willRunSoon):
3368
3369 2017-10-04  Filip Pizlo  <fpizlo@apple.com>
3370
3371         bmalloc mutex should be adaptive
3372         https://bugs.webkit.org/show_bug.cgi?id=177839
3373
3374         Reviewed by Michael Saboff.
3375         
3376         This pulls the WordLock algorithm into bmalloc, mostly by copy-pasting the code. We need to
3377         copy paste because sometimes we build WTF without bmalloc, so WTF cannot rely on bmalloc for
3378         anything other than malloc.
3379
3380         Reland after fixing ancient WordLock bug: the notify_one has to happen with the lock held
3381         to ensure it doesn't run after that thread has died.
3382
3383         * bmalloc/Algorithm.h:
3384         (bmalloc::compareExchangeWeak):
3385         (bmalloc::compareExchangeStrong):
3386         * bmalloc/PerThread.h:
3387         * bmalloc/StaticMutex.cpp:
3388         (bmalloc::StaticMutex::lockSlow):
3389         (bmalloc::StaticMutex::unlockSlow):
3390         (bmalloc::StaticMutex::lockSlowCase): Deleted.
3391         * bmalloc/StaticMutex.h:
3392         (bmalloc::StaticMutex::try_lock):
3393         (bmalloc::StaticMutex::isLocked const):
3394         (bmalloc::StaticMutex::init):
3395         (bmalloc::StaticMutex::tryLock):
3396         (bmalloc::StaticMutex::lock):
3397         (bmalloc::StaticMutex::unlock):
3398         (bmalloc::sleep): Deleted.
3399         (bmalloc::waitUntilFalse): Deleted.
3400
3401 2017-10-05  Matt Lewis  <jlewis3@apple.com>
3402
3403         Unreviewed, rolling out r222893.
3404
3405         This caused multiple API failures.
3406
3407         Reverted changeset:
3408
3409         "bmalloc mutex should be adaptive"
3410         https://bugs.webkit.org/show_bug.cgi?id=177839
3411         http://trac.webkit.org/changeset/222893
3412
3413 2017-10-05  Yusuke Suzuki  <utatane.tea@gmail.com>
3414
3415         [Linux] Port MallocBench
3416         https://bugs.webkit.org/show_bug.cgi?id=177856
3417
3418         Reviewed by Filip Pizlo.
3419
3420         * CMakeLists.txt:
3421
3422 2017-10-04  Filip Pizlo  <fpizlo@apple.com>
3423
3424         bmalloc mutex should be adaptive
3425         https://bugs.webkit.org/show_bug.cgi?id=177839
3426
3427         Reviewed by Michael Saboff.
3428         
3429         This pulls the WordLock algorithm into bmalloc, mostly by copy-pasting the code. We need to
3430         copy paste because sometimes we build WTF without bmalloc, so WTF cannot rely on bmalloc for
3431         anything other than malloc.
3432
3433         * bmalloc/Algorithm.h:
3434         (bmalloc::compareExchangeWeak):
3435         (bmalloc::compareExchangeStrong):
3436         * bmalloc/PerThread.h:
3437         * bmalloc/StaticMutex.cpp:
3438         (bmalloc::StaticMutex::lockSlow):
3439         (bmalloc::StaticMutex::unlockSlow):
3440         (bmalloc::StaticMutex::lockSlowCase): Deleted.
3441         * bmalloc/StaticMutex.h:
3442         (bmalloc::StaticMutex::try_lock):
3443         (bmalloc::StaticMutex::isLocked const):
3444         (bmalloc::StaticMutex::init):
3445         (bmalloc::StaticMutex::tryLock):
3446         (bmalloc::StaticMutex::lock):
3447         (bmalloc::StaticMutex::unlock):
3448         (bmalloc::sleep): Deleted.
3449         (bmalloc::waitUntilFalse): Deleted.
3450
3451 2017-10-02  Yusuke Suzuki  <utatane.tea@gmail.com>
3452
3453         [Linux] Enable Gigacage in x64 Linux environment
3454         https://bugs.webkit.org/show_bug.cgi?id=177745
3455
3456         Reviewed by Carlos Garcia Campos.
3457
3458         This patch enables Gigacage in x64 Linux environment.
3459         Gigacage enforces a caged pointer to reference to the
3460         specific memory region. This reduces the effectiveness
3461         of some types of attacks setting a pointer to ArrayBuffer
3462         and modifying arbitrary memory region.
3463
3464         * bmalloc/Gigacage.h:
3465
3466 2017-09-29  Commit Queue  <commit-queue@webkit.org>
3467
3468         Unreviewed, rolling out r222625.
3469         https://bugs.webkit.org/show_bug.cgi?id=177664
3470
3471         causes crashes on iOS (Requested by pizlo-mbp on #webkit).
3472
3473         Reverted changeset:
3474
3475         "Enable gigacage on iOS"
3476         https://bugs.webkit.org/show_bug.cgi?id=177586
3477         http://trac.webkit.org/changeset/222625
3478
3479 2017-09-28  Filip Pizlo  <fpizlo@apple.com>
3480
3481         Enable gigacage on iOS
3482         https://bugs.webkit.org/show_bug.cgi?id=177586
3483
3484         Reviewed by Michael Saboff.
3485         
3486         This enables Gigacage on iOS using a much smaller cage size. It's not necessary for it to be so
3487         small, but this is a good conservative starting point to start to exercise the code.
3488
3489         * bmalloc/Gigacage.h:
3490
3491 2017-09-26  Filip Pizlo  <fpizlo@apple.com>
3492
3493         Put g_gigacageBasePtr into its own page and make it read-only
3494         https://bugs.webkit.org/show_bug.cgi?id=174972
3495
3496         Reviewed by Michael Saboff.
3497         
3498         This puts the gigacage base pointers into their own page and makes that page read-only.
3499
3500         * bmalloc/Gigacage.cpp:
3501         (Gigacage::ensureGigacage):
3502         (Gigacage::disablePrimitiveGigacage):
3503         (Gigacage::addPrimitiveDisableCallback):
3504         * bmalloc/Gigacage.h:
3505         (Gigacage::basePtr):
3506         (Gigacage::basePtrs):
3507
3508 2017-09-04  Adrian Perez de Castro  <aperez@igalia.com>
3509
3510         Unreviewed build fix for Clang with libc++
3511
3512         Fixes a build failure when building with Clang, -stdlib=libc++, and gigacage
3513         support enabled, which resulted in "stderr" being undefined.
3514
3515         * bmalloc/Gigacage.cpp: Add missing <ctsdio> include to pull the definition.
3516
3517 2017-09-03  Yusuke Suzuki  <utatane.tea@gmail.com>
3518
3519         Large virtual memory region allocation requires MMAP_NORESERVE in Linux
3520         https://bugs.webkit.org/show_bug.cgi?id=176211
3521
3522         Reviewed by Geoffrey Garen.
3523
3524         In Linux, we cannot allocate very large memory region without MMAP_NORESERVE.
3525         Linux kernel needs to reserve swap area for allocated memory region. If the
3526         swap area is exhausted, kernel fails to allocate the memory region with ENOMEM.
3527
3528         This patch adds MMAP_NORESERVE to mmap flags in Linux. By adding this flag,
3529         mmap does not need to reserve swap area for the reserved memory region.
3530         This allows us to reserve very large memory region that is necessary for Gigacage.
3531
3532         * bmalloc/BPlatform.h:
3533         * bmalloc/VMAllocate.h:
3534         (bmalloc::tryVMAllocate):
3535
3536 2017-08-22  Filip Pizlo  <fpizlo@apple.com>
3537
3538         Strings need to be in some kind of gigacage
3539         https://bugs.webkit.org/show_bug.cgi?id=174924
3540
3541         Reviewed by Oliver Hunt.
3542         
3543         This adds a StringGigacage.
3544
3545         * bmalloc/Gigacage.cpp:
3546         * bmalloc/Gigacage.h:
3547         (Gigacage::name):
3548         (Gigacage::basePtr):
3549         (Gigacage::forEachKind):
3550         * bmalloc/HeapKind.h:
3551         (bmalloc::isGigacage):
3552         (bmalloc::gigacageKind):
3553         (bmalloc::heapKind):
3554
3555 2017-08-30  Matt Lewis  <jlewis3@apple.com>
3556
3557         Unreviewed, rolling out r221384.
3558
3559         This patch caused multiple 32-bit JSC test failures.
3560
3561         Reverted changeset:
3562
3563         "Strings need to be in some kind of gigacage"
3564         https://bugs.webkit.org/show_bug.cgi?id=174924
3565         http://trac.webkit.org/changeset/221384
3566
3567 2017-08-22  Filip Pizlo  <fpizlo@apple.com>
3568
3569         Strings need to be in some kind of gigacage
3570         https://bugs.webkit.org/show_bug.cgi?id=174924
3571
3572         Reviewed by Oliver Hunt.
3573         
3574         This adds a StringGigacage.
3575
3576         * bmalloc/Gigacage.cpp:
3577         * bmalloc/Gigacage.h:
3578         (Gigacage::name):
3579         (Gigacage::basePtr):
3580         (Gigacage::forEachKind):
3581         * bmalloc/HeapKind.h:
3582         (bmalloc::isGigacage):
3583         (bmalloc::gigacageKind):
3584         (bmalloc::heapKind):
3585
3586 2017-08-25  Daniel Bates  <dabates@apple.com>
3587
3588         Demarcate code added due to lack of NSDMI for aggregates
3589         https://bugs.webkit.org/show_bug.cgi?id=175990
3590
3591         Reviewed by Andy Estes.
3592
3593         * bmalloc/BPlatform.h:
3594         * bmalloc/List.h: Be explicit when initializing m_node to improve readability.
3595         (bmalloc::ListNode::ListNode):
3596
3597 2017-08-23  Filip Pizlo  <fpizlo@apple.com>
3598
3599         Reduce Gigacage sizes
3600         https://bugs.webkit.org/show_bug.cgi?id=175920
3601
3602         Reviewed by Mark Lam.
3603
3604         This introduces the ability to have different gigacage sizes for different gigacages, and uses it to reduce the size of both
3605         gigacages, but to different extents: Primitive gets 32GB with a 16GB runway and JSValue gets 16GB.
3606
3607         This is a ~10% membuster progression on my Mac Pro.
3608
3609         * bmalloc/Gigacage.cpp:
3610         (Gigacage::ensureGigacage):
3611         * bmalloc/Gigacage.h:
3612         (Gigacage::size):
3613         (Gigacage::alignment):
3614         (Gigacage::mask):
3615         (Gigacage::runway):
3616         (Gigacage::totalSize):
3617         (Gigacage::caged):
3618         * bmalloc/Heap.cpp:
3619         (bmalloc::Heap::Heap):
3620         (bmalloc::Heap::gigacageSize):
3621         * bmalloc/Heap.h:
3622
3623 2017-08-08  Filip Pizlo  <fpizlo@apple.com>
3624
3625         Baseline JIT should do caging
3626         https://bugs.webkit.org/show_bug.cgi?id=175037
3627
3628         Reviewed by Mark Lam.
3629         
3630         This centralizes the notion of permanently enabling the primitive gigacage, which we only do in jsc
3631         and WebProcess.
3632         
3633         This saves the baseline JIT from emitting some code. Otherwise it would always have to emit enabled
3634         checks on each typed array access.
3635
3636         * bmalloc/Gigacage.cpp:
3637         (Gigacage::primitiveGigacageDisabled):
3638         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
3639         (Gigacage::isDisablingPrimitiveGigacageDisabled):
3640         * bmalloc/Gigacage.h:
3641         (Gigacage::isPrimitiveGigacagePermanentlyEnabled):
3642         (Gigacage::canPrimitiveGigacageBeDisabled):
3643
3644 2017-08-08  Ryan Haddad  <ryanhaddad@apple.com>
3645
3646         Unreviewed, rolling out r220368.
3647
3648         This change caused WK1 tests to exit early with crashes.
3649
3650         Reverted changeset:
3651
3652         "Baseline JIT should do caging"
3653         https://bugs.webkit.org/show_bug.cgi?id=175037
3654         http://trac.webkit.org/changeset/220368
3655
3656 2017-08-07  Filip Pizlo  <fpizlo@apple.com>
3657
3658         Baseline JIT should do caging
3659         https://bugs.webkit.org/show_bug.cgi?id=175037
3660
3661         Reviewed by Mark Lam.
3662         
3663         This centralizes the notion of permanently enabling the primitive gigacage, which we only do in jsc
3664         and WebProcess.
3665         
3666         This saves the baseline JIT from emitting some code. Otherwise it would always have to emit enabled
3667         checks on each typed array access.
3668
3669         * bmalloc/Gigacage.cpp:
3670         (Gigacage::primitiveGigacageDisabled):
3671         (Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled):
3672         (Gigacage::isDisablingPrimitiveGigacageDisabled):
3673         * bmalloc/Gigacage.h:
3674         (Gigacage::isPrimitiveGigacagePermanentlyEnabled):
3675         (Gigacage::canPrimitiveGigacageBeDisabled):
3676
3677 2017-08-06  Filip Pizlo  <fpizlo@apple.com>
3678
3679         Primitive auxiliaries and JSValue auxiliaries should have separate gigacages
3680         https://bugs.webkit.org/show_bug.cgi?id=174919
3681
3682         Reviewed by Keith Miller.
3683         
3684         This introduces two kinds of Gigacage, Primitive and JSValue. This translates to two kinds of
3685         HeapKind, PrimitiveGigacage and JSValueGigacage.
3686         
3687         The new support functionality required turning Inline.h into BInline.h, and INLINE into BINLINE, and
3688         NO_INLINE into BNO_INLINE.
3689
3690         * bmalloc.xcodeproj/project.pbxproj:
3691         * bmalloc/Allocator.cpp:
3692         (bmalloc::Allocator::refillAllocatorSlowCase):
3693         (bmalloc::Allocator::refillAllocator):
3694         (bmalloc::Allocator::allocateLarge):
3695         (bmalloc::Allocator::allocateLogSizeClass):
3696         * bmalloc/AsyncTask.h:
3697         * bmalloc/BInline.h: Copied from Source/bmalloc/bmalloc/Inline.h.
3698         * bmalloc/Cache.cpp:
3699         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
3700         (bmalloc::Cache::allocateSlowCaseNullCache):
3701         (bmalloc::Cache::deallocateSlowCaseNullCache):
3702         (bmalloc::Cache::reallocateSlowCaseNullCache):
3703         * bmalloc/Deallocator.cpp:
3704         * bmalloc/Gigacage.cpp:
3705         (Gigacage::PrimitiveDisableCallbacks::PrimitiveDisableCallbacks):
3706         (Gigacage::ensureGigacage):
3707         (Gigacage::disablePrimitiveGigacage):
3708         (Gigacage::addPrimitiveDisableCallback):
3709         (Gigacage::removePrimitiveDisableCallback):
3710         (Gigacage::Callbacks::Callbacks): Deleted.
3711         (Gigacage::disableGigacage): Deleted.
3712         (Gigacage::addDisableCallback): Deleted.
3713         (Gigacage::removeDisableCallback): Deleted.
3714         * bmalloc/Gigacage.h:
3715         (Gigacage::name):
3716         (Gigacage::basePtr):
3717         (Gigacage::forEachKind):
3718         (Gigacage::caged):
3719         (Gigacage::isCaged):
3720         * bmalloc/Heap.cpp:
3721         (bmalloc::Heap::Heap):
3722         (bmalloc::Heap::usingGigacage):
3723         (bmalloc::Heap::gigacageBasePtr):
3724         * bmalloc/Heap.h:
3725         * bmalloc/HeapKind.h:
3726         (bmalloc::isGigacage):
3727         (bmalloc::gigacageKind):
3728         (bmalloc::heapKind):
3729         * bmalloc/Inline.h: Removed.
3730         * bmalloc/Map.h:
3731         * bmalloc/PerProcess.h:
3732         (bmalloc::PerProcess<T>::getFastCase):
3733         (bmalloc::PerProcess<T>::get):
3734         (bmalloc::PerProcess<T>::getSlowCase):
3735         * bmalloc/PerThread.h:
3736         (bmalloc::PerThread<T>::getFastCase):
3737         * bmalloc/Vector.h:
3738         (bmalloc::Vector<T>::push):
3739         (bmalloc::Vector<T>::shrinkCapacity):
3740         (bmalloc::Vector<T>::growCapacity):
3741
3742 2017-08-02  Filip Pizlo  <fpizlo@apple.com>
3743
3744         If Gigacage is disabled, bmalloc should service large aligned memory allocation requests through vmAllocate
3745         https://bugs.webkit.org/show_bug.cgi?id=175085
3746
3747         Reviewed by Saam Barati.
3748         
3749         This fixes a problem where if we used gmalloc, WebAssembly memory allocations would still use
3750         bmalloc's large allocator.
3751         
3752         We want to use the page allocator for those "large" allocations when the Gigacage is disabled.
3753
3754         * bmalloc/DebugHeap.cpp:
3755         (bmalloc::DebugHeap::DebugHeap):
3756         (bmalloc::DebugHeap::memalignLarge):
3757         (bmalloc::DebugHeap::freeLarge):
3758         * bmalloc/DebugHeap.h:
3759         * bmalloc/Heap.cpp:
3760         (bmalloc::Heap::tryAllocateLarge):
3761         (bmalloc::Heap::deallocateLarge):
3762
3763 2017-08-02  Filip Pizlo  <fpizlo@apple.com>
3764
3765         We should be OK with the gigacage being disabled on gmalloc
3766         https://bugs.webkit.org/show_bug.cgi?id=175082
3767
3768         Reviewed by Michael Saboff.
3769         
3770         This adds Gigacage::shouldBeEnabled(), which returns false when we're using gmalloc or other things
3771         that enable DebugHeap.
3772
3773         * bmalloc/Environment.cpp:
3774         (bmalloc::Environment::Environment):
3775         * bmalloc/Environment.h:
3776         * bmalloc/Gigacage.cpp:
3777         (Gigacage::ensureGigacage):
3778         (Gigacage::shouldBeEnabled):
3779         * bmalloc/Gigacage.h:
3780         * bmalloc/Heap.cpp:
3781         (bmalloc::Heap::Heap):
3782         * bmalloc/Heap.h:
3783
3784 2017-08-01  Filip Pizlo  <fpizlo@apple.com>
3785
3786         Bmalloc and GC should put auxiliaries (butterflies, typed array backing stores) in a gigacage (separate multi-GB VM region)
3787         https://bugs.webkit.org/show_bug.cgi?id=174727
3788
3789         Reviewed by Mark Lam.
3790         
3791         This adds a mechanism for managing multiple isolated heaps in bmalloc. For now, these isoheaps
3792         (isolated heaps) have a very simple relationship with each other and with the rest of bmalloc:
3793         
3794         - You have to choose how many isoheaps you will have statically. See numHeaps in HeapKind.h.
3795         
3796         - Because numHeaps is static, each isoheap gets fast thread-local allocation. Basically, we have a
3797           Cache for each heap kind.
3798         
3799         - Each isoheap gets its own Heap.
3800         
3801         - Each Heap gets a scavenger thread.
3802         
3803         - Some things, like Zone/VMHeap/Scavenger, are per-process.
3804         
3805         Most of the per-HeapKind functionality is handled by PerHeapKind<>.
3806         
3807         This approach is ideal for supporting special per-HeapKind behaviors. For now we have two heaps:
3808         the Primary heap for normal malloc and the Gigacage. The gigacage is a 64GB-aligned 64GB virtual
3809         region that we now use for variable-length random-access allocations. No Primary allocations will
3810         go into the Gigacage.
3811
3812         * CMakeLists.txt:
3813         * bmalloc.xcodeproj/project.pbxproj:
3814         * bmalloc/AllocationKind.h: Added.
3815         * bmalloc/Allocator.cpp:
3816         (bmalloc::Allocator::Allocator):
3817         (bmalloc::Allocator::tryAllocate):
3818         (bmalloc::Allocator::allocateImpl):
3819         (bmalloc::Allocator::reallocate):
3820         (bmalloc::Allocator::refillAllocatorSlowCase):
3821         (bmalloc::Allocator::allocateLarge):
3822         * bmalloc/Allocator.h:
3823         * bmalloc/BExport.h: Added.
3824         * bmalloc/Cache.cpp:
3825         (bmalloc::Cache::scavenge):
3826         (bmalloc::Cache::Cache):
3827         (bmalloc::Cache::tryAllocateSlowCaseNullCache):
3828         (bmalloc::Cache::allocateSlowCaseNullCache):
3829         (bmalloc::Cache::deallocateSlowCaseNullCache):
3830         (bmalloc::Cache::reallocateSlowCaseNullCache):
3831         (bmalloc::Cache::operator new): Deleted.
3832         (bmalloc::Cache::operator delete): Deleted.
3833         * bmalloc/Cache.h:
3834         (bmalloc::Cache::tryAllocate):
3835         (bmalloc::Cache::allocate):
3836         (bmalloc::Cache::deallocate):
3837         (bmalloc::Cache::reallocate):
3838         * bmalloc/Deallocator.cpp:
3839         (bmalloc::Deallocator::Deallocator):
3840         (bmalloc::Deallocator::scavenge):
3841         (bmalloc::Deallocator::processObjectLog):
3842         (bmalloc::Deallocator::deallocateSlowCase):
3843         * bmalloc/Deallocator.h:
3844         * bmalloc/Gigacage.cpp: Added.
3845         (Gigacage::Callback::Callback):
3846         (Gigacage::Callback::function):
3847         (Gigacage::Callbacks::Callbacks):
3848         (Gigacage::ensureGigacage):
3849         (Gigacage::disableGigacage):
3850         (Gigacage::addDisableCallback):
3851         (Gigacage::removeDisableCallback):
3852         * bmalloc/Gigacage.h: Added.
3853         (Gigacage::caged):
3854         (Gigacage::isCaged):
3855         * bmalloc/Heap.cpp:
3856         (bmalloc::Heap::Heap):
3857         (bmalloc::Heap::usingGigacage):
3858         (bmalloc::Heap::concurrentScavenge):
3859         (bmalloc::Heap::splitAndAllocate):
3860         (bmalloc::Heap::tryAllocateLarge):
3861         (bmalloc::Heap::allocateLarge):
3862         (bmalloc::Heap::shrinkLarge):
3863         (bmalloc::Heap::deallocateLarge):
3864         * bmalloc/Heap.h:
3865         (bmalloc::Heap::mutex):
3866         (bmalloc::Heap::kind const):
3867         (bmalloc::Heap::setScavengerThreadQOSClass): Deleted.
3868         * bmalloc/HeapKind.h: Added.
3869         * bmalloc/ObjectType.cpp:
3870         (bmalloc::objectType):
3871         * bmalloc/ObjectType.h:
3872         * bmalloc/PerHeapKind.h: Added.
3873         (bmalloc::PerHeapKindBase::PerHeapKindBase):
3874         (bmalloc::PerHeapKindBase::size):
3875         (bmalloc::PerHeapKindBase::at):
3876         (bmalloc::PerHeapKindBase::at const):
3877         (bmalloc::PerHeapKindBase::operator[]):
3878         (bmalloc::PerHeapKindBase::operator[] const):
3879         (bmalloc::StaticPerHeapKind::StaticPerHeapKind):
3880         (bmalloc::PerHeapKind::PerHeapKind):
3881         (bmalloc::PerHeapKind::~PerHeapKind):
3882         * bmalloc/PerThread.h:
3883         (bmalloc::PerThread<T>::destructor):
3884         (bmalloc::PerThread<T>::getSlowCase):
3885         (bmalloc::PerThreadStorage<Cache>::get): Deleted.
3886         (bmalloc::PerThreadStorage<Cache>::init): Deleted.
3887         * bmalloc/Scavenger.cpp: Added.
3888         (bmalloc::Scavenger::Scavenger):
3889         (bmalloc::Scavenger::scavenge):
3890         * bmalloc/Scavenger.h: Added.
3891         (bmalloc::Scavenger::setScavengerThreadQOSClass):
3892         (bmalloc::Scavenger::requestedScavengerThreadQOSClass const):
3893         * bmalloc/VMHeap.cpp:
3894         (bmalloc::VMHeap::VMHeap):
3895         (bmalloc::VMHeap::tryAllocateLargeChunk):
3896         * bmalloc/VMHeap.h:
3897         * bmalloc/Zone.cpp:
3898         (bmalloc::Zone::Zone):
3899         * bmalloc/Zone.h:
3900         * bmalloc/bmalloc.h:
3901         (bmalloc::api::tryMalloc):
3902         (bmalloc::api::malloc):
3903         (bmalloc::api::tryMemalign):
3904         (bmalloc::api::memalign):
3905         (bmalloc::api::realloc):
3906         (bmalloc::api::tryLargeMemalignVirtual):
3907         (bmalloc::api::free):
3908         (bmalloc::api::freeLargeVirtual):
3909         (bmalloc::api::scavengeThisThread):
3910         (bmalloc::api::scavenge):
3911         (bmalloc::api::isEnabled):
3912         (bmalloc::api::setScavengerThreadQOSClass):
3913         * bmalloc/mbmalloc.cpp:
3914
3915 2017-08-01  Daewoong Jang  <daewoong.jang@navercorp.com>
3916
3917         Implement __builtin_clzl for MSVC
3918         https://bugs.webkit.org/show_bug.cgi?id=174232
3919
3920         Reviewed by Geoffrey Garen.
3921
3922         * bmalloc/Algorithm.h:
3923         (bmalloc::clzl):
3924         (bmalloc::clzl<1>):
3925         (bmalloc::__builtin_clzl):
3926         * bmalloc/BPlatform.h:
3927
3928 2017-07-31  Mark Lam  <mark.lam@apple.com>
3929
3930         Fixed some comment typos.
3931
3932         Not reviewed.
3933
3934         * bmalloc/PerProcess.h:
3935
3936 2017-07-14  Filip Pizlo  <fpizlo@apple.com>
3937
3938         It should be easy to decide how WebKit yields
3939         https://bugs.webkit.org/show_bug.cgi?id=174298
3940
3941         Reviewed by Saam Barati.
3942         
3943         Use sched_yield() explicitly.
3944
3945         * bmalloc/StaticMutex.cpp:
3946         (bmalloc::StaticMutex::lockSlowCase):
3947
3948 2017-07-20  Chris Dumez  <cdumez@apple.com>
3949
3950         Replace calls to Vector::resize() with calls to more efficient shrink() / grow() when applicable
3951         https://bugs.webkit.org/show_bug.cgi?id=174660
3952
3953         Reviewed by Geoffrey Garen.
3954
3955         Replace calls to Vector::resize() with calls to more efficient shrink() / grow() when applicable.
3956         This essentially replaces a branch to figure out if the new size is less or greater than the
3957         current size by an assertion.
3958
3959         * bmalloc/Map.h:
3960         (bmalloc::Hash>::rehash):
3961
3962 2017-07-18  Andy Estes  <aestes@apple.com>
3963
3964         [Xcode] Enable CLANG_WARN_RANGE_LOOP_ANALYSIS
3965         https://bugs.webkit.org/show_bug.cgi?id=174631
3966
3967         Reviewed by Tim Horton.
3968
3969         * Configurations/Base.xcconfig:
3970
3971 2017-07-18  Andy Estes  <aestes@apple.com>
3972
3973         [Xcode] Enable CLANG_WARN_OBJC_LITERAL_CONVERSION
3974         https://bugs.webkit.org/show_bug.cgi?id=174631
3975
3976         Reviewed by Sam Weinig.
3977
3978         * Configurations/Base.xcconfig:
3979
3980 2017-07-18  Andy Estes  <aestes@apple.com>
3981
3982         [Xcode] Enable CLANG_WARN_NON_LITERAL_NULL_CONVERSION
3983         https://bugs.webkit.org/show_bug.cgi?id=174631
3984
3985         Reviewed by Dan Bernstein.
3986
3987         * Configurations/Base.xcconfig:
3988
3989 2017-07-18  Andy Estes  <aestes@apple.com>
3990
3991         [Xcode] Enable CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING
3992         https://bugs.webkit.org/show_bug.cgi?id=174631
3993
3994         Reviewed by Darin Adler.
3995
3996         * Configurations/Base.xcconfig:
3997
3998 2017-07-12  Adrian Perez de Castro  <aperez@igalia.com>
3999
4000         bmalloc: Failure to build when the compiler specifically targets ARMv8-A / defines __ARM_ARCH_8A__
4001         https://bugs.webkit.org/show_bug.cgi?id=174424
4002
4003         Reviewed by Michael Catanzaro.
4004
4005         * bmalloc/BPlatform.h: Also check for __ARCH_ARM_8A__ to detect ARMv8.
4006
4007 2017-07-05  Daewoong Jang  <daewoong.jang@navercorp.com>
4008
4009         reinterpret_cast does not evaluate to constexpr
4010         https://bugs.webkit.org/show_bug.cgi?id=173622
4011
4012         Reviewed by Yusuke Suzuki.
4013
4014         * bmalloc/Algorithm.h:
4015         (bmalloc::mask):
4016         (bmalloc::roundUpToMultipleOf):
4017
4018 2017-07-03  Andy Estes  <aestes@apple.com>
4019
4020         [Xcode] Add an experimental setting to build with ccache
4021         https://bugs.webkit.org/show_bug.cgi?id=173875
4022
4023         Reviewed by Tim Horton.
4024
4025         * Configurations/DebugRelease.xcconfig: Included ccache.xcconfig.
4026
4027 2017-07-01  Dan Bernstein  <mitz@apple.com>
4028
4029         [iOS] Remove code only needed when building for iOS 9.x
4030         https://bugs.webkit.org/show_bug.cgi?id=174068
4031
4032         Reviewed by Tim Horton.
4033
4034         * bmalloc/BPlatform.h:
4035         * bmalloc/VMAllocate.h:
4036         (bmalloc::vmPageSizePhysical):
4037
4038 2017-07-01  Dan Bernstein  <mitz@apple.com>
4039
4040         [macOS] Remove code only needed when building for OS X Yosemite
4041         https://bugs.webkit.org/show_bug.cgi?id=174067
4042
4043         Reviewed by Tim Horton.
4044
4045         * Configurations/Base.xcconfig:
4046         * Configurations/DebugRelease.xcconfig:
4047
4048 2017-06-30  Ryosuke Niwa  <rniwa@webkit.org>
4049
4050         Ran sort-Xcode-project-file.
4051
4052         * bmalloc.xcodeproj/project.pbxproj:
4053
4054 2017-06-19  Geoffrey Garen  <ggaren@apple.com>
4055
4056         bmalloc: Add a per-thread line cache
4057         https://bugs.webkit.org/show_bug.cgi?id=173552
4058
4059         Reviewed by Darin Adler.
4060
4061         Previously, any thread could allocate out of any page with free lines.
4062         Now, the first thread to free a line in a page owns that page's free
4063         lines until the whole page becomes free.
4064
4065         This patch is a big speedup on multi-threaded benchmarks.
4066         tree_churn --parallel gets 14% faster on a 2-core (4-hyper-core) MacBook
4067         Air and 2.85X faster on 12-core (24-hyper-core) Mac Pro. Other parallel
4068         benchmarks show significant but smaller speedups.
4069
4070         Thread affinity is a great predictor of object lifetime. The per-thread
4071         line cache avoids the pathology of shuffling pages between threads,
4072         turning predictable lifetimes into unpredictable lifetimes, increasing
4073         fragmentation. On tree_churn --parallel, the per-thread line cache
4074         increases free memory found per page scanned by 2.85X.
4075
4076         Free line scanning in fragmented pages is pretty expensive relative to
4077         other allocate / initialize / free operations. According to Instruments,
4078         on tree_churn --parallel, scanning is about 10X more expensive than
4079         freeing. This explains why a 2.85X improvement in scanning efficiency
4080         translates into a 2.85X overall speedup on tree_churn --parallel.
4081
4082         * bmalloc/Allocator.cpp:
4083         (bmalloc::Allocator::refillAllocatorSlowCase): Pass through our line
4084         cache so the Heap can fill it.
4085
4086         * bmalloc/Deallocator.cpp:
4087         (bmalloc::Deallocator::scavenge): Scavenge our line cache.
4088
4089         (bmalloc::Deallocator::processObjectLog): Deleted.
4090
4091         * bmalloc/Deallocator.h:
4092         (bmalloc::Deallocator::lineCache): Added a line cache.
4093
4094         * bmalloc/Heap.cpp:
4095         (bmalloc::Heap::deallocateLineCache): Deallocation function for thread
4096         destruction.
4097
4098         (bmalloc::Heap::allocateSmallPage):
4099         (bmalloc::Heap::deallocateSmallLine):
4100         (bmalloc::Heap::allocateSmallBumpRangesByMetadata):
4101         (bmalloc::Heap::allocateSmallBumpRangesByObject): Consult the new per-thread line
4102         cache for allocation and deallocation.
4103
4104         * bmalloc/Heap.h:
4105         (bmalloc::Heap::allocateSmallBumpRanges):
4106         (bmalloc::Heap::derefSmallLine):
4107
4108         * bmalloc/List.h:
4109         (bmalloc::List::remove): Remove has always been a logically static
4110         operation. Declare it static now so that the Heap can remove a page from