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