e804e1bd7bef996bcdcac364cd5129a1061bd5ff
[WebKit-https.git] / Source / JavaScriptCore / heap / MarkedBlock.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003-2019 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #pragma once
23
24 #include "CellAttributes.h"
25 #include "DestructionMode.h"
26 #include "HeapCell.h"
27 #include "IterationStatus.h"
28 #include "WeakSet.h"
29 #include <wtf/Atomics.h>
30 #include <wtf/Bitmap.h>
31 #include <wtf/HashFunctions.h>
32 #include <wtf/CountingLock.h>
33 #include <wtf/StdLibExtras.h>
34
35 namespace JSC {
36
37 class AlignedMemoryAllocator;    
38 class FreeList;
39 class Heap;
40 class JSCell;
41 class BlockDirectory;
42 class MarkedSpace;
43 class SlotVisitor;
44 class Subspace;
45
46 typedef uint32_t HeapVersion;
47
48 // A marked block is a page-aligned container for heap-allocated objects.
49 // Objects are allocated within cells of the marked block. For a given
50 // marked block, all cells have the same size. Objects smaller than the
51 // cell size may be allocated in the marked block, in which case the
52 // allocation suffers from internal fragmentation: wasted space whose
53 // size is equal to the difference between the cell size and the object
54 // size.
55 DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(MarkedBlock);
56 DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(MarkedBlockHandle);
57 class MarkedBlock {
58     WTF_MAKE_NONCOPYABLE(MarkedBlock);
59     WTF_MAKE_STRUCT_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(MarkedBlock);
60     friend class LLIntOffsetsExtractor;
61     friend struct VerifyMarked;
62
63 public:
64     class Footer;
65     class Handle;
66 private:
67     friend class Footer;
68     friend class Handle;
69 public:
70     static constexpr size_t atomSize = 16; // bytes
71
72     // Block size must be at least as large as the system page size.
73 #if CPU(PPC64) || CPU(PPC64LE) || CPU(PPC) || CPU(UNKNOWN)
74     static constexpr size_t blockSize = 64 * KB;
75 #else
76     static constexpr size_t blockSize = 16 * KB;
77 #endif
78
79     static constexpr size_t blockMask = ~(blockSize - 1); // blockSize must be a power of two.
80
81     static constexpr size_t atomsPerBlock = blockSize / atomSize;
82
83     static constexpr size_t maxNumberOfLowerTierCells = 8;
84     static_assert(maxNumberOfLowerTierCells <= 256);
85     
86     static_assert(!(MarkedBlock::atomSize & (MarkedBlock::atomSize - 1)), "MarkedBlock::atomSize must be a power of two.");
87     static_assert(!(MarkedBlock::blockSize & (MarkedBlock::blockSize - 1)), "MarkedBlock::blockSize must be a power of two.");
88     
89     struct VoidFunctor {
90         typedef void ReturnType;
91         void returnValue() { }
92     };
93     
94     class CountFunctor {
95     public:
96         typedef size_t ReturnType;
97
98         CountFunctor() : m_count(0) { }
99         void count(size_t count) const { m_count += count; }
100         ReturnType returnValue() const { return m_count; }
101
102     private:
103         // FIXME: This is mutable because we're using a functor rather than C++ lambdas.
104         // https://bugs.webkit.org/show_bug.cgi?id=159644
105         mutable ReturnType m_count;
106     };
107         
108     class Handle {
109         WTF_MAKE_NONCOPYABLE(Handle);
110         WTF_MAKE_STRUCT_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(MarkedBlockHandle);
111         friend class LLIntOffsetsExtractor;
112         friend class MarkedBlock;
113         friend struct VerifyMarked;
114     public:
115             
116         ~Handle();
117             
118         MarkedBlock& block();
119         MarkedBlock::Footer& blockFooter();
120             
121         void* cellAlign(void*);
122             
123         bool isEmpty();
124
125         void lastChanceToFinalize();
126
127         BlockDirectory* directory() const;
128         Subspace* subspace() const;
129         AlignedMemoryAllocator* alignedMemoryAllocator() const;
130         Heap* heap() const;
131         inline MarkedSpace* space() const;
132         VM& vm() const;
133         WeakSet& weakSet();
134             
135         enum SweepMode { SweepOnly, SweepToFreeList };
136
137         // Sweeping ensures that destructors get called and removes the block from the unswept
138         // set. Sweeping to free list also removes the block from the empty set, if it was in that
139         // set. Sweeping with SweepOnly may add this block to the empty set, if the block is found
140         // to be empty. The free-list being null implies SweepOnly.
141         //
142         // Note that you need to make sure that the empty bit reflects reality. If it's not set
143         // and the block is freshly created, then we'll make the mistake of running destructors in
144         // the block. If it's not set and the block has nothing marked, then we'll make the
145         // mistake of making a pop freelist rather than a bump freelist.
146         void sweep(FreeList*);
147         
148         // This is to be called by Subspace.
149         template<typename DestroyFunc>
150         void finishSweepKnowingHeapCellType(FreeList*, const DestroyFunc&);
151         
152         void unsweepWithNoNewlyAllocated();
153         
154         void shrink();
155             
156         void visitWeakSet(SlotVisitor&);
157         void reapWeakSet();
158             
159         // While allocating from a free list, MarkedBlock temporarily has bogus
160         // cell liveness data. To restore accurate cell liveness data, call one
161         // of these functions:
162         void didConsumeFreeList(); // Call this once you've allocated all the items in the free list.
163         void stopAllocating(const FreeList&);
164         void resumeAllocating(FreeList&); // Call this if you canonicalized a block for some non-collection related purpose.
165             
166         size_t cellSize();
167         inline unsigned cellsPerBlock();
168         
169         const CellAttributes& attributes() const;
170         DestructionMode destruction() const;
171         bool needsDestruction() const;
172         HeapCell::Kind cellKind() const;
173             
174         size_t markCount();
175         size_t size();
176         
177         bool isAllocated();
178         
179         bool isLive(HeapVersion markingVersion, HeapVersion newlyAllocatedVersion, bool isMarking, const HeapCell*);
180         inline bool isLiveCell(HeapVersion markingVersion, HeapVersion newlyAllocatedVersion, bool isMarking, const void*);
181
182         bool isLive(const HeapCell*);
183         bool isLiveCell(const void*);
184
185         bool isFreeListedCell(const void* target) const;
186
187         template <typename Functor> IterationStatus forEachCell(const Functor&);
188         template <typename Functor> inline IterationStatus forEachLiveCell(const Functor&);
189         template <typename Functor> inline IterationStatus forEachDeadCell(const Functor&);
190         template <typename Functor> inline IterationStatus forEachMarkedCell(const Functor&);
191             
192         JS_EXPORT_PRIVATE bool areMarksStale();
193         bool areMarksStaleForSweep();
194         
195         void assertMarksNotStale();
196             
197         bool isFreeListed() const { return m_isFreeListed; }
198         
199         unsigned index() const { return m_index; }
200         
201         void removeFromDirectory();
202         
203         void didAddToDirectory(BlockDirectory*, unsigned index);
204         void didRemoveFromDirectory();
205         
206         void* start() const { return &m_block->atoms()[0]; }
207         void* end() const { return &m_block->atoms()[m_endAtom]; }
208         bool contains(void* p) const { return start() <= p && p < end(); }
209
210         void dumpState(PrintStream&);
211         
212     private:
213         Handle(Heap&, AlignedMemoryAllocator*, void*);
214         
215         enum SweepDestructionMode { BlockHasNoDestructors, BlockHasDestructors, BlockHasDestructorsAndCollectorIsRunning };
216         enum ScribbleMode { DontScribble, Scribble };
217         enum EmptyMode { IsEmpty, NotEmpty };
218         enum NewlyAllocatedMode { HasNewlyAllocated, DoesNotHaveNewlyAllocated };
219         enum MarksMode { MarksStale, MarksNotStale };
220         
221         SweepDestructionMode sweepDestructionMode();
222         EmptyMode emptyMode();
223         ScribbleMode scribbleMode();
224         NewlyAllocatedMode newlyAllocatedMode();
225         MarksMode marksMode();
226         
227         template<bool, EmptyMode, SweepMode, SweepDestructionMode, ScribbleMode, NewlyAllocatedMode, MarksMode, typename DestroyFunc>
228         void specializedSweep(FreeList*, EmptyMode, SweepMode, SweepDestructionMode, ScribbleMode, NewlyAllocatedMode, MarksMode, const DestroyFunc&);
229         
230         void setIsFreeListed();
231         
232         unsigned m_atomsPerCell { std::numeric_limits<unsigned>::max() };
233         unsigned m_endAtom { std::numeric_limits<unsigned>::max() }; // This is a fuzzy end. Always test for < m_endAtom.
234             
235         CellAttributes m_attributes;
236         bool m_isFreeListed { false };
237         unsigned m_index { std::numeric_limits<unsigned>::max() };
238
239         AlignedMemoryAllocator* m_alignedMemoryAllocator { nullptr };
240         BlockDirectory* m_directory { nullptr };
241         WeakSet m_weakSet;
242         
243         MarkedBlock* m_block { nullptr };
244     };
245
246 private:    
247     static constexpr size_t atomAlignmentMask = atomSize - 1;
248
249     typedef char Atom[atomSize];
250
251 public:
252     class Footer {
253     public:
254         Footer(VM&, Handle&);
255         ~Footer();
256         
257     private:
258         friend class LLIntOffsetsExtractor;
259         friend class MarkedBlock;
260         
261         Handle& m_handle;
262         // m_vm must remain a pointer (instead of a reference) because JSCLLIntOffsetsExtractor
263         // will fail otherwise.
264         VM* m_vm;
265         Subspace* m_subspace;
266
267         CountingLock m_lock;
268     
269         // The actual mark count can be computed by doing: m_biasedMarkCount - m_markCountBias. Note
270         // that this count is racy. It will accurately detect whether or not exactly zero things were
271         // marked, but if N things got marked, then this may report anything in the range [1, N] (or
272         // before unbiased, it would be [1 + m_markCountBias, N + m_markCountBias].)
273         int16_t m_biasedMarkCount;
274     
275         // We bias the mark count so that if m_biasedMarkCount >= 0 then the block should be retired.
276         // We go to all this trouble to make marking a bit faster: this way, marking knows when to
277         // retire a block using a js/jns on m_biasedMarkCount.
278         //
279         // For example, if a block has room for 100 objects and retirement happens whenever 90% are
280         // live, then m_markCountBias will be -90. This way, when marking begins, this will cause us to
281         // set m_biasedMarkCount to -90 as well, since:
282         //
283         //     m_biasedMarkCount = actualMarkCount + m_markCountBias.
284         //
285         // Marking an object will increment m_biasedMarkCount. Once 90 objects get marked, we will have
286         // m_biasedMarkCount = 0, which will trigger retirement. In other words, we want to set
287         // m_markCountBias like so:
288         //
289         //     m_markCountBias = -(minMarkedBlockUtilization * cellsPerBlock)
290         //
291         // All of this also means that you can detect if any objects are marked by doing:
292         //
293         //     m_biasedMarkCount != m_markCountBias
294         int16_t m_markCountBias;
295
296         HeapVersion m_markingVersion;
297         HeapVersion m_newlyAllocatedVersion;
298
299         Bitmap<atomsPerBlock> m_marks;
300         Bitmap<atomsPerBlock> m_newlyAllocated;
301     };
302     
303 private:    
304     Footer& footer();
305     const Footer& footer() const;
306
307 public:
308     static constexpr size_t endAtom = (blockSize - sizeof(Footer)) / atomSize;
309     static constexpr size_t payloadSize = endAtom * atomSize;
310     static constexpr size_t footerSize = blockSize - payloadSize;
311
312     static_assert(payloadSize == ((blockSize - sizeof(MarkedBlock::Footer)) & ~(atomSize - 1)), "Payload size computed the alternate way should give the same result");
313     
314     static MarkedBlock::Handle* tryCreate(Heap&, AlignedMemoryAllocator*);
315         
316     Handle& handle();
317     const Handle& handle() const;
318         
319     VM& vm() const;
320     inline Heap* heap() const;
321     inline MarkedSpace* space() const;
322
323     static bool isAtomAligned(const void*);
324     static MarkedBlock* blockFor(const void*);
325     unsigned atomNumber(const void*);
326     size_t candidateAtomNumber(const void*);
327         
328     size_t markCount();
329
330     bool isMarked(const void*);
331     bool isMarked(HeapVersion markingVersion, const void*);
332     bool isMarked(const void*, Dependency);
333     bool testAndSetMarked(const void*, Dependency);
334         
335     bool isAtom(const void*);
336     void clearMarked(const void*);
337     
338     bool isNewlyAllocated(const void*);
339     void setNewlyAllocated(const void*);
340     void clearNewlyAllocated(const void*);
341     const Bitmap<atomsPerBlock>& newlyAllocated() const;
342     
343     HeapVersion newlyAllocatedVersion() const { return footer().m_newlyAllocatedVersion; }
344     
345     inline bool isNewlyAllocatedStale() const;
346     
347     inline bool hasAnyNewlyAllocated();
348     void resetAllocated();
349         
350     size_t cellSize();
351     const CellAttributes& attributes() const;
352     
353     bool hasAnyMarked() const;
354     void noteMarked();
355 #if ASSERT_ENABLED
356     void assertValidCell(VM&, HeapCell*) const;
357 #else
358     void assertValidCell(VM&, HeapCell*) const { }
359 #endif
360         
361     WeakSet& weakSet();
362
363     JS_EXPORT_PRIVATE bool areMarksStale();
364     bool areMarksStale(HeapVersion markingVersion);
365     
366     Dependency aboutToMark(HeapVersion markingVersion);
367         
368 #if ASSERT_ENABLED
369     JS_EXPORT_PRIVATE void assertMarksNotStale();
370 #else
371     void assertMarksNotStale() { }
372 #endif
373         
374     void resetMarks();
375     
376     bool isMarkedRaw(const void* p);
377     HeapVersion markingVersion() const { return footer().m_markingVersion; }
378     
379     const Bitmap<atomsPerBlock>& marks() const;
380     
381     CountingLock& lock() { return footer().m_lock; }
382     
383     Subspace* subspace() const { return footer().m_subspace; }
384
385     void populatePage() const
386     {
387         *bitwise_cast<volatile uint8_t*>(&footer());
388     }
389     
390     static constexpr size_t offsetOfFooter = endAtom * atomSize;
391
392 private:
393     MarkedBlock(VM&, Handle&);
394     ~MarkedBlock();
395     Atom* atoms();
396         
397     JS_EXPORT_PRIVATE void aboutToMarkSlow(HeapVersion markingVersion);
398     void clearHasAnyMarked();
399     
400     void noteMarkedSlow();
401     
402     inline bool marksConveyLivenessDuringMarking(HeapVersion markingVersion);
403     inline bool marksConveyLivenessDuringMarking(HeapVersion myMarkingVersion, HeapVersion markingVersion);
404 };
405
406 inline MarkedBlock::Footer& MarkedBlock::footer()
407 {
408     return *bitwise_cast<MarkedBlock::Footer*>(atoms() + endAtom);
409 }
410
411 inline const MarkedBlock::Footer& MarkedBlock::footer() const
412 {
413     return const_cast<MarkedBlock*>(this)->footer();
414 }
415
416 inline MarkedBlock::Handle& MarkedBlock::handle()
417 {
418     return footer().m_handle;
419 }
420
421 inline const MarkedBlock::Handle& MarkedBlock::handle() const
422 {
423     return const_cast<MarkedBlock*>(this)->handle();
424 }
425
426 inline MarkedBlock& MarkedBlock::Handle::block()
427 {
428     return *m_block;
429 }
430
431 inline MarkedBlock::Footer& MarkedBlock::Handle::blockFooter()
432 {
433     return block().footer();
434 }
435
436 inline MarkedBlock::Atom* MarkedBlock::atoms()
437 {
438     return reinterpret_cast<Atom*>(this);
439 }
440
441 inline bool MarkedBlock::isAtomAligned(const void* p)
442 {
443     return !(reinterpret_cast<uintptr_t>(p) & atomAlignmentMask);
444 }
445
446 inline void* MarkedBlock::Handle::cellAlign(void* p)
447 {
448     uintptr_t base = reinterpret_cast<uintptr_t>(block().atoms());
449     uintptr_t bits = reinterpret_cast<uintptr_t>(p);
450     bits -= base;
451     bits -= bits % cellSize();
452     bits += base;
453     return reinterpret_cast<void*>(bits);
454 }
455
456 inline MarkedBlock* MarkedBlock::blockFor(const void* p)
457 {
458     return reinterpret_cast<MarkedBlock*>(reinterpret_cast<uintptr_t>(p) & blockMask);
459 }
460
461 inline BlockDirectory* MarkedBlock::Handle::directory() const
462 {
463     return m_directory;
464 }
465
466 inline AlignedMemoryAllocator* MarkedBlock::Handle::alignedMemoryAllocator() const
467 {
468     return m_alignedMemoryAllocator;
469 }
470
471 inline Heap* MarkedBlock::Handle::heap() const
472 {
473     return m_weakSet.heap();
474 }
475
476 inline VM& MarkedBlock::Handle::vm() const
477 {
478     return m_weakSet.vm();
479 }
480
481 inline VM& MarkedBlock::vm() const
482 {
483     return *footer().m_vm;
484 }
485
486 inline WeakSet& MarkedBlock::Handle::weakSet()
487 {
488     return m_weakSet;
489 }
490
491 inline WeakSet& MarkedBlock::weakSet()
492 {
493     return handle().weakSet();
494 }
495
496 inline void MarkedBlock::Handle::shrink()
497 {
498     m_weakSet.shrink();
499 }
500
501 inline void MarkedBlock::Handle::visitWeakSet(SlotVisitor& visitor)
502 {
503     return m_weakSet.visit(visitor);
504 }
505
506 inline void MarkedBlock::Handle::reapWeakSet()
507 {
508     m_weakSet.reap();
509 }
510
511 inline size_t MarkedBlock::Handle::cellSize()
512 {
513     return m_atomsPerCell * atomSize;
514 }
515
516 inline size_t MarkedBlock::cellSize()
517 {
518     return handle().cellSize();
519 }
520
521 inline const CellAttributes& MarkedBlock::Handle::attributes() const
522 {
523     return m_attributes;
524 }
525
526 inline const CellAttributes& MarkedBlock::attributes() const
527 {
528     return handle().attributes();
529 }
530
531 inline bool MarkedBlock::Handle::needsDestruction() const
532 {
533     return m_attributes.destruction == NeedsDestruction;
534 }
535
536 inline DestructionMode MarkedBlock::Handle::destruction() const
537 {
538     return m_attributes.destruction;
539 }
540
541 inline HeapCell::Kind MarkedBlock::Handle::cellKind() const
542 {
543     return m_attributes.cellKind;
544 }
545
546 inline size_t MarkedBlock::Handle::markCount()
547 {
548     return m_block->markCount();
549 }
550
551 inline size_t MarkedBlock::Handle::size()
552 {
553     return markCount() * cellSize();
554 }
555
556 inline size_t MarkedBlock::candidateAtomNumber(const void* p)
557 {
558     // This function must return size_t instead of unsigned since pointer |p| is not guaranteed that this is within MarkedBlock.
559     // See MarkedBlock::isAtom which can accept out-of-bound pointers.
560     return (reinterpret_cast<uintptr_t>(p) - reinterpret_cast<uintptr_t>(this)) / atomSize;
561 }
562
563 inline unsigned MarkedBlock::atomNumber(const void* p)
564 {
565     size_t atomNumber = candidateAtomNumber(p);
566     ASSERT(atomNumber < handle().m_endAtom);
567     return atomNumber;
568 }
569
570 inline bool MarkedBlock::areMarksStale(HeapVersion markingVersion)
571 {
572     return markingVersion != footer().m_markingVersion;
573 }
574
575 inline Dependency MarkedBlock::aboutToMark(HeapVersion markingVersion)
576 {
577     HeapVersion version = footer().m_markingVersion;
578     if (UNLIKELY(version != markingVersion))
579         aboutToMarkSlow(markingVersion);
580     return Dependency::fence(version);
581 }
582
583 inline void MarkedBlock::Handle::assertMarksNotStale()
584 {
585     block().assertMarksNotStale();
586 }
587
588 inline bool MarkedBlock::isMarkedRaw(const void* p)
589 {
590     return footer().m_marks.get(atomNumber(p));
591 }
592
593 inline bool MarkedBlock::isMarked(HeapVersion markingVersion, const void* p)
594 {
595     HeapVersion version = footer().m_markingVersion;
596     if (UNLIKELY(version != markingVersion))
597         return false;
598     return footer().m_marks.get(atomNumber(p), Dependency::fence(version));
599 }
600
601 inline bool MarkedBlock::isMarked(const void* p, Dependency dependency)
602 {
603     assertMarksNotStale();
604     return footer().m_marks.get(atomNumber(p), dependency);
605 }
606
607 inline bool MarkedBlock::testAndSetMarked(const void* p, Dependency dependency)
608 {
609     assertMarksNotStale();
610     return footer().m_marks.concurrentTestAndSet(atomNumber(p), dependency);
611 }
612
613 inline const Bitmap<MarkedBlock::atomsPerBlock>& MarkedBlock::marks() const
614 {
615     return footer().m_marks;
616 }
617
618 inline bool MarkedBlock::isNewlyAllocated(const void* p)
619 {
620     return footer().m_newlyAllocated.get(atomNumber(p));
621 }
622
623 inline void MarkedBlock::setNewlyAllocated(const void* p)
624 {
625     footer().m_newlyAllocated.set(atomNumber(p));
626 }
627
628 inline void MarkedBlock::clearNewlyAllocated(const void* p)
629 {
630     footer().m_newlyAllocated.clear(atomNumber(p));
631 }
632
633 inline const Bitmap<MarkedBlock::atomsPerBlock>& MarkedBlock::newlyAllocated() const
634 {
635     return footer().m_newlyAllocated;
636 }
637
638 inline bool MarkedBlock::isAtom(const void* p)
639 {
640     ASSERT(MarkedBlock::isAtomAligned(p));
641     size_t atomNumber = candidateAtomNumber(p);
642     if (atomNumber % handle().m_atomsPerCell) // Filters pointers into cell middles.
643         return false;
644     if (atomNumber >= handle().m_endAtom) // Filters pointers into invalid cells out of the range.
645         return false;
646     return true;
647 }
648
649 template <typename Functor>
650 inline IterationStatus MarkedBlock::Handle::forEachCell(const Functor& functor)
651 {
652     HeapCell::Kind kind = m_attributes.cellKind;
653     for (size_t i = 0; i < m_endAtom; i += m_atomsPerCell) {
654         HeapCell* cell = reinterpret_cast_ptr<HeapCell*>(&m_block->atoms()[i]);
655         if (functor(i, cell, kind) == IterationStatus::Done)
656             return IterationStatus::Done;
657     }
658     return IterationStatus::Continue;
659 }
660
661 inline bool MarkedBlock::hasAnyMarked() const
662 {
663     return footer().m_biasedMarkCount != footer().m_markCountBias;
664 }
665
666 inline void MarkedBlock::noteMarked()
667 {
668     // This is racy by design. We don't want to pay the price of an atomic increment!
669     int16_t biasedMarkCount = footer().m_biasedMarkCount;
670     ++biasedMarkCount;
671     footer().m_biasedMarkCount = biasedMarkCount;
672     if (UNLIKELY(!biasedMarkCount))
673         noteMarkedSlow();
674 }
675
676 } // namespace JSC
677
678 namespace WTF {
679
680 struct MarkedBlockHash : PtrHash<JSC::MarkedBlock*> {
681     static unsigned hash(JSC::MarkedBlock* const& key)
682     {
683         // Aligned VM regions tend to be monotonically increasing integers,
684         // which is a great hash function, but we have to remove the low bits,
685         // since they're always zero, which is a terrible hash function!
686         return reinterpret_cast<uintptr_t>(key) / JSC::MarkedBlock::blockSize;
687     }
688 };
689
690 template<> struct DefaultHash<JSC::MarkedBlock*> {
691     typedef MarkedBlockHash Hash;
692 };
693
694 void printInternal(PrintStream& out, JSC::MarkedBlock::Handle::SweepMode);
695
696 } // namespace WTF