Changeset 252302 in webkit

Timestamp:

Nov 8, 2019 7:45:18 PM (4 years ago)

Author:

ysuzuki@apple.com

Message:

[JSC] Rename LargeAllocation to PreciseAllocation
​https://bugs.webkit.org/show_bug.cgi?id=204040

Reviewed by Keith Miller.

After r252298, LargeAllocation is also used for small allocations.
This patch renames from LargeAllocation to PreciseAllocation since it reflects the behavior.

• CMakeLists.txt:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Sources.txt:
• heap/CellContainer.cpp:

(JSC::CellContainer::isNewlyAllocated const):

• heap/CellContainer.h:

(JSC::CellContainer::CellContainer):
(JSC::CellContainer::isMarkedBlock const):
(JSC::CellContainer::isPreciseAllocation const):
(JSC::CellContainer::preciseAllocation const):
(JSC::CellContainer::isLargeAllocation const): Deleted.
(JSC::CellContainer::largeAllocation const): Deleted.

• heap/CellContainerInlines.h:

(JSC::CellContainer::vm const):
(JSC::CellContainer::isMarked const):
(JSC::CellContainer::noteMarked):
(JSC::CellContainer::assertValidCell const):
(JSC::CellContainer::cellSize const):
(JSC::CellContainer::weakSet const):
(JSC::CellContainer::aboutToMark):
(JSC::CellContainer::areMarksStale const):

• heap/CompleteSubspace.cpp:

(JSC::CompleteSubspace::tryAllocateSlow):
(JSC::CompleteSubspace::reallocatePreciseAllocationNonVirtual):
(JSC::CompleteSubspace::reallocateLargeAllocationNonVirtual): Deleted.

• heap/CompleteSubspace.h:
• heap/Heap.cpp:

(JSC::Heap::sweepInFinalize):

• heap/HeapCell.cpp:

(JSC::HeapCell::isLive):

• heap/HeapCell.h:
• heap/HeapCellInlines.h:

(JSC::HeapCell::isPreciseAllocation const):
(JSC::HeapCell::cellContainer const):
(JSC::HeapCell::preciseAllocation const):
(JSC::HeapCell::vm const):
(JSC::HeapCell::cellSize const):
(JSC::HeapCell::cellAttributes const):
(JSC::HeapCell::subspace const):
(JSC::HeapCell::isLargeAllocation const): Deleted.
(JSC::HeapCell::largeAllocation const): Deleted.

• heap/HeapInlines.h:

(JSC::Heap::isMarked):
(JSC::Heap::testAndSetMarked):

• heap/HeapUtil.h:

(JSC::HeapUtil::findGCObjectPointersForMarking):
(JSC::HeapUtil::isPointerGCObjectJSCell):
(JSC::HeapUtil::isValueGCObject):

• heap/IsoAlignedMemoryAllocator.cpp:

(JSC::IsoAlignedMemoryAllocator::tryReallocateMemory):

• heap/IsoCellSetInlines.h:

(JSC::IsoCellSet::add):
(JSC::IsoCellSet::remove):
(JSC::IsoCellSet::contains const):
(JSC::IsoCellSet::forEachMarkedCell):
(JSC::IsoCellSet::forEachMarkedCellInParallel):
(JSC::IsoCellSet::forEachLiveCell):

• heap/IsoSubspace.cpp:

(JSC::IsoSubspace::tryAllocateFromLowerTier):
(JSC::IsoSubspace::sweepLowerTierCell):
(JSC::IsoSubspace::destroyLowerTierFreeList):

• heap/IsoSubspace.h:
• heap/MarkedSpace.cpp:

(JSC::MarkedSpace::freeMemory):
(JSC::MarkedSpace::lastChanceToFinalize):
(JSC::MarkedSpace::sweepPreciseAllocations):
(JSC::MarkedSpace::prepareForAllocation):
(JSC::MarkedSpace::enablePreciseAllocationTracking):
(JSC::MarkedSpace::prepareForConservativeScan):
(JSC::MarkedSpace::prepareForMarking):
(JSC::MarkedSpace::resumeAllocating):
(JSC::MarkedSpace::isPagedOut):
(JSC::MarkedSpace::beginMarking):
(JSC::MarkedSpace::endMarking):
(JSC::MarkedSpace::objectCount):
(JSC::MarkedSpace::size):
(JSC::MarkedSpace::sweepLargeAllocations): Deleted.
(JSC::MarkedSpace::enableLargeAllocationTracking): Deleted.

• heap/MarkedSpace.h:

(JSC::MarkedSpace:: const):
(JSC::MarkedSpace::preciseAllocationsNurseryOffset const):
(JSC::MarkedSpace::preciseAllocationsOffsetForThisCollection const):
(JSC::MarkedSpace::preciseAllocationsForThisCollectionBegin const):
(JSC::MarkedSpace::preciseAllocationsForThisCollectionEnd const):
(JSC::MarkedSpace::preciseAllocationsForThisCollectionSize const):
(JSC::MarkedSpace::largeAllocationsNurseryOffset const): Deleted.
(JSC::MarkedSpace::largeAllocationsOffsetForThisCollection const): Deleted.
(JSC::MarkedSpace::largeAllocationsForThisCollectionBegin const): Deleted.
(JSC::MarkedSpace::largeAllocationsForThisCollectionEnd const): Deleted.
(JSC::MarkedSpace::largeAllocationsForThisCollectionSize const): Deleted.

• heap/MarkedSpaceInlines.h:

(JSC::MarkedSpace::forEachLiveCell):
(JSC::MarkedSpace::forEachDeadCell):

• heap/PreciseAllocation.cpp: Renamed from Source/JavaScriptCore/heap/LargeAllocation.cpp.

(JSC::isAlignedForPreciseAllocation):
(JSC::PreciseAllocation::tryCreate):
(JSC::PreciseAllocation::tryReallocate):
(JSC::PreciseAllocation::createForLowerTier):
(JSC::PreciseAllocation::reuseForLowerTier):
(JSC::PreciseAllocation::PreciseAllocation):
(JSC::PreciseAllocation::~PreciseAllocation):
(JSC::PreciseAllocation::lastChanceToFinalize):
(JSC::PreciseAllocation::shrink):
(JSC::PreciseAllocation::visitWeakSet):
(JSC::PreciseAllocation::reapWeakSet):
(JSC::PreciseAllocation::flip):
(JSC::PreciseAllocation::isEmpty):
(JSC::PreciseAllocation::sweep):
(JSC::PreciseAllocation::destroy):
(JSC::PreciseAllocation::dump const):
(JSC::PreciseAllocation::assertValidCell const):

• heap/PreciseAllocation.h: Renamed from Source/JavaScriptCore/heap/LargeAllocation.h.

(JSC::PreciseAllocation::fromCell):
(JSC::PreciseAllocation::isPreciseAllocation):
(JSC::PreciseAllocation::headerSize):
(JSC::PreciseAllocation::basePointer const):

• heap/SlotVisitor.cpp:

(JSC::SlotVisitor::appendHiddenSlowImpl):
(JSC::SlotVisitor::appendToMarkStack):

• heap/SlotVisitorInlines.h:

(JSC::SlotVisitor::appendUnbarriered):
(JSC::SlotVisitor::appendHiddenUnbarriered):

• heap/Subspace.h:
• heap/SubspaceInlines.h:

(JSC::Subspace::forEachPreciseAllocation):
(JSC::Subspace::forEachMarkedCell):
(JSC::Subspace::forEachMarkedCellInParallel):
(JSC::Subspace::forEachLiveCell):
(JSC::Subspace::forEachLargeAllocation): Deleted.

• heap/WeakBlock.cpp:

(JSC::WeakBlock::visit):

• heap/WeakSet.cpp:

(JSC::WeakSet::sweep):

• llint/LowLevelInterpreter.asm:
• runtime/ButterflyInlines.h:

(JSC::Butterfly::reallocArrayRightIfPossible):

• runtime/OptionsList.h:
• runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::SamplingProfiler):

• tools/VMInspector.cpp:

(JSC::VMInspector::isInHeap):

• tools/VMInspectorInlines.h:

(JSC::VMInspector::verifyCell):

Location:

trunk/Source/JavaScriptCore

Files:

• CMakeLists.txt (modified) (2 diffs)
• ChangeLog (modified) (1 diff)
• JavaScriptCore.xcodeproj/project.pbxproj (modified) (8 diffs)
• Sources.txt (modified) (1 diff)
• heap/CellContainer.cpp (modified) (1 diff)
• heap/CellContainer.h (modified) (6 diffs)
• heap/CellContainerInlines.h (modified) (10 diffs)
• heap/CompleteSubspace.cpp (modified) (7 diffs)
• heap/CompleteSubspace.h (modified) (1 diff)
• heap/Heap.cpp (modified) (1 diff)
• heap/HeapCell.cpp (modified) (1 diff)
• heap/HeapCell.h (modified) (2 diffs)
• heap/HeapCellInlines.h (modified) (6 diffs)
• heap/HeapInlines.h (modified) (2 diffs)
• heap/HeapUtil.h (modified) (3 diffs)
• heap/IsoAlignedMemoryAllocator.cpp (modified) (1 diff)
• heap/IsoCellSetInlines.h (modified) (7 diffs)
• heap/IsoSubspace.cpp (modified) (4 diffs)
• heap/IsoSubspace.h (modified) (2 diffs)
• heap/MarkedSpace.cpp (modified) (14 diffs)
• heap/MarkedSpace.h (modified) (4 diffs)
• heap/MarkedSpaceInlines.h (modified) (2 diffs)
• heap/PreciseAllocation.cpp (moved) (moved from trunk/Source/JavaScriptCore/heap/LargeAllocation.cpp) (15 diffs)
• heap/PreciseAllocation.h (moved) (moved from trunk/Source/JavaScriptCore/heap/LargeAllocation.h) (4 diffs)
• heap/SlotVisitor.cpp (modified) (2 diffs)
• heap/SlotVisitorInlines.h (modified) (2 diffs)
• heap/Subspace.h (modified) (2 diffs)
• heap/SubspaceInlines.h (modified) (5 diffs)
• heap/WeakBlock.cpp (modified) (1 diff)
• heap/WeakSet.cpp (modified) (1 diff)
• llint/LowLevelInterpreter.asm (modified) (2 diffs)
• runtime/ButterflyInlines.h (modified) (1 diff)
• runtime/OptionsList.h (modified) (1 diff)
• runtime/SamplingProfiler.cpp (modified) (1 diff)
• tools/VMInspector.cpp (modified) (1 diff)
• tools/VMInspectorInlines.h (modified) (1 diff)

trunk/Source/JavaScriptCore/CMakeLists.txt

@@ -617 +617 @@
     heap/IsoSubspaceInlines.h
     heap/IsoSubspacePerVM.h
-    heap/LargeAllocation.h
     heap/LocalAllocator.h
     heap/LocalAllocatorInlines.h
@@ -630 +629 @@
     heap/MutatorState.h
     heap/PackedCellPtr.h
+    heap/PreciseAllocation.h
     heap/RegisterState.h
     heap/RunningScope.h

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2019-11-08  Yusuke Suzuki  <ysuzuki@apple.com>
+
+        [JSC] Rename LargeAllocation to PreciseAllocation
+        https://bugs.webkit.org/show_bug.cgi?id=204040
+
+        Reviewed by Keith Miller.
+
+        After r252298, LargeAllocation is also used for small allocations.
+        This patch renames from LargeAllocation to PreciseAllocation since it reflects the behavior.
+
+        * CMakeLists.txt:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * Sources.txt:
+        * heap/CellContainer.cpp:
+        (JSC::CellContainer::isNewlyAllocated const):
+        * heap/CellContainer.h:
+        (JSC::CellContainer::CellContainer):
+        (JSC::CellContainer::isMarkedBlock const):
+        (JSC::CellContainer::isPreciseAllocation const):
+        (JSC::CellContainer::preciseAllocation const):
+        (JSC::CellContainer::isLargeAllocation const): Deleted.
+        (JSC::CellContainer::largeAllocation const): Deleted.
+        * heap/CellContainerInlines.h:
+        (JSC::CellContainer::vm const):
+        (JSC::CellContainer::isMarked const):
+        (JSC::CellContainer::noteMarked):
+        (JSC::CellContainer::assertValidCell const):
+        (JSC::CellContainer::cellSize const):
+        (JSC::CellContainer::weakSet const):
+        (JSC::CellContainer::aboutToMark):
+        (JSC::CellContainer::areMarksStale const):
+        * heap/CompleteSubspace.cpp:
+        (JSC::CompleteSubspace::tryAllocateSlow):
+        (JSC::CompleteSubspace::reallocatePreciseAllocationNonVirtual):
+        (JSC::CompleteSubspace::reallocateLargeAllocationNonVirtual): Deleted.
+        * heap/CompleteSubspace.h:
+        * heap/Heap.cpp:
+        (JSC::Heap::sweepInFinalize):
+        * heap/HeapCell.cpp:
+        (JSC::HeapCell::isLive):
+        * heap/HeapCell.h:
+        * heap/HeapCellInlines.h:
+        (JSC::HeapCell::isPreciseAllocation const):
+        (JSC::HeapCell::cellContainer const):
+        (JSC::HeapCell::preciseAllocation const):
+        (JSC::HeapCell::vm const):
+        (JSC::HeapCell::cellSize const):
+        (JSC::HeapCell::cellAttributes const):
+        (JSC::HeapCell::subspace const):
+        (JSC::HeapCell::isLargeAllocation const): Deleted.
+        (JSC::HeapCell::largeAllocation const): Deleted.
+        * heap/HeapInlines.h:
+        (JSC::Heap::isMarked):
+        (JSC::Heap::testAndSetMarked):
+        * heap/HeapUtil.h:
+        (JSC::HeapUtil::findGCObjectPointersForMarking):
+        (JSC::HeapUtil::isPointerGCObjectJSCell):
+        (JSC::HeapUtil::isValueGCObject):
+        * heap/IsoAlignedMemoryAllocator.cpp:
+        (JSC::IsoAlignedMemoryAllocator::tryReallocateMemory):
+        * heap/IsoCellSetInlines.h:
+        (JSC::IsoCellSet::add):
+        (JSC::IsoCellSet::remove):
+        (JSC::IsoCellSet::contains const):
+        (JSC::IsoCellSet::forEachMarkedCell):
+        (JSC::IsoCellSet::forEachMarkedCellInParallel):
+        (JSC::IsoCellSet::forEachLiveCell):
+        * heap/IsoSubspace.cpp:
+        (JSC::IsoSubspace::tryAllocateFromLowerTier):
+        (JSC::IsoSubspace::sweepLowerTierCell):
+        (JSC::IsoSubspace::destroyLowerTierFreeList):
+        * heap/IsoSubspace.h:
+        * heap/MarkedSpace.cpp:
+        (JSC::MarkedSpace::freeMemory):
+        (JSC::MarkedSpace::lastChanceToFinalize):
+        (JSC::MarkedSpace::sweepPreciseAllocations):
+        (JSC::MarkedSpace::prepareForAllocation):
+        (JSC::MarkedSpace::enablePreciseAllocationTracking):
+        (JSC::MarkedSpace::prepareForConservativeScan):
+        (JSC::MarkedSpace::prepareForMarking):
+        (JSC::MarkedSpace::resumeAllocating):
+        (JSC::MarkedSpace::isPagedOut):
+        (JSC::MarkedSpace::beginMarking):
+        (JSC::MarkedSpace::endMarking):
+        (JSC::MarkedSpace::objectCount):
+        (JSC::MarkedSpace::size):
+        (JSC::MarkedSpace::sweepLargeAllocations): Deleted.
+        (JSC::MarkedSpace::enableLargeAllocationTracking): Deleted.
+        * heap/MarkedSpace.h:
+        (JSC::MarkedSpace:: const):
+        (JSC::MarkedSpace::preciseAllocationsNurseryOffset const):
+        (JSC::MarkedSpace::preciseAllocationsOffsetForThisCollection const):
+        (JSC::MarkedSpace::preciseAllocationsForThisCollectionBegin const):
+        (JSC::MarkedSpace::preciseAllocationsForThisCollectionEnd const):
+        (JSC::MarkedSpace::preciseAllocationsForThisCollectionSize const):
+        (JSC::MarkedSpace::largeAllocationsNurseryOffset const): Deleted.
+        (JSC::MarkedSpace::largeAllocationsOffsetForThisCollection const): Deleted.
+        (JSC::MarkedSpace::largeAllocationsForThisCollectionBegin const): Deleted.
+        (JSC::MarkedSpace::largeAllocationsForThisCollectionEnd const): Deleted.
+        (JSC::MarkedSpace::largeAllocationsForThisCollectionSize const): Deleted.
+        * heap/MarkedSpaceInlines.h:
+        (JSC::MarkedSpace::forEachLiveCell):
+        (JSC::MarkedSpace::forEachDeadCell):
+        * heap/PreciseAllocation.cpp: Renamed from Source/JavaScriptCore/heap/LargeAllocation.cpp.
+        (JSC::isAlignedForPreciseAllocation):
+        (JSC::PreciseAllocation::tryCreate):
+        (JSC::PreciseAllocation::tryReallocate):
+        (JSC::PreciseAllocation::createForLowerTier):
+        (JSC::PreciseAllocation::reuseForLowerTier):
+        (JSC::PreciseAllocation::PreciseAllocation):
+        (JSC::PreciseAllocation::~PreciseAllocation):
+        (JSC::PreciseAllocation::lastChanceToFinalize):
+        (JSC::PreciseAllocation::shrink):
+        (JSC::PreciseAllocation::visitWeakSet):
+        (JSC::PreciseAllocation::reapWeakSet):
+        (JSC::PreciseAllocation::flip):
+        (JSC::PreciseAllocation::isEmpty):
+        (JSC::PreciseAllocation::sweep):
+        (JSC::PreciseAllocation::destroy):
+        (JSC::PreciseAllocation::dump const):
+        (JSC::PreciseAllocation::assertValidCell const):
+        * heap/PreciseAllocation.h: Renamed from Source/JavaScriptCore/heap/LargeAllocation.h.
+        (JSC::PreciseAllocation::fromCell):
+        (JSC::PreciseAllocation::isPreciseAllocation):
+        (JSC::PreciseAllocation::headerSize):
+        (JSC::PreciseAllocation::basePointer const):
+        * heap/SlotVisitor.cpp:
+        (JSC::SlotVisitor::appendHiddenSlowImpl):
+        (JSC::SlotVisitor::appendToMarkStack):
+        * heap/SlotVisitorInlines.h:
+        (JSC::SlotVisitor::appendUnbarriered):
+        (JSC::SlotVisitor::appendHiddenUnbarriered):
+        * heap/Subspace.h:
+        * heap/SubspaceInlines.h:
+        (JSC::Subspace::forEachPreciseAllocation):
+        (JSC::Subspace::forEachMarkedCell):
+        (JSC::Subspace::forEachMarkedCellInParallel):
+        (JSC::Subspace::forEachLiveCell):
+        (JSC::Subspace::forEachLargeAllocation): Deleted.
+        * heap/WeakBlock.cpp:
+        (JSC::WeakBlock::visit):
+        * heap/WeakSet.cpp:
+        (JSC::WeakSet::sweep):
+        * llint/LowLevelInterpreter.asm:
+        * runtime/ButterflyInlines.h:
+        (JSC::Butterfly::reallocArrayRightIfPossible):
+        * runtime/OptionsList.h:
+        * runtime/SamplingProfiler.cpp:
+        (JSC::SamplingProfiler::SamplingProfiler):
+        * tools/VMInspector.cpp:
+        (JSC::VMInspector::isInHeap):
+        * tools/VMInspectorInlines.h:
+        (JSC::VMInspector::verifyCell):
+
 2019-11-08  Yusuke Suzuki  <ysuzuki@apple.com>
 

trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

@@ -135 +135 @@
                 0F070A481D543A90006E7232 /* CellContainerInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F070A431D543A89006E7232 /* CellContainerInlines.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0F070A491D543A93006E7232 /* HeapCellInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F070A441D543A89006E7232 /* HeapCellInlines.h */; settings = {ATTRIBUTES = (Private, ); }; };
-                0F070A4B1D543A98006E7232 /* LargeAllocation.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F070A461D543A89006E7232 /* LargeAllocation.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                0F070A4B1D543A98006E7232 /* PreciseAllocation.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F070A461D543A89006E7232 /* PreciseAllocation.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0F0776BF14FF002B00102332 /* JITCompilationEffort.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0776BD14FF002800102332 /* JITCompilationEffort.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0F0B286B1EB8E6CF000EB5D2 /* JSWeakPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0B286A1EB8E6CD000EB5D2 /* JSWeakPrivate.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -2222 +2222 @@
                 0F070A431D543A89006E7232 /* CellContainerInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CellContainerInlines.h; sourceTree = "<group>"; };
                 0F070A441D543A89006E7232 /* HeapCellInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HeapCellInlines.h; sourceTree = "<group>"; };
-                0F070A451D543A89006E7232 /* LargeAllocation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LargeAllocation.cpp; sourceTree = "<group>"; };
-                0F070A461D543A89006E7232 /* LargeAllocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LargeAllocation.h; sourceTree = "<group>"; };
+                0F070A451D543A89006E7232 /* PreciseAllocation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PreciseAllocation.cpp; sourceTree = "<group>"; };
+                0F070A461D543A89006E7232 /* PreciseAllocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PreciseAllocation.h; sourceTree = "<group>"; };
                 0F0776BD14FF002800102332 /* JITCompilationEffort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITCompilationEffort.h; sourceTree = "<group>"; };
                 0F0B28671EB8E6CD000EB5D2 /* JSMarkingConstraintPrivate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSMarkingConstraintPrivate.cpp; sourceTree = "<group>"; };
@@ -6202 +6202 @@
                                 0F766D2915A8CC34008F363E /* JITStubRoutineSet.cpp */,
                                 0F766D2A15A8CC34008F363E /* JITStubRoutineSet.h */,
-                                0F070A451D543A89006E7232 /* LargeAllocation.cpp */,
-                                0F070A461D543A89006E7232 /* LargeAllocation.h */,
                                 0F75A059200D25F00038E2CF /* LocalAllocator.cpp */,
                                 0F75A057200D25F00038E2CF /* LocalAllocator.h */,
@@ -6233 +6231 @@
                                 E356987122841183008CDCCB /* PackedCellPtr.h */,
                                 0F9DAA081FD1C3C80079C5B2 /* ParallelSourceAdapter.h */,
+                                0F070A451D543A89006E7232 /* PreciseAllocation.cpp */,
+                                0F070A461D543A89006E7232 /* PreciseAllocation.h */,
                                 0FBB73B61DEF3AAC002C009E /* PreventCollectionScope.h */,
                                 0FD0E5EF1E46BF230006AB08 /* RegisterState.h */,
@@ -8931 +8931 @@
                                 3395C70722555F6D00BDBFAD /* B3EliminateDeadCode.h in Headers */,
                                 0F5BF1711F23A5A10029D91D /* B3EnsureLoopPreHeaders.h in Headers */,
-                                522927D5235FD0B9005CB169 /* GCMemoryOperations.h in Headers */,
                                 5318045C22EAAC4B004A7342 /* B3ExtractValue.h in Headers */,
                                 0F6971EA1D92F42400BA02A5 /* B3FenceValue.h in Headers */,
@@ -9453 +9452 @@
                                 0F2B66AF17B6B54500A7AE3F /* GCIncomingRefCountedSetInlines.h in Headers */,
                                 2AABCDE718EF294200002096 /* GCLogging.h in Headers */,
+                                522927D5235FD0B9005CB169 /* GCMemoryOperations.h in Headers */,
                                 0F9715311EB28BEE00A1645D /* GCRequest.h in Headers */,
                                 A54E8EB018BFFBBB00556D28 /* GCSegmentedArray.h in Headers */,
@@ -9837 +9837 @@
                                 969A072A0ED1CE6900F1F681 /* Label.h in Headers */,
                                 960097A60EBABB58007A7297 /* LabelScope.h in Headers */,
-                                0F070A4B1D543A98006E7232 /* LargeAllocation.h in Headers */,
                                 DCF3D56A1CD29470003D5C65 /* LazyClassStructure.h in Headers */,
                                 DCF3D56B1CD29472003D5C65 /* LazyClassStructureInlines.h in Headers */,
@@ -9965 +9964 @@
                                 0FE834181A6EF97B00D04847 /* PolymorphicCallStubRoutine.h in Headers */,
                                 521131F71F82BF14007CCEEE /* PolyProtoAccessChain.h in Headers */,
+                                0F070A4B1D543A98006E7232 /* PreciseAllocation.h in Headers */,
                                 0F98206116BFE38300240D02 /* PreciseJumpTargets.h in Headers */,
                                 E3A421431D6F58930007C617 /* PreciseJumpTargetsInlines.h in Headers */,

trunk/Source/JavaScriptCore/Sources.txt

@@ -525 +525 @@
 heap/IsoSubspacePerVM.cpp
 heap/JITStubRoutineSet.cpp
-heap/LargeAllocation.cpp
+heap/PreciseAllocation.cpp
 heap/LocalAllocator.cpp
 heap/MachineStackMarker.cpp

trunk/Source/JavaScriptCore/heap/CellContainer.cpp

@@ -33 +33 @@
 bool CellContainer::isNewlyAllocated(HeapCell* cell) const
 {
-    if (isLargeAllocation())
-        return largeAllocation().isNewlyAllocated();
+    if (isPreciseAllocation())
+        return preciseAllocation().isNewlyAllocated();
     MarkedBlock& block = markedBlock();
     return !block.isNewlyAllocatedStale()

trunk/Source/JavaScriptCore/heap/CellContainer.h

@@ -32 +32 @@
 class Heap;
 class HeapCell;
-class LargeAllocation;
+class PreciseAllocation;
 class MarkedBlock;
 class WeakSet;
@@ -39 +39 @@
 typedef uint32_t HeapVersion;
 
-// This is how we abstract over either MarkedBlock& or LargeAllocation&. Put things in here as you
+// This is how we abstract over either MarkedBlock& or PreciseAllocation&. Put things in here as you
 // find need for them.
 
@@ -54 +54 @@
     }
     
-    CellContainer(LargeAllocation& largeAllocation)
-        : m_encodedPointer(bitwise_cast<uintptr_t>(&largeAllocation) | isLargeAllocationBit)
+    CellContainer(PreciseAllocation& preciseAllocation)
+        : m_encodedPointer(bitwise_cast<uintptr_t>(&preciseAllocation) | isPreciseAllocationBit)
     {
     }
@@ -64 +64 @@
     explicit operator bool() const { return !!m_encodedPointer; }
     
-    bool isMarkedBlock() const { return m_encodedPointer && !(m_encodedPointer & isLargeAllocationBit); }
-    bool isLargeAllocation() const { return m_encodedPointer & isLargeAllocationBit; }
+    bool isMarkedBlock() const { return m_encodedPointer && !(m_encodedPointer & isPreciseAllocationBit); }
+    bool isPreciseAllocation() const { return m_encodedPointer & isPreciseAllocationBit; }
     
     MarkedBlock& markedBlock() const
@@ -73 +73 @@
     }
     
-    LargeAllocation& largeAllocation() const
+    PreciseAllocation& preciseAllocation() const
     {
-        ASSERT(isLargeAllocation());
-        return *bitwise_cast<LargeAllocation*>(m_encodedPointer - isLargeAllocationBit);
+        ASSERT(isPreciseAllocation());
+        return *bitwise_cast<PreciseAllocation*>(m_encodedPointer - isPreciseAllocationBit);
     }
     
@@ -95 +95 @@
     
 private:
-    static constexpr uintptr_t isLargeAllocationBit = 1;
+    static constexpr uintptr_t isPreciseAllocationBit = 1;
     uintptr_t m_encodedPointer;
 };

trunk/Source/JavaScriptCore/heap/CellContainerInlines.h

@@ -28 +28 @@
 #include "CellContainer.h"
 #include "JSCast.h"
-#include "LargeAllocation.h"
 #include "MarkedBlock.h"
+#include "PreciseAllocation.h"
 #include "VM.h"
 
@@ -36 +36 @@
 inline VM& CellContainer::vm() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().vm();
+    if (isPreciseAllocation())
+        return preciseAllocation().vm();
     return markedBlock().vm();
 }
@@ -48 +48 @@
 inline bool CellContainer::isMarked(HeapCell* cell) const
 {
-    if (isLargeAllocation())
-        return largeAllocation().isMarked();
+    if (isPreciseAllocation())
+        return preciseAllocation().isMarked();
     return markedBlock().isMarked(cell);
 }
@@ -55 +55 @@
 inline bool CellContainer::isMarked(HeapVersion markingVersion, HeapCell* cell) const
 {
-    if (isLargeAllocation())
-        return largeAllocation().isMarked();
+    if (isPreciseAllocation())
+        return preciseAllocation().isMarked();
     return markedBlock().isMarked(markingVersion, cell);
 }
@@ -62 +62 @@
 inline void CellContainer::noteMarked()
 {
-    if (!isLargeAllocation())
+    if (!isPreciseAllocation())
         markedBlock().noteMarked();
 }
@@ -68 +68 @@
 inline void CellContainer::assertValidCell(VM& vm, HeapCell* cell) const
 {
-    if (isLargeAllocation())
-        largeAllocation().assertValidCell(vm, cell);
+    if (isPreciseAllocation())
+        preciseAllocation().assertValidCell(vm, cell);
     else
         markedBlock().assertValidCell(vm, cell);
@@ -76 +76 @@
 inline size_t CellContainer::cellSize() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().cellSize();
+    if (isPreciseAllocation())
+        return preciseAllocation().cellSize();
     return markedBlock().cellSize();
 }
@@ -83 +83 @@
 inline WeakSet& CellContainer::weakSet() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().weakSet();
+    if (isPreciseAllocation())
+        return preciseAllocation().weakSet();
     return markedBlock().weakSet();
 }
@@ -90 +90 @@
 inline void CellContainer::aboutToMark(HeapVersion markingVersion)
 {
-    if (!isLargeAllocation())
+    if (!isPreciseAllocation())
         markedBlock().aboutToMark(markingVersion);
 }
@@ -96 +96 @@
 inline bool CellContainer::areMarksStale() const
 {
-    if (isLargeAllocation())
+    if (isPreciseAllocation())
         return false;
     return markedBlock().areMarksStale();

trunk/Source/JavaScriptCore/heap/CompleteSubspace.cpp

@@ -130 +130 @@
         return allocator.allocate(deferralContext, AllocationFailureMode::ReturnNull);
     
-    if (size <= Options::largeAllocationCutoff()
+    if (size <= Options::preciseAllocationCutoff()
         && size <= MarkedSpace::largeCutoff) {
         dataLog("FATAL: attampting to allocate small object using large allocation.\n");
@@ -140 +140 @@
     
     size = WTF::roundUpToMultipleOf<MarkedSpace::sizeStep>(size);
-    LargeAllocation* allocation = LargeAllocation::tryCreate(vm.heap, size, this, m_space.m_largeAllocations.size());
+    PreciseAllocation* allocation = PreciseAllocation::tryCreate(vm.heap, size, this, m_space.m_preciseAllocations.size());
     if (!allocation)
         return nullptr;
     
-    m_space.m_largeAllocations.append(allocation);
-    if (auto* set = m_space.largeAllocationSet())
+    m_space.m_preciseAllocations.append(allocation);
+    if (auto* set = m_space.preciseAllocationSet())
         set->add(allocation->cell());
-    ASSERT(allocation->indexInSpace() == m_space.m_largeAllocations.size() - 1);
+    ASSERT(allocation->indexInSpace() == m_space.m_preciseAllocations.size() - 1);
     vm.heap.didAllocate(size);
     m_space.m_capacity += size;
     
-    m_largeAllocations.append(allocation);
+    m_preciseAllocations.append(allocation);
         
     return allocation->cell();
 }
 
-void* CompleteSubspace::reallocateLargeAllocationNonVirtual(VM& vm, HeapCell* oldCell, size_t size, GCDeferralContext* deferralContext, AllocationFailureMode failureMode)
+void* CompleteSubspace::reallocatePreciseAllocationNonVirtual(VM& vm, HeapCell* oldCell, size_t size, GCDeferralContext* deferralContext, AllocationFailureMode failureMode)
 {
     if (validateDFGDoesGC)
@@ -162 +162 @@
 
     // The following conditions are met in Butterfly for example.
-    ASSERT(oldCell->isLargeAllocation());
-
-    LargeAllocation* oldAllocation = &oldCell->largeAllocation();
+    ASSERT(oldCell->isPreciseAllocation());
+
+    PreciseAllocation* oldAllocation = &oldCell->preciseAllocation();
     ASSERT(oldAllocation->cellSize() <= size);
     ASSERT(oldAllocation->weakSet().isTriviallyDestructible());
@@ -173 +173 @@
     sanitizeStackForVM(vm);
 
-    if (size <= Options::largeAllocationCutoff()
+    if (size <= Options::preciseAllocationCutoff()
         && size <= MarkedSpace::largeCutoff) {
         dataLog("FATAL: attampting to allocate small object using large allocation.\n");
@@ -188 +188 @@
         oldAllocation->remove();
 
-    LargeAllocation* allocation = oldAllocation->tryReallocate(size, this);
+    PreciseAllocation* allocation = oldAllocation->tryReallocate(size, this);
     if (!allocation) {
         RELEASE_ASSERT(failureMode != AllocationFailureMode::Assert);
-        m_largeAllocations.append(oldAllocation);
+        m_preciseAllocations.append(oldAllocation);
         return nullptr;
     }
@@ -198 +198 @@
     // If reallocation changes the address, we should update HashSet.
     if (oldAllocation != allocation) {
-        if (auto* set = m_space.largeAllocationSet()) {
+        if (auto* set = m_space.preciseAllocationSet()) {
             set->remove(oldAllocation->cell());
             set->add(allocation->cell());
@@ -204 +204 @@
     }
 
-    m_space.m_largeAllocations[oldIndexInSpace] = allocation;
+    m_space.m_preciseAllocations[oldIndexInSpace] = allocation;
     vm.heap.didAllocate(difference);
     m_space.m_capacity += difference;
 
-    m_largeAllocations.append(allocation);
+    m_preciseAllocations.append(allocation);
 
     return allocation->cell();

trunk/Source/JavaScriptCore/heap/CompleteSubspace.h

@@ -45 +45 @@
     void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) override;
     void* allocateNonVirtual(VM&, size_t, GCDeferralContext*, AllocationFailureMode);
-    void* reallocateLargeAllocationNonVirtual(VM&, HeapCell*, size_t, GCDeferralContext*, AllocationFailureMode);
+    void* reallocatePreciseAllocationNonVirtual(VM&, HeapCell*, size_t, GCDeferralContext*, AllocationFailureMode);
     
     static ptrdiff_t offsetOfAllocatorForSizeStep() { return OBJECT_OFFSETOF(CompleteSubspace, m_allocatorForSizeStep); }

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -2154 +2154 @@
 void Heap::sweepInFinalize()
 {
-    m_objectSpace.sweepLargeAllocations();
+    m_objectSpace.sweepPreciseAllocations();
     vm().eagerlySweptDestructibleObjectSpace.sweep();
 }

trunk/Source/JavaScriptCore/heap/HeapCell.cpp

@@ -35 +35 @@
 bool HeapCell::isLive()
 {
-    if (isLargeAllocation())
-        return largeAllocation().isLive();
+    if (isPreciseAllocation())
+        return preciseAllocation().isLive();
     auto& markedBlockHandle = markedBlock().handle();
     if (markedBlockHandle.isFreeListed())

trunk/Source/JavaScriptCore/heap/HeapCell.h

@@ -32 +32 @@
 class CellContainer;
 class Heap;
-class LargeAllocation;
+class PreciseAllocation;
 class MarkedBlock;
 class Subspace;
@@ -62 +62 @@
     bool isLive();
 
-    bool isLargeAllocation() const;
+    bool isPreciseAllocation() const;
     CellContainer cellContainer() const;
     MarkedBlock& markedBlock() const;
-    LargeAllocation& largeAllocation() const;
+    PreciseAllocation& preciseAllocation() const;
 
     // If you want performance and you know that your cell is small, you can do this instead:
-    // ASSERT(!cell->isLargeAllocation());
+    // ASSERT(!cell->isPreciseAllocation());
     // cell->markedBlock().vm()
     // We currently only use this hack for callees to make CallFrame::vm() fast. It's not

trunk/Source/JavaScriptCore/heap/HeapCellInlines.h

@@ -28 +28 @@
 #include "CellContainer.h"
 #include "HeapCell.h"
-#include "LargeAllocation.h"
+#include "PreciseAllocation.h"
 #include "VM.h"
 
 namespace JSC {
 
-ALWAYS_INLINE bool HeapCell::isLargeAllocation() const
+ALWAYS_INLINE bool HeapCell::isPreciseAllocation() const
 {
-    return LargeAllocation::isLargeAllocation(const_cast<HeapCell*>(this));
+    return PreciseAllocation::isPreciseAllocation(const_cast<HeapCell*>(this));
 }
 
 ALWAYS_INLINE CellContainer HeapCell::cellContainer() const
 {
-    if (isLargeAllocation())
-        return largeAllocation();
+    if (isPreciseAllocation())
+        return preciseAllocation();
     return markedBlock();
 }
@@ -50 +50 @@
 }
 
-ALWAYS_INLINE LargeAllocation& HeapCell::largeAllocation() const
+ALWAYS_INLINE PreciseAllocation& HeapCell::preciseAllocation() const
 {
-    return *LargeAllocation::fromCell(const_cast<HeapCell*>(this));
+    return *PreciseAllocation::fromCell(const_cast<HeapCell*>(this));
 }
 
@@ -62 +62 @@
 ALWAYS_INLINE VM& HeapCell::vm() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().vm();
+    if (isPreciseAllocation())
+        return preciseAllocation().vm();
     return markedBlock().vm();
 }
@@ -69 +69 @@
 ALWAYS_INLINE size_t HeapCell::cellSize() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().cellSize();
+    if (isPreciseAllocation())
+        return preciseAllocation().cellSize();
     return markedBlock().cellSize();
 }
@@ -76 +76 @@
 ALWAYS_INLINE CellAttributes HeapCell::cellAttributes() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().attributes();
+    if (isPreciseAllocation())
+        return preciseAllocation().attributes();
     return markedBlock().attributes();
 }
@@ -93 +93 @@
 ALWAYS_INLINE Subspace* HeapCell::subspace() const
 {
-    if (isLargeAllocation())
-        return largeAllocation().subspace();
+    if (isPreciseAllocation())
+        return preciseAllocation().subspace();
     return markedBlock().subspace();
 }

trunk/Source/JavaScriptCore/heap/HeapInlines.h

@@ -71 +71 @@
 {
     HeapCell* cell = bitwise_cast<HeapCell*>(rawCell);
-    if (cell->isLargeAllocation())
-        return cell->largeAllocation().isMarked();
+    if (cell->isPreciseAllocation())
+        return cell->preciseAllocation().isMarked();
     MarkedBlock& block = cell->markedBlock();
     return block.isMarked(m_objectSpace.markingVersion(), cell);
@@ -80 +80 @@
 {
     HeapCell* cell = bitwise_cast<HeapCell*>(rawCell);
-    if (cell->isLargeAllocation())
-        return cell->largeAllocation().testAndSetMarked();
+    if (cell->isPreciseAllocation())
+        return cell->preciseAllocation().testAndSetMarked();
     MarkedBlock& block = cell->markedBlock();
     Dependency dependency = block.aboutToMark(markingVersion);

trunk/Source/JavaScriptCore/heap/HeapUtil.h

@@ -58 +58 @@
         
         // It could point to a large allocation.
-        if (heap.objectSpace().largeAllocationsForThisCollectionSize()) {
-            if (heap.objectSpace().largeAllocationsForThisCollectionBegin()[0]->aboveLowerBound(pointer)
-                && heap.objectSpace().largeAllocationsForThisCollectionEnd()[-1]->belowUpperBound(pointer)) {
-                LargeAllocation** result = approximateBinarySearch<LargeAllocation*>(
-                    heap.objectSpace().largeAllocationsForThisCollectionBegin(),
-                    heap.objectSpace().largeAllocationsForThisCollectionSize(),
-                    LargeAllocation::fromCell(pointer),
-                    [] (LargeAllocation** ptr) -> LargeAllocation* { return *ptr; });
+        if (heap.objectSpace().preciseAllocationsForThisCollectionSize()) {
+            if (heap.objectSpace().preciseAllocationsForThisCollectionBegin()[0]->aboveLowerBound(pointer)
+                && heap.objectSpace().preciseAllocationsForThisCollectionEnd()[-1]->belowUpperBound(pointer)) {
+                PreciseAllocation** result = approximateBinarySearch<PreciseAllocation*>(
+                    heap.objectSpace().preciseAllocationsForThisCollectionBegin(),
+                    heap.objectSpace().preciseAllocationsForThisCollectionSize(),
+                    PreciseAllocation::fromCell(pointer),
+                    [] (PreciseAllocation** ptr) -> PreciseAllocation* { return *ptr; });
                 if (result) {
-                    auto attemptLarge = [&] (LargeAllocation* allocation) {
+                    auto attemptLarge = [&] (PreciseAllocation* allocation) {
                         if (allocation->contains(pointer))
                             func(allocation->cell(), allocation->attributes().cellKind);
                     };
                     
-                    if (result > heap.objectSpace().largeAllocationsForThisCollectionBegin())
+                    if (result > heap.objectSpace().preciseAllocationsForThisCollectionBegin())
                         attemptLarge(result[-1]);
                     attemptLarge(result[0]);
-                    if (result + 1 < heap.objectSpace().largeAllocationsForThisCollectionEnd())
+                    if (result + 1 < heap.objectSpace().preciseAllocationsForThisCollectionEnd())
                         attemptLarge(result[1]);
                 }
@@ -132 +132 @@
     {
         // It could point to a large allocation.
-        if (pointer->isLargeAllocation()) {
-            auto* set = heap.objectSpace().largeAllocationSet();
+        if (pointer->isPreciseAllocation()) {
+            auto* set = heap.objectSpace().preciseAllocationSet();
             ASSERT(set);
             if (set->isEmpty())
@@ -167 +167 @@
         Heap& heap, TinyBloomFilter filter, JSValue value)
     {
-        ASSERT(heap.objectSpace().largeAllocationSet());
+        ASSERT(heap.objectSpace().preciseAllocationSet());
         if (!value.isCell())
             return false;

trunk/Source/JavaScriptCore/heap/IsoAlignedMemoryAllocator.cpp

@@ -102 +102 @@
 void* IsoAlignedMemoryAllocator::tryReallocateMemory(void*, size_t)
 {
-    // In IsoSubspace-managed LargeAllocation, we must not perform realloc.
+    // In IsoSubspace-managed PreciseAllocation, we must not perform realloc.
     RELEASE_ASSERT_NOT_REACHED();
 }

trunk/Source/JavaScriptCore/heap/IsoCellSetInlines.h

@@ -34 +34 @@
 inline bool IsoCellSet::add(HeapCell* cell)
 {
-    if (cell->isLargeAllocation())
-        return !m_lowerTierBits.concurrentTestAndSet(cell->largeAllocation().lowerTierIndex());
+    if (cell->isPreciseAllocation())
+        return !m_lowerTierBits.concurrentTestAndSet(cell->preciseAllocation().lowerTierIndex());
     AtomIndices atomIndices(cell);
     auto& bitsPtrRef = m_bits[atomIndices.blockIndex];
@@ -46 +46 @@
 inline bool IsoCellSet::remove(HeapCell* cell)
 {
-    if (cell->isLargeAllocation())
-        return !m_lowerTierBits.concurrentTestAndClear(cell->largeAllocation().lowerTierIndex());
+    if (cell->isPreciseAllocation())
+        return !m_lowerTierBits.concurrentTestAndClear(cell->preciseAllocation().lowerTierIndex());
     AtomIndices atomIndices(cell);
     auto& bitsPtrRef = m_bits[atomIndices.blockIndex];
@@ -58 +58 @@
 inline bool IsoCellSet::contains(HeapCell* cell) const
 {
-    if (cell->isLargeAllocation())
-        return !m_lowerTierBits.get(cell->largeAllocation().lowerTierIndex());
+    if (cell->isPreciseAllocation())
+        return !m_lowerTierBits.get(cell->preciseAllocation().lowerTierIndex());
     AtomIndices atomIndices(cell);
     auto* bits = m_bits[atomIndices.blockIndex].get();
@@ -85 +85 @@
 
     CellAttributes attributes = m_subspace.attributes();
-    m_subspace.forEachLargeAllocation(
-        [&] (LargeAllocation* allocation) {
+    m_subspace.forEachPreciseAllocation(
+        [&] (PreciseAllocation* allocation) {
             if (m_lowerTierBits.get(allocation->lowerTierIndex()) && allocation->isMarked())
                 func(allocation->cell(), attributes.cellKind);
@@ -119 +119 @@
             {
                 auto locker = holdLock(m_lock);
-                if (!m_needToVisitLargeAllocations)
+                if (!m_needToVisitPreciseAllocations)
                     return;
-                m_needToVisitLargeAllocations = false;
+                m_needToVisitPreciseAllocations = false;
             }
 
             CellAttributes attributes = m_set.m_subspace.attributes();
-            m_set.m_subspace.forEachLargeAllocation(
-                [&] (LargeAllocation* allocation) {
+            m_set.m_subspace.forEachPreciseAllocation(
+                [&] (PreciseAllocation* allocation) {
                     if (m_set.m_lowerTierBits.get(allocation->lowerTierIndex()) && allocation->isMarked())
                         m_func(visitor, allocation->cell(), attributes.cellKind);
@@ -137 +137 @@
         Func m_func;
         Lock m_lock;
-        bool m_needToVisitLargeAllocations { true };
+        bool m_needToVisitPreciseAllocations { true };
     };
     
@@ -161 +161 @@
 
     CellAttributes attributes = m_subspace.attributes();
-    m_subspace.forEachLargeAllocation(
-        [&] (LargeAllocation* allocation) {
+    m_subspace.forEachPreciseAllocation(
+        [&] (PreciseAllocation* allocation) {
             if (m_lowerTierBits.get(allocation->lowerTierIndex()) && allocation->isLive())
                 func(allocation->cell(), attributes.cellKind);

trunk/Source/JavaScriptCore/heap/IsoSubspace.cpp

@@ -93 +93 @@
 void* IsoSubspace::tryAllocateFromLowerTier()
 {
-    auto revive = [&] (LargeAllocation* allocation) {
-        allocation->setIndexInSpace(m_space.m_largeAllocations.size());
+    auto revive = [&] (PreciseAllocation* allocation) {
+        allocation->setIndexInSpace(m_space.m_preciseAllocations.size());
         allocation->m_hasValidCell = true;
-        m_space.m_largeAllocations.append(allocation);
-        if (auto* set = m_space.largeAllocationSet())
+        m_space.m_preciseAllocations.append(allocation);
+        if (auto* set = m_space.preciseAllocationSet())
             set->add(allocation->cell());
-        ASSERT(allocation->indexInSpace() == m_space.m_largeAllocations.size() - 1);
-        m_largeAllocations.append(allocation);
+        ASSERT(allocation->indexInSpace() == m_space.m_preciseAllocations.size() - 1);
+        m_preciseAllocations.append(allocation);
         return allocation->cell();
     };
 
     if (!m_lowerTierFreeList.isEmpty()) {
-        LargeAllocation* allocation = m_lowerTierFreeList.begin();
+        PreciseAllocation* allocation = m_lowerTierFreeList.begin();
         allocation->remove();
         return revive(allocation);
@@ -111 +111 @@
     if (m_lowerTierCellCount != MarkedBlock::numberOfLowerTierCells) {
         size_t size = WTF::roundUpToMultipleOf<MarkedSpace::sizeStep>(m_size);
-        LargeAllocation* allocation = LargeAllocation::createForLowerTier(*m_space.heap(), size, this, m_lowerTierCellCount++);
+        PreciseAllocation* allocation = PreciseAllocation::createForLowerTier(*m_space.heap(), size, this, m_lowerTierCellCount++);
         return revive(allocation);
     }
@@ -117 +117 @@
 }
 
-void IsoSubspace::sweepLowerTierCell(LargeAllocation* largeAllocation)
+void IsoSubspace::sweepLowerTierCell(PreciseAllocation* preciseAllocation)
 {
-    unsigned lowerTierIndex = largeAllocation->lowerTierIndex();
-    largeAllocation = largeAllocation->reuseForLowerTier();
-    m_lowerTierFreeList.append(largeAllocation);
+    unsigned lowerTierIndex = preciseAllocation->lowerTierIndex();
+    preciseAllocation = preciseAllocation->reuseForLowerTier();
+    m_lowerTierFreeList.append(preciseAllocation);
     m_cellSets.forEach(
         [&] (IsoCellSet* set) {
@@ -130 +130 @@
 void IsoSubspace::destroyLowerTierFreeList()
 {
-    m_lowerTierFreeList.forEach([&](LargeAllocation* allocation) {
+    m_lowerTierFreeList.forEach([&](PreciseAllocation* allocation) {
         allocation->destroy();
     });

trunk/Source/JavaScriptCore/heap/IsoSubspace.h

@@ -49 +49 @@
     void* allocateNonVirtual(VM&, size_t, GCDeferralContext*, AllocationFailureMode);
 
-    void sweepLowerTierCell(LargeAllocation*);
+    void sweepLowerTierCell(PreciseAllocation*);
 
     void* tryAllocateFromLowerTier();
@@ -65 +65 @@
     LocalAllocator m_localAllocator;
     std::unique_ptr<IsoAlignedMemoryAllocator> m_isoAlignedMemoryAllocator;
-    SentinelLinkedList<LargeAllocation, PackedRawSentinelNode<LargeAllocation>> m_lowerTierFreeList;
+    SentinelLinkedList<PreciseAllocation, PackedRawSentinelNode<PreciseAllocation>> m_lowerTierFreeList;
     SentinelLinkedList<IsoCellSet, PackedRawSentinelNode<IsoCellSet>> m_cellSets;
     uint8_t m_lowerTierCellCount { 0 };

trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp

@@ -131 +131 @@
                 // This is usually how we get out of the loop.
                 if (betterSizeClass > MarkedSpace::largeCutoff
-                    || betterSizeClass > Options::largeAllocationCutoff())
+                    || betterSizeClass > Options::preciseAllocationCutoff())
                     break;
                 
@@ -212 +212 @@
             freeBlock(block);
         });
-    for (LargeAllocation* allocation : m_largeAllocations)
+    for (PreciseAllocation* allocation : m_preciseAllocations)
         allocation->destroy();
     forEachSubspace([&](Subspace& subspace) {
@@ -228 +228 @@
             return IterationStatus::Continue;
         });
-    for (LargeAllocation* allocation : m_largeAllocations)
+    for (PreciseAllocation* allocation : m_preciseAllocations)
         allocation->lastChanceToFinalize();
     // We do not call lastChanceToFinalize for lower-tier swept cells since we need nothing to do.
@@ -243 +243 @@
 }
 
-void MarkedSpace::sweepLargeAllocations()
-{
-    RELEASE_ASSERT(m_largeAllocationsNurseryOffset == m_largeAllocations.size());
-    unsigned srcIndex = m_largeAllocationsNurseryOffsetForSweep;
+void MarkedSpace::sweepPreciseAllocations()
+{
+    RELEASE_ASSERT(m_preciseAllocationsNurseryOffset == m_preciseAllocations.size());
+    unsigned srcIndex = m_preciseAllocationsNurseryOffsetForSweep;
     unsigned dstIndex = srcIndex;
-    while (srcIndex < m_largeAllocations.size()) {
-        LargeAllocation* allocation = m_largeAllocations[srcIndex++];
+    while (srcIndex < m_preciseAllocations.size()) {
+        PreciseAllocation* allocation = m_preciseAllocations[srcIndex++];
         allocation->sweep();
         if (allocation->isEmpty()) {
-            if (auto* set = largeAllocationSet())
+            if (auto* set = preciseAllocationSet())
                 set->remove(allocation->cell());
             if (allocation->isLowerTier())
@@ -263 +263 @@
         }
         allocation->setIndexInSpace(dstIndex);
-        m_largeAllocations[dstIndex++] = allocation;
-    }
-    m_largeAllocations.shrink(dstIndex);
-    m_largeAllocationsNurseryOffset = m_largeAllocations.size();
+        m_preciseAllocations[dstIndex++] = allocation;
+    }
+    m_preciseAllocations.shrink(dstIndex);
+    m_preciseAllocationsNurseryOffset = m_preciseAllocations.size();
 }
 
@@ -278 +278 @@
     
     if (m_heap->collectionScope() == CollectionScope::Eden)
-        m_largeAllocationsNurseryOffsetForSweep = m_largeAllocationsNurseryOffset;
+        m_preciseAllocationsNurseryOffsetForSweep = m_preciseAllocationsNurseryOffset;
     else
-        m_largeAllocationsNurseryOffsetForSweep = 0;
-    m_largeAllocationsNurseryOffset = m_largeAllocations.size();
-}
-
-void MarkedSpace::enableLargeAllocationTracking()
-{
-    m_largeAllocationSet = makeUnique<HashSet<HeapCell*>>();
-    for (auto* allocation : m_largeAllocations)
-        m_largeAllocationSet->add(allocation->cell());
+        m_preciseAllocationsNurseryOffsetForSweep = 0;
+    m_preciseAllocationsNurseryOffset = m_preciseAllocations.size();
+}
+
+void MarkedSpace::enablePreciseAllocationTracking()
+{
+    m_preciseAllocationSet = makeUnique<HashSet<HeapCell*>>();
+    for (auto* allocation : m_preciseAllocations)
+        m_preciseAllocationSet->add(allocation->cell());
 }
 
@@ -337 +337 @@
 void MarkedSpace::prepareForConservativeScan()
 {
-    m_largeAllocationsForThisCollectionBegin = m_largeAllocations.begin() + m_largeAllocationsOffsetForThisCollection;
-    m_largeAllocationsForThisCollectionSize = m_largeAllocations.size() - m_largeAllocationsOffsetForThisCollection;
-    m_largeAllocationsForThisCollectionEnd = m_largeAllocations.end();
-    RELEASE_ASSERT(m_largeAllocationsForThisCollectionEnd == m_largeAllocationsForThisCollectionBegin + m_largeAllocationsForThisCollectionSize);
+    m_preciseAllocationsForThisCollectionBegin = m_preciseAllocations.begin() + m_preciseAllocationsOffsetForThisCollection;
+    m_preciseAllocationsForThisCollectionSize = m_preciseAllocations.size() - m_preciseAllocationsOffsetForThisCollection;
+    m_preciseAllocationsForThisCollectionEnd = m_preciseAllocations.end();
+    RELEASE_ASSERT(m_preciseAllocationsForThisCollectionEnd == m_preciseAllocationsForThisCollectionBegin + m_preciseAllocationsForThisCollectionSize);
     
     std::sort(
-        m_largeAllocationsForThisCollectionBegin, m_largeAllocationsForThisCollectionEnd,
-        [&] (LargeAllocation* a, LargeAllocation* b) {
+        m_preciseAllocationsForThisCollectionBegin, m_preciseAllocationsForThisCollectionEnd,
+        [&] (PreciseAllocation* a, PreciseAllocation* b) {
             return a < b;
         });
-    unsigned index = m_largeAllocationsOffsetForThisCollection;
-    for (auto* start = m_largeAllocationsForThisCollectionBegin; start != m_largeAllocationsForThisCollectionEnd; ++start, ++index) {
+    unsigned index = m_preciseAllocationsOffsetForThisCollection;
+    for (auto* start = m_preciseAllocationsForThisCollectionBegin; start != m_preciseAllocationsForThisCollectionEnd; ++start, ++index) {
         (*start)->setIndexInSpace(index);
-        ASSERT(m_largeAllocations[index] == *start);
-        ASSERT(m_largeAllocations[index]->indexInSpace() == index);
+        ASSERT(m_preciseAllocations[index] == *start);
+        ASSERT(m_preciseAllocations[index]->indexInSpace() == index);
     }
 }
@@ -358 +358 @@
 {
     if (m_heap->collectionScope() == CollectionScope::Eden)
-        m_largeAllocationsOffsetForThisCollection = m_largeAllocationsNurseryOffset;
+        m_preciseAllocationsOffsetForThisCollection = m_preciseAllocationsNurseryOffset;
     else
-        m_largeAllocationsOffsetForThisCollection = 0;
+        m_preciseAllocationsOffsetForThisCollection = 0;
 }
 
@@ -370 +370 @@
             return IterationStatus::Continue;
         });
-    // Nothing to do for LargeAllocations.
+    // Nothing to do for PreciseAllocations.
 }
 
@@ -384 +384 @@
             return IterationStatus::Continue;
         });
-    // FIXME: Consider taking LargeAllocations into account here.
+    // FIXME: Consider taking PreciseAllocations into account here.
     return result;
 }
@@ -433 +433 @@
         m_markingVersion = nextVersion(m_markingVersion);
         
-        for (LargeAllocation* allocation : m_largeAllocations)
+        for (PreciseAllocation* allocation : m_preciseAllocations)
             allocation->flip();
     }
@@ -460 +460 @@
     m_newlyAllocatedVersion = nextVersion(m_newlyAllocatedVersion);
     
-    for (unsigned i = m_largeAllocationsOffsetForThisCollection; i < m_largeAllocations.size(); ++i)
-        m_largeAllocations[i]->clearNewlyAllocated();
+    for (unsigned i = m_preciseAllocationsOffsetForThisCollection; i < m_preciseAllocations.size(); ++i)
+        m_preciseAllocations[i]->clearNewlyAllocated();
 
     if (!ASSERT_DISABLED) {
-        for (LargeAllocation* allocation : m_largeAllocations)
+        for (PreciseAllocation* allocation : m_preciseAllocations)
             ASSERT_UNUSED(allocation, !allocation->isNewlyAllocated());
     }
@@ -498 +498 @@
             result += block->markCount();
         });
-    for (LargeAllocation* allocation : m_largeAllocations) {
+    for (PreciseAllocation* allocation : m_preciseAllocations) {
         if (allocation->isMarked())
             result++;
@@ -512 +512 @@
             result += block->markCount() * block->cellSize();
         });
-    for (LargeAllocation* allocation : m_largeAllocations) {
+    for (PreciseAllocation* allocation : m_preciseAllocations) {
         if (allocation->isMarked())
             result += allocation->cellSize();

trunk/Source/JavaScriptCore/heap/MarkedSpace.h

@@ -24 +24 @@
 #include "BlockDirectory.h"
 #include "IterationStatus.h"
-#include "LargeAllocation.h"
 #include "MarkedBlock.h"
 #include "MarkedBlockSet.h"
+#include "PreciseAllocation.h"
 #include <array>
 #include <wtf/Bag.h>
@@ -142 +142 @@
     void clearNewlyAllocated();
     void sweep();
-    void sweepLargeAllocations();
+    void sweepPreciseAllocations();
     void assertNoUnswept();
     size_t objectCount();
@@ -153 +153 @@
     HeapVersion newlyAllocatedVersion() const { return m_newlyAllocatedVersion; }
 
-    const Vector<LargeAllocation*>& largeAllocations() const { return m_largeAllocations; }
-    unsigned largeAllocationsNurseryOffset() const { return m_largeAllocationsNurseryOffset; }
-    unsigned largeAllocationsOffsetForThisCollection() const { return m_largeAllocationsOffsetForThisCollection; }
-    HashSet<HeapCell*>* largeAllocationSet() const { return m_largeAllocationSet.get(); }
-
-    void enableLargeAllocationTracking();
+    const Vector<PreciseAllocation*>& preciseAllocations() const { return m_preciseAllocations; }
+    unsigned preciseAllocationsNurseryOffset() const { return m_preciseAllocationsNurseryOffset; }
+    unsigned preciseAllocationsOffsetForThisCollection() const { return m_preciseAllocationsOffsetForThisCollection; }
+    HashSet<HeapCell*>* preciseAllocationSet() const { return m_preciseAllocationSet.get(); }
+
+    void enablePreciseAllocationTracking();
     
     // These are cached pointers and offsets for quickly searching the large allocations that are
     // relevant to this collection.
-    LargeAllocation** largeAllocationsForThisCollectionBegin() const { return m_largeAllocationsForThisCollectionBegin; }
-    LargeAllocation** largeAllocationsForThisCollectionEnd() const { return m_largeAllocationsForThisCollectionEnd; }
-    unsigned largeAllocationsForThisCollectionSize() const { return m_largeAllocationsForThisCollectionSize; }
+    PreciseAllocation** preciseAllocationsForThisCollectionBegin() const { return m_preciseAllocationsForThisCollectionBegin; }
+    PreciseAllocation** preciseAllocationsForThisCollectionEnd() const { return m_preciseAllocationsForThisCollectionEnd; }
+    unsigned preciseAllocationsForThisCollectionSize() const { return m_preciseAllocationsForThisCollectionSize; }
     
     BlockDirectory* firstDirectory() const { return m_directories.first(); }
@@ -205 +205 @@
     Vector<Subspace*> m_subspaces;
 
-    std::unique_ptr<HashSet<HeapCell*>> m_largeAllocationSet;
-    Vector<LargeAllocation*> m_largeAllocations;
-    unsigned m_largeAllocationsNurseryOffset { 0 };
-    unsigned m_largeAllocationsOffsetForThisCollection { 0 };
-    unsigned m_largeAllocationsNurseryOffsetForSweep { 0 };
-    unsigned m_largeAllocationsForThisCollectionSize { 0 };
-    LargeAllocation** m_largeAllocationsForThisCollectionBegin { nullptr };
-    LargeAllocation** m_largeAllocationsForThisCollectionEnd { nullptr };
+    std::unique_ptr<HashSet<HeapCell*>> m_preciseAllocationSet;
+    Vector<PreciseAllocation*> m_preciseAllocations;
+    unsigned m_preciseAllocationsNurseryOffset { 0 };
+    unsigned m_preciseAllocationsOffsetForThisCollection { 0 };
+    unsigned m_preciseAllocationsNurseryOffsetForSweep { 0 };
+    unsigned m_preciseAllocationsForThisCollectionSize { 0 };
+    PreciseAllocation** m_preciseAllocationsForThisCollectionBegin { nullptr };
+    PreciseAllocation** m_preciseAllocationsForThisCollectionEnd { nullptr };
 
     Heap* m_heap;

trunk/Source/JavaScriptCore/heap/MarkedSpaceInlines.h

@@ -48 +48 @@
             return;
     }
-    for (LargeAllocation* allocation : m_largeAllocations) {
+    for (PreciseAllocation* allocation : m_preciseAllocations) {
         if (allocation->isLive()) {
             if (functor(allocation->cell(), allocation->attributes().cellKind) == IterationStatus::Done)
@@ -64 +64 @@
             return;
     }
-    for (LargeAllocation* allocation : m_largeAllocations) {
+    for (PreciseAllocation* allocation : m_preciseAllocations) {
         if (!allocation->isLive()) {
             if (functor(allocation->cell(), allocation->attributes().cellKind) == IterationStatus::Done)

trunk/Source/JavaScriptCore/heap/PreciseAllocation.cpp

@@ -25 +25 @@
 
 #include "config.h"
-#include "LargeAllocation.h"
+#include "PreciseAllocation.h"
 
 #include "AlignedMemoryAllocator.h"
@@ -35 +35 @@
 namespace JSC {
 
-static inline bool isAlignedForLargeAllocation(void* memory)
+static inline bool isAlignedForPreciseAllocation(void* memory)
 {
     uintptr_t allocatedPointer = bitwise_cast<uintptr_t>(memory);
-    return !(allocatedPointer & (LargeAllocation::alignment - 1));
-}
-
-LargeAllocation* LargeAllocation::tryCreate(Heap& heap, size_t size, Subspace* subspace, unsigned indexInSpace)
+    return !(allocatedPointer & (PreciseAllocation::alignment - 1));
+}
+
+PreciseAllocation* PreciseAllocation::tryCreate(Heap& heap, size_t size, Subspace* subspace, unsigned indexInSpace)
 {
     if (validateDFGDoesGC)
@@ -55 +55 @@
 
     bool adjustedAlignment = false;
-    if (!isAlignedForLargeAllocation(space)) {
+    if (!isAlignedForPreciseAllocation(space)) {
         space = bitwise_cast<void*>(bitwise_cast<uintptr_t>(space) + halfAlignment);
         adjustedAlignment = true;
-        ASSERT(isAlignedForLargeAllocation(space));
+        ASSERT(isAlignedForPreciseAllocation(space));
     }
     
     if (scribbleFreeCells())
         scribble(space, size);
-    return new (NotNull, space) LargeAllocation(heap, size, subspace, indexInSpace, adjustedAlignment);
-}
-
-LargeAllocation* LargeAllocation::tryReallocate(size_t size, Subspace* subspace)
+    return new (NotNull, space) PreciseAllocation(heap, size, subspace, indexInSpace, adjustedAlignment);
+}
+
+PreciseAllocation* PreciseAllocation::tryReallocate(size_t size, Subspace* subspace)
 {
     ASSERT(!isLowerTier());
@@ -82 +82 @@
         return nullptr;
 
-    LargeAllocation* newAllocation = bitwise_cast<LargeAllocation*>(newBasePointer);
+    PreciseAllocation* newAllocation = bitwise_cast<PreciseAllocation*>(newBasePointer);
     bool newAdjustedAlignment = false;
-    if (!isAlignedForLargeAllocation(newBasePointer)) {
+    if (!isAlignedForPreciseAllocation(newBasePointer)) {
         newAdjustedAlignment = true;
-        newAllocation = bitwise_cast<LargeAllocation*>(bitwise_cast<uintptr_t>(newBasePointer) + halfAlignment);
-        ASSERT(isAlignedForLargeAllocation(static_cast<void*>(newAllocation)));
+        newAllocation = bitwise_cast<PreciseAllocation*>(bitwise_cast<uintptr_t>(newBasePointer) + halfAlignment);
+        ASSERT(isAlignedForPreciseAllocation(static_cast<void*>(newAllocation)));
     }
 
@@ -103 +103 @@
             // Now   [   ][  content  ]
             // New   [  content  ]...
-            memmove(newBasePointer, bitwise_cast<char*>(newBasePointer) + halfAlignment, oldCellSize + LargeAllocation::headerSize());
+            memmove(newBasePointer, bitwise_cast<char*>(newBasePointer) + halfAlignment, oldCellSize + PreciseAllocation::headerSize());
         } else {
             ASSERT(newAdjustedAlignment);
@@ -111 +111 @@
             // Now   [  content  ][   ]
             // New   [ 8 ][  content  ]
-            memmove(bitwise_cast<char*>(newBasePointer) + halfAlignment, newBasePointer, oldCellSize + LargeAllocation::headerSize());
+            memmove(bitwise_cast<char*>(newBasePointer) + halfAlignment, newBasePointer, oldCellSize + PreciseAllocation::headerSize());
         }
     }
@@ -121 +121 @@
 
 
-LargeAllocation* LargeAllocation::createForLowerTier(Heap& heap, size_t size, Subspace* subspace, uint8_t lowerTierIndex)
+PreciseAllocation* PreciseAllocation::createForLowerTier(Heap& heap, size_t size, Subspace* subspace, uint8_t lowerTierIndex)
 {
     if (validateDFGDoesGC)
@@ -133 +133 @@
 
     bool adjustedAlignment = false;
-    if (!isAlignedForLargeAllocation(space)) {
+    if (!isAlignedForPreciseAllocation(space)) {
         space = bitwise_cast<void*>(bitwise_cast<uintptr_t>(space) + halfAlignment);
         adjustedAlignment = true;
-        ASSERT(isAlignedForLargeAllocation(space));
+        ASSERT(isAlignedForPreciseAllocation(space));
     }
 
     if (scribbleFreeCells())
         scribble(space, size);
-    LargeAllocation* largeAllocation = new (NotNull, space) LargeAllocation(heap, size, subspace, 0, adjustedAlignment);
-    largeAllocation->m_lowerTierIndex = lowerTierIndex;
-    return largeAllocation;
-}
-
-LargeAllocation* LargeAllocation::reuseForLowerTier()
+    PreciseAllocation* preciseAllocation = new (NotNull, space) PreciseAllocation(heap, size, subspace, 0, adjustedAlignment);
+    preciseAllocation->m_lowerTierIndex = lowerTierIndex;
+    return preciseAllocation;
+}
+
+PreciseAllocation* PreciseAllocation::reuseForLowerTier()
 {
     Heap& heap = *this->heap();
@@ -155 +155 @@
 
     void* space = this->basePointer();
-    this->~LargeAllocation();
-
-    LargeAllocation* largeAllocation = new (NotNull, space) LargeAllocation(heap, size, subspace, 0, adjustedAlignment);
-    largeAllocation->m_lowerTierIndex = lowerTierIndex;
-    largeAllocation->m_hasValidCell = false;
-    return largeAllocation;
-}
-
-LargeAllocation::LargeAllocation(Heap& heap, size_t size, Subspace* subspace, unsigned indexInSpace, bool adjustedAlignment)
+    this->~PreciseAllocation();
+
+    PreciseAllocation* preciseAllocation = new (NotNull, space) PreciseAllocation(heap, size, subspace, 0, adjustedAlignment);
+    preciseAllocation->m_lowerTierIndex = lowerTierIndex;
+    preciseAllocation->m_hasValidCell = false;
+    return preciseAllocation;
+}
+
+PreciseAllocation::PreciseAllocation(Heap& heap, size_t size, Subspace* subspace, unsigned indexInSpace, bool adjustedAlignment)
     : m_indexInSpace(indexInSpace)
     , m_cellSize(size)
@@ -176 +176 @@
 }
 
-LargeAllocation::~LargeAllocation()
+PreciseAllocation::~PreciseAllocation()
 {
     if (isOnList())
@@ -182 +182 @@
 }
 
-void LargeAllocation::lastChanceToFinalize()
+void PreciseAllocation::lastChanceToFinalize()
 {
     m_weakSet.lastChanceToFinalize();
@@ -190 +190 @@
 }
 
-void LargeAllocation::shrink()
+void PreciseAllocation::shrink()
 {
     m_weakSet.shrink();
 }
 
-void LargeAllocation::visitWeakSet(SlotVisitor& visitor)
+void PreciseAllocation::visitWeakSet(SlotVisitor& visitor)
 {
     m_weakSet.visit(visitor);
 }
 
-void LargeAllocation::reapWeakSet()
+void PreciseAllocation::reapWeakSet()
 {
     return m_weakSet.reap();
 }
 
-void LargeAllocation::flip()
+void PreciseAllocation::flip()
 {
     ASSERT(heap()->collectionScope() == CollectionScope::Full);
@@ -211 +211 @@
 }
 
-bool LargeAllocation::isEmpty()
+bool PreciseAllocation::isEmpty()
 {
     return !isMarked() && m_weakSet.isEmpty() && !isNewlyAllocated();
 }
 
-void LargeAllocation::sweep()
+void PreciseAllocation::sweep()
 {
     m_weakSet.sweep();
@@ -227 +227 @@
 }
 
-void LargeAllocation::destroy()
+void PreciseAllocation::destroy()
 {
     AlignedMemoryAllocator* allocator = m_subspace->alignedMemoryAllocator();
     void* basePointer = this->basePointer();
-    this->~LargeAllocation();
+    this->~PreciseAllocation();
     allocator->freeMemory(basePointer);
 }
 
-void LargeAllocation::dump(PrintStream& out) const
+void PreciseAllocation::dump(PrintStream& out) const
 {
     out.print(RawPointer(this), ":(cell at ", RawPointer(cell()), " with size ", m_cellSize, " and attributes ", m_attributes, ")");
@@ -241 +241 @@
 
 #if !ASSERT_DISABLED
-void LargeAllocation::assertValidCell(VM& vm, HeapCell* cell) const
+void PreciseAllocation::assertValidCell(VM& vm, HeapCell* cell) const
 {
     ASSERT(&vm == &this->vm());

trunk/Source/JavaScriptCore/heap/PreciseAllocation.h

@@ -35 +35 @@
 
 // WebKit has a good malloc that already knows what to do for large allocations. The GC shouldn't
-// have to think about such things. That's where LargeAllocation comes in. We will allocate large
-// objects directly using malloc, and put the LargeAllocation header just before them. We can detect
-// when a HeapCell* is a LargeAllocation because it will have the MarkedBlock::atomSize / 2 bit set.
+// have to think about such things. That's where PreciseAllocation comes in. We will allocate large
+// objects directly using malloc, and put the PreciseAllocation header just before them. We can detect
+// when a HeapCell* is a PreciseAllocation because it will have the MarkedBlock::atomSize / 2 bit set.
 
-class LargeAllocation : public PackedRawSentinelNode<LargeAllocation> {
+class PreciseAllocation : public PackedRawSentinelNode<PreciseAllocation> {
 public:
     friend class LLIntOffsetsExtractor;
     friend class IsoSubspace;
 
-    static LargeAllocation* tryCreate(Heap&, size_t, Subspace*, unsigned indexInSpace);
+    static PreciseAllocation* tryCreate(Heap&, size_t, Subspace*, unsigned indexInSpace);
 
-    static LargeAllocation* createForLowerTier(Heap&, size_t, Subspace*, uint8_t lowerTierIndex);
-    LargeAllocation* reuseForLowerTier();
+    static PreciseAllocation* createForLowerTier(Heap&, size_t, Subspace*, uint8_t lowerTierIndex);
+    PreciseAllocation* reuseForLowerTier();
 
-    LargeAllocation* tryReallocate(size_t, Subspace*);
+    PreciseAllocation* tryReallocate(size_t, Subspace*);
     
-    ~LargeAllocation();
+    ~PreciseAllocation();
     
-    static LargeAllocation* fromCell(const void* cell)
+    static PreciseAllocation* fromCell(const void* cell)
     {
-        return bitwise_cast<LargeAllocation*>(bitwise_cast<char*>(cell) - headerSize());
+        return bitwise_cast<PreciseAllocation*>(bitwise_cast<char*>(cell) - headerSize());
     }
     
@@ -63 +63 @@
     }
     
-    static bool isLargeAllocation(HeapCell* cell)
+    static bool isPreciseAllocation(HeapCell* cell)
     {
         return bitwise_cast<uintptr_t>(cell) & halfAlignment;
@@ -159 +159 @@
     static constexpr unsigned alignment = MarkedBlock::atomSize;
     static constexpr unsigned halfAlignment = alignment / 2;
-    static constexpr unsigned headerSize() { return ((sizeof(LargeAllocation) + halfAlignment - 1) & ~(halfAlignment - 1)) | halfAlignment; }
+    static constexpr unsigned headerSize() { return ((sizeof(PreciseAllocation) + halfAlignment - 1) & ~(halfAlignment - 1)) | halfAlignment; }
 
 private:
-    LargeAllocation(Heap&, size_t, Subspace*, unsigned indexInSpace, bool adjustedAlignment);
+    PreciseAllocation(Heap&, size_t, Subspace*, unsigned indexInSpace, bool adjustedAlignment);
     
     void* basePointer() const;
@@ -178 +178 @@
 };
 
-inline void* LargeAllocation::basePointer() const
+inline void* PreciseAllocation::basePointer() const
 {
     if (m_adjustedAlignment)

trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp

@@ -258 +258 @@
 #endif
     
-    if (cell->isLargeAllocation())
-        setMarkedAndAppendToMarkStack(cell->largeAllocation(), cell, dependency);
+    if (cell->isPreciseAllocation())
+        setMarkedAndAppendToMarkStack(cell->preciseAllocation(), cell, dependency);
     else
         setMarkedAndAppendToMarkStack(cell->markedBlock(), cell, dependency);
@@ -282 +282 @@
 void SlotVisitor::appendToMarkStack(JSCell* cell)
 {
-    if (cell->isLargeAllocation())
-        appendToMarkStack(cell->largeAllocation(), cell);
+    if (cell->isPreciseAllocation())
+        appendToMarkStack(cell->preciseAllocation(), cell);
     else
         appendToMarkStack(cell->markedBlock(), cell);

trunk/Source/JavaScriptCore/heap/SlotVisitorInlines.h

@@ -47 +47 @@
     
     Dependency dependency;
-    if (UNLIKELY(cell->isLargeAllocation())) {
-        if (LIKELY(cell->largeAllocation().isMarked())) {
+    if (UNLIKELY(cell->isPreciseAllocation())) {
+        if (LIKELY(cell->preciseAllocation().isMarked())) {
             if (LIKELY(!m_heapAnalyzer))
                 return;
@@ -85 +85 @@
     
     Dependency dependency;
-    if (UNLIKELY(cell->isLargeAllocation())) {
-        if (LIKELY(cell->largeAllocation().isMarked()))
+    if (UNLIKELY(cell->isPreciseAllocation())) {
+        if (LIKELY(cell->preciseAllocation().isMarked()))
             return;
     } else {

trunk/Source/JavaScriptCore/heap/Subspace.h

@@ -82 +82 @@
     
     template<typename Func>
-    void forEachLargeAllocation(const Func&);
+    void forEachPreciseAllocation(const Func&);
     
     template<typename Func>
@@ -114 +114 @@
     BlockDirectory* m_firstDirectory { nullptr };
     BlockDirectory* m_directoryForEmptyAllocation { nullptr }; // Uses the MarkedSpace linked list of blocks.
-    SentinelLinkedList<LargeAllocation, PackedRawSentinelNode<LargeAllocation>> m_largeAllocations;
+    SentinelLinkedList<PreciseAllocation, PackedRawSentinelNode<PreciseAllocation>> m_preciseAllocations;
     Subspace* m_nextSubspaceInAlignedMemoryAllocator { nullptr };
 

trunk/Source/JavaScriptCore/heap/SubspaceInlines.h

@@ -61 +61 @@
 
 template<typename Func>
-void Subspace::forEachLargeAllocation(const Func& func)
+void Subspace::forEachPreciseAllocation(const Func& func)
 {
-    for (LargeAllocation* allocation = m_largeAllocations.begin(); allocation != m_largeAllocations.end(); allocation = allocation->next())
+    for (PreciseAllocation* allocation = m_preciseAllocations.begin(); allocation != m_preciseAllocations.end(); allocation = allocation->next())
         func(allocation);
 }
@@ -79 +79 @@
         });
     CellAttributes attributes = this->attributes();
-    forEachLargeAllocation(
-        [&] (LargeAllocation* allocation) {
+    forEachPreciseAllocation(
+        [&] (PreciseAllocation* allocation) {
             if (allocation->isMarked())
                 func(allocation->cell(), attributes.cellKind);
@@ -110 +110 @@
             {
                 auto locker = holdLock(m_lock);
-                if (!m_needToVisitLargeAllocations)
+                if (!m_needToVisitPreciseAllocations)
                     return;
-                m_needToVisitLargeAllocations = false;
+                m_needToVisitPreciseAllocations = false;
             }
             
             CellAttributes attributes = m_subspace.attributes();
-            m_subspace.forEachLargeAllocation(
-                [&] (LargeAllocation* allocation) {
+            m_subspace.forEachPreciseAllocation(
+                [&] (PreciseAllocation* allocation) {
                     if (allocation->isMarked())
                         m_func(visitor, allocation->cell(), attributes.cellKind);
@@ -128 +128 @@
         Func m_func;
         Lock m_lock;
-        bool m_needToVisitLargeAllocations { true };
+        bool m_needToVisitPreciseAllocations { true };
     };
     
@@ -146 +146 @@
         });
     CellAttributes attributes = this->attributes();
-    forEachLargeAllocation(
-        [&] (LargeAllocation* allocation) {
+    forEachPreciseAllocation(
+        [&] (PreciseAllocation* allocation) {
             if (allocation->isLive())
                 func(allocation->cell(), attributes.cellKind);

trunk/Source/JavaScriptCore/heap/WeakBlock.cpp

@@ -142 +142 @@
     ASSERT(m_container);
     
-    if (m_container.isLargeAllocation())
-        specializedVisit(m_container.largeAllocation(), visitor);
+    if (m_container.isPreciseAllocation())
+        specializedVisit(m_container.preciseAllocation(), visitor);
     else
         specializedVisit(m_container.markedBlock(), visitor);

trunk/Source/JavaScriptCore/heap/WeakSet.cpp

@@ -57 +57 @@
             // If this WeakBlock is logically empty, but still has Weaks pointing into it,
             // we can't destroy it just yet. Detach it from the WeakSet and hand ownership
-            // to the Heap so we don't pin down the entire MarkedBlock or LargeAllocation.
+            // to the Heap so we don't pin down the entire MarkedBlock or PreciseAllocation.
             m_blocks.remove(block);
             heap()->addLogicallyEmptyWeakBlock(block);

trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

@@ -558 +558 @@
 const MarkedBlockMask = ~(MarkedBlockSize - 1)
 const MarkedBlockFooterOffset = constexpr MarkedBlock::offsetOfFooter
-const LargeAllocationHeaderSize = constexpr (LargeAllocation::headerSize())
-const LargeAllocationVMOffset = (LargeAllocation::m_weakSet + WeakSet::m_vm - LargeAllocationHeaderSize)
+const PreciseAllocationHeaderSize = constexpr (PreciseAllocation::headerSize())
+const PreciseAllocationVMOffset = (PreciseAllocation::m_weakSet + WeakSet::m_vm - PreciseAllocationHeaderSize)
 
 const BlackThreshold = constexpr blackThreshold
@@ -1166 +1166 @@
 
 macro convertCalleeToVM(callee)
-    btpnz callee, (constexpr LargeAllocation::halfAlignment), .largeAllocation
+    btpnz callee, (constexpr PreciseAllocation::halfAlignment), .preciseAllocation
     andp MarkedBlockMask, callee
     loadp MarkedBlockFooterOffset + MarkedBlock::Footer::m_vm[callee], callee
     jmp .done
-.largeAllocation:
-    loadp LargeAllocationVMOffset[callee], callee
+.preciseAllocation:
+    loadp PreciseAllocationVMOffset[callee], callee
 .done:
 end

trunk/Source/JavaScriptCore/runtime/ButterflyInlines.h

@@ -207 +207 @@
     ASSERT(newSize >= oldSize);
 
-    // We can eagerly destroy butterfly backed by LargeAllocation if (1) concurrent collector is not active and (2) the butterfly does not contain any property storage.
+    // We can eagerly destroy butterfly backed by PreciseAllocation if (1) concurrent collector is not active and (2) the butterfly does not contain any property storage.
     // This is because during deallocation concurrent collector can access butterfly and DFG concurrent compilers accesses properties.
     // Objects with no properties are common in arrays, and we are focusing on very large array crafted by repeating Array#push, so... that's fine!
-    bool canRealloc = !propertyCapacity && !vm.heap.mutatorShouldBeFenced() && bitwise_cast<HeapCell*>(theBase)->isLargeAllocation();
+    bool canRealloc = !propertyCapacity && !vm.heap.mutatorShouldBeFenced() && bitwise_cast<HeapCell*>(theBase)->isPreciseAllocation();
     if (canRealloc) {
-        void* newBase = vm.jsValueGigacageAuxiliarySpace.reallocateLargeAllocationNonVirtual(vm, bitwise_cast<HeapCell*>(theBase), newSize, &deferralContext, AllocationFailureMode::ReturnNull);
+        void* newBase = vm.jsValueGigacageAuxiliarySpace.reallocatePreciseAllocationNonVirtual(vm, bitwise_cast<HeapCell*>(theBase), newSize, &deferralContext, AllocationFailureMode::ReturnNull);
         if (!newBase)
             return nullptr;

trunk/Source/JavaScriptCore/runtime/OptionsList.h

@@ -184 +184 @@
     v(Bool, scribbleFreeCells, false, Normal, nullptr) \
     v(Double, sizeClassProgression, 1.4, Normal, nullptr) \
-    v(Unsigned, largeAllocationCutoff, 100000, Normal, nullptr) \
+    v(Unsigned, preciseAllocationCutoff, 100000, Normal, nullptr) \
     v(Bool, dumpSizeClasses, false, Normal, nullptr) \
     v(Bool, useBumpAllocator, true, Normal, nullptr) \

trunk/Source/JavaScriptCore/runtime/SamplingProfiler.cpp

@@ -308 +308 @@
 
     m_currentFrames.grow(256);
-    vm.heap.objectSpace().enableLargeAllocationTracking();
+    vm.heap.objectSpace().enablePreciseAllocationTracking();
 }
 

trunk/Source/JavaScriptCore/tools/VMInspector.cpp

@@ -232 +232 @@
     if (heap->objectSpace().blocks().set().contains(candidate))
         return true;
-    for (LargeAllocation* allocation : heap->objectSpace().largeAllocations()) {
+    for (PreciseAllocation* allocation : heap->objectSpace().preciseAllocations()) {
         if (allocation->contains(ptr))
             return true;

trunk/Source/JavaScriptCore/tools/VMInspectorInlines.h

@@ -60 +60 @@
 {
     size_t allocatorCellSize = 0;
-    if (cell->isLargeAllocation()) {
-        LargeAllocation& largeAllocation = cell->largeAllocation();
-        AUDIT_VERIFY(action, verifier, &largeAllocation.vm() == &vm, cell, cell->type(), &largeAllocation.vm(), &vm);
+    if (cell->isPreciseAllocation()) {
+        PreciseAllocation& preciseAllocation = cell->preciseAllocation();
+        AUDIT_VERIFY(action, verifier, &preciseAllocation.vm() == &vm, cell, cell->type(), &preciseAllocation.vm(), &vm);
 
-        bool isValidLargeAllocation = false;
-        for (auto* i : vm.heap.objectSpace().largeAllocations()) {
-            if (i == &largeAllocation) {
-                isValidLargeAllocation = true;
+        bool isValidPreciseAllocation = false;
+        for (auto* i : vm.heap.objectSpace().preciseAllocations()) {
+            if (i == &preciseAllocation) {
+                isValidPreciseAllocation = true;
                 break;
             }
         }
-        AUDIT_VERIFY(action, verifier, isValidLargeAllocation, cell, cell->type());
+        AUDIT_VERIFY(action, verifier, isValidPreciseAllocation, cell, cell->type());
 
-        allocatorCellSize = largeAllocation.cellSize();
+        allocatorCellSize = preciseAllocation.cellSize();
     } else {
         MarkedBlock& block = cell->markedBlock();