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