Attachment 369465 Details for Bug 197730 – Patch

[patch] Patch

bug-197730-20190508224859.patch (text/plain), 53.34 KB, created by Yusuke Suzuki on 2019-05-08 22:49:00 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2019-05-08 22:49:00 PDT

Size: 53.34 KB

patch

obsolete

>Subversion Revision: 245093
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index d28ce69f4a1c3ed8500abafd9dfa14ef48e71908..2153806189f98ace869f8e8895be7b5647d13c0f 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,42 @@
>+2019-05-08 Yusuke Suzuki <ysuzuki@apple.com>
>+
>+ [JSC] Compress Watchpoint size by using enum type and Packed<> data structure
>+ https://bugs.webkit.org/show_bug.cgi?id=197730
>+
>+ Reviewed by NOBODY (OOPS!).
>+
>+ * JavaScriptCore.xcodeproj/project.pbxproj:
>+ * Sources.txt:
>+ * bytecode/AdaptiveInferredPropertyValueWatchpointBase.h:
>+ * bytecode/CodeBlockJettisoningWatchpoint.h:
>+ * bytecode/CodeOrigin.h:
>+ * bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp:
>+ (JSC::LLIntPrototypeLoadAdaptiveStructureWatchpoint::LLIntPrototypeLoadAdaptiveStructureWatchpoint):
>+ (JSC::LLIntPrototypeLoadAdaptiveStructureWatchpoint::fireInternal):
>+ * bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.h:
>+ * bytecode/StructureStubClearingWatchpoint.cpp:
>+ (JSC::StructureStubClearingWatchpoint::fireInternal):
>+ * bytecode/StructureStubClearingWatchpoint.h:
>+ * bytecode/Watchpoint.cpp:
>+ (JSC::Watchpoint::fire):
>+ * bytecode/Watchpoint.h:
>+ (JSC::Watchpoint::Watchpoint):
>+ * dfg/DFGAdaptiveStructureWatchpoint.cpp:
>+ (JSC::DFG::AdaptiveStructureWatchpoint::AdaptiveStructureWatchpoint):
>+ * dfg/DFGAdaptiveStructureWatchpoint.h:
>+ * runtime/FunctionRareData.h:
>+ * runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp: Added.
>+ (JSC::ObjectToStringAdaptiveStructureWatchpoint::ObjectToStringAdaptiveStructureWatchpoint):
>+ (JSC::ObjectToStringAdaptiveStructureWatchpoint::install):
>+ (JSC::ObjectToStringAdaptiveStructureWatchpoint::fireInternal):
>+ * runtime/ObjectToStringAdaptiveStructureWatchpoint.h: Added.
>+ * runtime/StructureRareData.cpp:
>+ (JSC::StructureRareData::clearObjectToStringValue):
>+ (JSC::ObjectToStringAdaptiveStructureWatchpoint::ObjectToStringAdaptiveStructureWatchpoint): Deleted.
>+ (JSC::ObjectToStringAdaptiveStructureWatchpoint::install): Deleted.
>+ (JSC::ObjectToStringAdaptiveStructureWatchpoint::fireInternal): Deleted.
>+ * runtime/StructureRareData.h:
>+
> 2019-05-08 Yusuke Suzuki <ysuzuki@apple.com>
> 
> Unreviewed, build fix after r245064
>diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog
>index 6f263fe8e3c46f1b618fd717f2c3840dde27bea8..ae6f713e81747aa28b901e6477c07217d3baf9b7 100644
>--- a/Source/WTF/ChangeLog
>+++ b/Source/WTF/ChangeLog
>@@ -1,3 +1,49 @@
>+2019-05-08 Yusuke Suzuki <ysuzuki@apple.com>
>+
>+ [JSC] Compress Watchpoint size by using enum type and Packed<> data structure
>+ https://bugs.webkit.org/show_bug.cgi?id=197730
>+
>+ Reviewed by NOBODY (OOPS!).
>+
>+ * WTF.xcodeproj/project.pbxproj:
>+ * wtf/Bag.h:
>+ (WTF::Bag::clear):
>+ (WTF::Bag::iterator::operator++):
>+ * wtf/CMakeLists.txt:
>+ * wtf/DumbPtrTraits.h:
>+ * wtf/DumbValueTraits.h:
>+ * wtf/MathExtras.h:
>+ (WTF::getLSBSetConstexpr):
>+ * wtf/Packed.h: Added.
>+ (WTF::Packed::Packed):
>+ (WTF::Packed::get const):
>+ (WTF::Packed::set):
>+ (WTF::Packed::operator=):
>+ (WTF::Packed::exchange):
>+ (WTF::Packed::swap):
>+ (WTF::alignof):
>+ (WTF::PackedPtrTraits::exchange):
>+ (WTF::PackedPtrTraits::swap):
>+ (WTF::PackedPtrTraits::unwrap):
>+ * wtf/Platform.h:
>+ * wtf/SentinelLinkedList.h:
>+ (WTF::BasicRawSentinelNode::BasicRawSentinelNode):
>+ (WTF::BasicRawSentinelNode::prev):
>+ (WTF::BasicRawSentinelNode::next):
>+ (WTF::PtrTraits>::remove):
>+ (WTF::PtrTraits>::prepend):
>+ (WTF::PtrTraits>::append):
>+ (WTF::RawNode>::SentinelLinkedList):
>+ (WTF::RawNode>::remove):
>+ (WTF::BasicRawSentinelNode<T>::remove): Deleted.
>+ (WTF::BasicRawSentinelNode<T>::prepend): Deleted.
>+ (WTF::BasicRawSentinelNode<T>::append): Deleted.
>+ * wtf/StdLibExtras.h:
>+ (WTF::roundUpToMultipleOfImpl):
>+ (WTF::roundDownToMultipleOfImpl):
>+ (WTF::roundDownToMultipleOf):
>+ (WTF::roundUpToMultipleOfImpl0): Deleted.
>+
> 2019-05-08 Alex Christensen <achristensen@webkit.org>
> 
> Add SPI to set HSTS storage directory
>diff --git a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>index e7dc887b9aaf815bb3b80a7d42e8a07f894fdd03..47996435325d9415797e94469d9fcbf4413e5159 100644
>--- a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>+++ b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>@@ -1791,6 +1791,7 @@
> 		E393ADD81FE702D00022D681 /* WeakMapImplInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = E393ADD71FE702CC0022D681 /* WeakMapImplInlines.h */; };
> 		E39D45F51D39005600B3B377 /* InterpreterInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = E39D9D841D39000600667282 /* InterpreterInlines.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		E39DA4A71B7E8B7C0084F33A /* JSModuleRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = E39DA4A51B7E8B7C0084F33A /* JSModuleRecord.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		E39EEAF322812450008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.h in Headers */ = {isa = PBXBuildFile; fileRef = E39EEAF22281244C008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.h */; };
> 		E3A0531A21342B680022EC14 /* WasmStreamingParser.h in Headers */ = {isa = PBXBuildFile; fileRef = E3A0531621342B660022EC14 /* WasmStreamingParser.h */; };
> 		E3A0531C21342B680022EC14 /* WasmSectionParser.h in Headers */ = {isa = PBXBuildFile; fileRef = E3A0531821342B670022EC14 /* WasmSectionParser.h */; };
> 		E3A32BC71FC83147007D7E76 /* WeakMapImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = E3A32BC61FC8312E007D7E76 /* WeakMapImpl.h */; };
>@@ -4797,6 +4798,8 @@
> 		E39D9D841D39000600667282 /* InterpreterInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InterpreterInlines.h; sourceTree = "<group>"; };
> 		E39DA4A41B7E8B7C0084F33A /* JSModuleRecord.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSModuleRecord.cpp; sourceTree = "<group>"; };
> 		E39DA4A51B7E8B7C0084F33A /* JSModuleRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSModuleRecord.h; sourceTree = "<group>"; };
>+		E39EEAF12281244C008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ObjectToStringAdaptiveStructureWatchpoint.cpp; sourceTree = "<group>"; };
>+		E39EEAF22281244C008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ObjectToStringAdaptiveStructureWatchpoint.h; sourceTree = "<group>"; };
> 		E3A0531621342B660022EC14 /* WasmStreamingParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmStreamingParser.h; sourceTree = "<group>"; };
> 		E3A0531721342B660022EC14 /* WasmSectionParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WasmSectionParser.cpp; sourceTree = "<group>"; };
> 		E3A0531821342B670022EC14 /* WasmSectionParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmSectionParser.h; sourceTree = "<group>"; };
>@@ -7172,6 +7175,8 @@
> 				E3C295DC1ED2CBAA00D3016F /* ObjectPropertyChangeAdaptiveWatchpoint.h */,
> 				BC2680C80E16D4E900A06E92 /* ObjectPrototype.cpp */,
> 				BC2680C90E16D4E900A06E92 /* ObjectPrototype.h */,
>+				E39EEAF12281244C008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.cpp */,
>+				E39EEAF22281244C008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.h */,
> 				F692A8770255597D01FF60F7 /* Operations.cpp */,
> 				F692A8780255597D01FF60F7 /* Operations.h */,
> 				0FE228EA1436AB2300196C48 /* Options.cpp */,
>@@ -9657,6 +9662,7 @@
> 				0FD3E40A1B618B6600C80E1E /* ObjectPropertyCondition.h in Headers */,
> 				0FD3E40C1B618B6600C80E1E /* ObjectPropertyConditionSet.h in Headers */,
> 				BC18C4460E16F5CD00B34460 /* ObjectPrototype.h in Headers */,
>+				E39EEAF322812450008474F4 /* ObjectToStringAdaptiveStructureWatchpoint.h in Headers */,
> 				E124A8F70E555775003091F1 /* OpaqueJSString.h in Headers */,
> 				14F79F70216EAFD200046D39 /* Opcode.h in Headers */,
> 				FE64872E2141D04800AB0D3E /* OpcodeInlines.h in Headers */,
>diff --git a/Source/JavaScriptCore/Sources.txt b/Source/JavaScriptCore/Sources.txt
>index f5534441390d1a608aae0dc28ffbef31868329b4..2196c97bbb129e2abdbc30c8f5ccb414d6528fb8 100644
>--- a/Source/JavaScriptCore/Sources.txt
>+++ b/Source/JavaScriptCore/Sources.txt
>@@ -899,6 +899,7 @@ runtime/NumberPrototype.cpp
> runtime/ObjectConstructor.cpp
> runtime/ObjectInitializationScope.cpp
> runtime/ObjectPrototype.cpp
>+runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp
> runtime/Operations.cpp
> runtime/Options.cpp
> runtime/ProgramExecutable.cpp
>diff --git a/Source/JavaScriptCore/bytecode/AdaptiveInferredPropertyValueWatchpointBase.h b/Source/JavaScriptCore/bytecode/AdaptiveInferredPropertyValueWatchpointBase.h
>index 5d4e02aaefe966003f65218400887e42f1435e89..b14f66dde24d6e9f7d1ce6ce3649ecbcd2599a18 100644
>--- a/Source/JavaScriptCore/bytecode/AdaptiveInferredPropertyValueWatchpointBase.h
>+++ b/Source/JavaScriptCore/bytecode/AdaptiveInferredPropertyValueWatchpointBase.h
>@@ -45,24 +45,32 @@ class AdaptiveInferredPropertyValueWatchpointBase {
> 
> virtual ~AdaptiveInferredPropertyValueWatchpointBase() = default;
> 
>-protected:
>- virtual bool isValid() const;
>- virtual void handleFire(VM&, const FireDetail&) = 0;
>-
>-private:
> class StructureWatchpoint final : public Watchpoint {
> public:
>- StructureWatchpoint() { }
>- protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+ StructureWatchpoint()
>+ : Watchpoint(Watchpoint::Type::AdaptiveInferredPropertyValueStructure)
>+ { }
>+
>+ void fireInternal(VM&, const FireDetail&);
>+
>+ // Own destructor may not be called. Keep members trivially destructible.
> };
> class PropertyWatchpoint final : public Watchpoint {
> public:
>- PropertyWatchpoint() { }
>- protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+ PropertyWatchpoint()
>+ : Watchpoint(Watchpoint::Type::AdaptiveInferredPropertyValueProperty)
>+ { }
>+
>+ void fireInternal(VM&, const FireDetail&);
>+
>+ // Own destructor may not be called. Keep members trivially destructible.
> };
> 
>+protected:
>+ virtual bool isValid() const;
>+ virtual void handleFire(VM&, const FireDetail&) = 0;
>+
>+private:
> void fire(VM&, const FireDetail&);
> 
> ObjectPropertyCondition m_key;
>diff --git a/Source/JavaScriptCore/bytecode/CodeBlockJettisoningWatchpoint.h b/Source/JavaScriptCore/bytecode/CodeBlockJettisoningWatchpoint.h
>index af24ea3a6fb302b79260aafcf7efe6faf69ceba5..60c9d11b08349019eb726686310a13a8d3c4464b 100644
>--- a/Source/JavaScriptCore/bytecode/CodeBlockJettisoningWatchpoint.h
>+++ b/Source/JavaScriptCore/bytecode/CodeBlockJettisoningWatchpoint.h
>@@ -34,15 +34,16 @@ class CodeBlock;
> class CodeBlockJettisoningWatchpoint final : public Watchpoint {
> public:
> CodeBlockJettisoningWatchpoint(CodeBlock* codeBlock)
>- : m_codeBlock(codeBlock)
>+ : Watchpoint(Watchpoint::Type::CodeBlockJettisoning)
>+ , m_codeBlock(codeBlock)
> {
> }
> 
>-protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+ void fireInternal(VM&, const FireDetail&);
> 
> private:
>- CodeBlock* m_codeBlock;
>+ // Own destructor may not be called. Keep members trivially destructible.
>+ PackedAlignedPtr<CodeBlock, MarkedBlock::atomSize> m_codeBlock;
> };
> 
> } // namespace JSC
>diff --git a/Source/JavaScriptCore/bytecode/CodeOrigin.h b/Source/JavaScriptCore/bytecode/CodeOrigin.h
>index 551fbec0f7a4f30926c4e6fdf465ddd81cd0e584..b6954e7018bf90a3ec110213e2056cf5bdb34054 100644
>--- a/Source/JavaScriptCore/bytecode/CodeOrigin.h
>+++ b/Source/JavaScriptCore/bytecode/CodeOrigin.h
>@@ -232,14 +232,9 @@ class CodeOrigin {
> return bitwise_cast<InlineCallFrame*>(value);
> }
> 
>-#if CPU(ARM64) && CPU(ADDRESS64)
>- static constexpr unsigned s_freeBitsAtTop = 28;
>- static constexpr uintptr_t s_maskCompositeValueForPointer = 0x0000000ffffffff8;
>-#elif CPU(ADDRESS64)
>- static constexpr unsigned s_freeBitsAtTop = 16;
>- static constexpr uintptr_t s_maskCompositeValueForPointer = 0x0000fffffffffff8;
>-#endif
> #if CPU(ADDRESS64)
>+ static constexpr unsigned s_freeBitsAtTop = 64 - WTF_CPU_EFFECTIVE_ADDRESS_WIDTH;
>+ static constexpr uintptr_t s_maskCompositeValueForPointer = ((1ULL << WTF_CPU_EFFECTIVE_ADDRESS_WIDTH) - 1) & ~(8ULL - 1);
> static uintptr_t buildCompositeValue(InlineCallFrame* inlineCallFrame, unsigned bytecodeIndex)
> {
> if (bytecodeIndex == s_invalidBytecodeIndex)
>diff --git a/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp b/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp
>index 086b513b26e7d9ac7a9879505279b62fbf2bd4a9..0ef6a55c9c719603f1a2e38b580566f0a2467be1 100644
>--- a/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp
>+++ b/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp
>@@ -33,9 +33,10 @@
> namespace JSC {
> 
> LLIntPrototypeLoadAdaptiveStructureWatchpoint::LLIntPrototypeLoadAdaptiveStructureWatchpoint(CodeBlock* owner, const ObjectPropertyCondition& key, unsigned bytecodeOffset)
>- : m_owner(owner)
>- , m_key(key)
>+ : Watchpoint(Watchpoint::Type::LLIntPrototypeLoadAdaptiveStructure)
>+ , m_owner(owner)
> , m_bytecodeOffset(bytecodeOffset)
>+ , m_key(key)
> {
> RELEASE_ASSERT(key.watchingRequiresStructureTransitionWatchpoint());
> RELEASE_ASSERT(!key.watchingRequiresReplacementWatchpoint());
>@@ -58,8 +59,8 @@ void LLIntPrototypeLoadAdaptiveStructureWatchpoint::fireInternal(VM& vm, const F
> return;
> }
> 
>- auto& instruction = m_owner->instructions().at(m_bytecodeOffset);
>- clearLLIntGetByIdCache(instruction->as<OpGetById>().metadata(m_owner));
>+ auto& instruction = m_owner->instructions().at(m_bytecodeOffset.get());
>+ clearLLIntGetByIdCache(instruction->as<OpGetById>().metadata(m_owner.get()));
> }
> 
> void LLIntPrototypeLoadAdaptiveStructureWatchpoint::clearLLIntGetByIdCache(OpGetById::Metadata& metadata)
>diff --git a/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.h b/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.h
>index a9b1fcd2587ae86270923e44e613b6775d5a8ff2..36365eb3c5d0aed076e7d636cb18cc61bb637a14 100644
>--- a/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.h
>+++ b/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.h
>@@ -41,13 +41,13 @@ class LLIntPrototypeLoadAdaptiveStructureWatchpoint final : public Watchpoint {
> 
> const ObjectPropertyCondition& key() const { return m_key; }
> 
>-protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+ void fireInternal(VM&, const FireDetail&);
> 
> private:
>- CodeBlock* m_owner;
>+ // Own destructor may not be called. Keep members trivially destructible.
>+ PackedAlignedPtr<CodeBlock, MarkedBlock::atomSize> m_owner;
>+ Packed<unsigned> m_bytecodeOffset;
> ObjectPropertyCondition m_key;
>- unsigned m_bytecodeOffset;
> };
> 
> } // namespace JSC
>diff --git a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp b/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp
>index 9416d308ada2f0e03e2916da3fd63955ba72a641..30a1f055259e3ded1a7168ee3526f72c084bee5a 100644
>--- a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp
>+++ b/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp
>@@ -36,15 +36,15 @@ namespace JSC {
> 
> void StructureStubClearingWatchpoint::fireInternal(VM& vm, const FireDetail&)
> {
>- if (!m_holder.isValid())
>+ if (!m_holder->isValid())
> return;
> 
> if (!m_key || !m_key.isWatchable(PropertyCondition::EnsureWatchability)) {
> // This will implicitly cause my own demise: stub reset removes all watchpoints.
> // That works, because deleting a watchpoint removes it from the set's list, and
> // the set's list traversal for firing is robust against the set changing.
>- ConcurrentJSLocker locker(m_holder.codeBlock()->m_lock);
>- m_holder.stubInfo()->reset(m_holder.codeBlock());
>+ ConcurrentJSLocker locker(m_holder->codeBlock()->m_lock);
>+ m_holder->stubInfo()->reset(m_holder->codeBlock());
> return;
> }
> 
>diff --git a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.h b/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.h
>index 70b697f69fbdcd490b270d5983b935b4f3c80382..52d290f27fa23051326532181ba00b781cf2475f 100644
>--- a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.h
>+++ b/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.h
>@@ -47,17 +47,18 @@ class StructureStubClearingWatchpoint final : public Watchpoint {
> StructureStubClearingWatchpoint(
> const ObjectPropertyCondition& key,
> WatchpointsOnStructureStubInfo& holder)
>- : m_key(key)
>- , m_holder(holder)
>+ : Watchpoint(Watchpoint::Type::StructureStubClearing)
>+ , m_holder(&holder)
>+ , m_key(key)
> {
> }
> 
>-protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+ void fireInternal(VM&, const FireDetail&);
> 
> private:
>+ // Own destructor may not be called. Keep members trivially destructible.
>+ PackedPtr<WatchpointsOnStructureStubInfo> m_holder;
> ObjectPropertyCondition m_key;
>- WatchpointsOnStructureStubInfo& m_holder;
> };
> 
> class WatchpointsOnStructureStubInfo {
>diff --git a/Source/JavaScriptCore/bytecode/Watchpoint.cpp b/Source/JavaScriptCore/bytecode/Watchpoint.cpp
>index 7fa56167bf2045f4c8c33ee155e0ab60a4c36b6d..b2305d7d3f62ccdabfac7059f64916e214383167 100644
>--- a/Source/JavaScriptCore/bytecode/Watchpoint.cpp
>+++ b/Source/JavaScriptCore/bytecode/Watchpoint.cpp
>@@ -26,7 +26,13 @@
> #include "config.h"
> #include "Watchpoint.h"
> 
>+#include "AdaptiveInferredPropertyValueWatchpointBase.h"
>+#include "CodeBlockJettisoningWatchpoint.h"
>+#include "DFGAdaptiveStructureWatchpoint.h"
>+#include "FunctionRareData.h"
> #include "HeapInlines.h"
>+#include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"
>+#include "ObjectToStringAdaptiveStructureWatchpoint.h"
> #include "VM.h"
> #include <wtf/CompilationThread.h>
> 
>@@ -52,7 +58,14 @@ Watchpoint::~Watchpoint()
> void Watchpoint::fire(VM& vm, const FireDetail& detail)
> {
> RELEASE_ASSERT(!isOnList());
>- fireInternal(vm, detail);
>+ switch (m_type) {
>+#define JSC_DEFINE_WATCHPOINT_DISPATCH(type, cast) \
>+ case Type::type: \
>+ static_cast<cast*>(this)->fireInternal(vm, detail); \
>+ break;
>+ JSC_WATCHPOINT_TYPES(JSC_DEFINE_WATCHPOINT_DISPATCH)
>+#undef JSC_DEFINE_WATCHPOINT_DISPATCH
>+ }
> }
> 
> WatchpointSet::WatchpointSet(WatchpointState state)
>diff --git a/Source/JavaScriptCore/bytecode/Watchpoint.h b/Source/JavaScriptCore/bytecode/Watchpoint.h
>index 77fba3efa9a5a45791b2b3ece232bf1d221a706b..45f3c8a0e7c09233f21562e91098ac95454c4bd2 100644
>--- a/Source/JavaScriptCore/bytecode/Watchpoint.h
>+++ b/Source/JavaScriptCore/bytecode/Watchpoint.h
>@@ -90,21 +90,55 @@ LazyFireDetail<Types...> createLazyFireDetail(const Types&... types)
> 
> class WatchpointSet;
> 
>-class Watchpoint : public BasicRawSentinelNode<Watchpoint> {
>+// Really unfortunately, we do not have the way to dispatch appropriate destructor based on enum type.
>+// If we call destructor explicitly in the base class, it ends up calling the base destructor twice.
>+// C++20 allows this by using std::std::destroying_delete_t. But we are not using C++20 right now.
>+//
>+// Luckily, none of our derived watchpoint classes have members which require destructors. So now we do
>+// not dispatch the destructor call to the drived class. If it becomes really required, we can introduce
>+// a custom deleter to container classes (Bag, Vector etc.) and call Watchpoint::destroy instead of "delete"
>+// operator. But since we do not require it for now, we are doing the simplest thing.
>+#define JSC_WATCHPOINT_TYPES_WITHOUT_DFG(macro) \
>+ macro(AdaptiveInferredPropertyValueStructure, AdaptiveInferredPropertyValueWatchpointBase::StructureWatchpoint) \
>+ macro(AdaptiveInferredPropertyValueProperty, AdaptiveInferredPropertyValueWatchpointBase::PropertyWatchpoint) \
>+ macro(CodeBlockJettisoning, CodeBlockJettisoningWatchpoint) \
>+ macro(LLIntPrototypeLoadAdaptiveStructure, LLIntPrototypeLoadAdaptiveStructureWatchpoint) \
>+ macro(StructureStubClearing, StructureStubClearingWatchpoint) \
>+ macro(FunctionRareDataAllocationProfileClearing, FunctionRareData::AllocationProfileClearingWatchpoint) \
>+ macro(ObjectToStringAdaptiveStructure, ObjectToStringAdaptiveStructureWatchpoint)
>+
>+#if ENABLE(DFG_JIT)
>+#define JSC_WATCHPOINT_TYPES(macro) \
>+ JSC_WATCHPOINT_TYPES_WITHOUT_DFG(macro) \
>+ macro(AdaptiveStructure, DFG::AdaptiveStructureWatchpoint)
>+#else
>+#define JSC_WATCHPOINT_TYPES(macro) \
>+ JSC_WATCHPOINT_TYPES_WITHOUT_DFG(macro)
>+#endif
>+
>+
>+class Watchpoint : public PackedRawSentinelNode<Watchpoint> {
> WTF_MAKE_NONCOPYABLE(Watchpoint);
> WTF_MAKE_NONMOVABLE(Watchpoint);
> WTF_MAKE_FAST_ALLOCATED;
> public:
>- Watchpoint() = default;
>- 
>- virtual ~Watchpoint();
>+#define JSC_DEFINE_WATCHPOINT_TYPES(type, _) type,
>+ enum class Type : uint8_t {
>+ JSC_WATCHPOINT_TYPES(JSC_DEFINE_WATCHPOINT_TYPES)
>+ };
>+#undef JSC_DEFINE_WATCHPOINT_TYPES
> 
>-protected:
>- virtual void fireInternal(VM&, const FireDetail&) = 0;
>+ Watchpoint(Type type)
>+ : m_type(type)
>+ { }
>+
>+ ~Watchpoint();
> 
> private:
> friend class WatchpointSet;
> void fire(VM&, const FireDetail&);
>+
>+ Type m_type;
> };
> 
> enum WatchpointState {
>@@ -239,7 +273,7 @@ class WatchpointSet : public ThreadSafeRefCounted<WatchpointSet> {
> int8_t m_state;
> int8_t m_setIsNotEmpty;
> 
>- SentinelLinkedList<Watchpoint, BasicRawSentinelNode<Watchpoint>> m_set;
>+ SentinelLinkedList<Watchpoint, PackedRawSentinelNode<Watchpoint>> m_set;
> };
> 
> // InlineWatchpointSet is a low-overhead, non-copyable watchpoint set in which
>diff --git a/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.cpp b/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.cpp
>index 5b9dda6fb0b174aac94a797ca1190cc5496a244d..8ca7df382175e430198a6acd6a150b33f39f93e0 100644
>--- a/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.cpp
>@@ -36,8 +36,9 @@ namespace JSC { namespace DFG {
> AdaptiveStructureWatchpoint::AdaptiveStructureWatchpoint(
> const ObjectPropertyCondition& key,
> CodeBlock* codeBlock)
>- : m_key(key)
>+ : Watchpoint(Watchpoint::Type::AdaptiveStructure)
> , m_codeBlock(codeBlock)
>+ , m_key(key)
> {
> RELEASE_ASSERT(key.watchingRequiresStructureTransitionWatchpoint());
> RELEASE_ASSERT(!key.watchingRequiresReplacementWatchpoint());
>diff --git a/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.h b/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.h
>index 94013dc9683f38a9d9437689f2dac0a84e630078..b2ac8dedf3b3379874ae48e3d8c1e47414058044 100644
>--- a/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.h
>+++ b/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.h
>@@ -40,12 +40,12 @@ class AdaptiveStructureWatchpoint final : public Watchpoint {
> 
> void install(VM&);
> 
>-protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+ void fireInternal(VM&, const FireDetail&);
> 
> private:
>+ // Own destructor may not be called. Keep members trivially destructible.
>+ PackedAlignedPtr<CodeBlock, MarkedBlock::atomSize> m_codeBlock;
> ObjectPropertyCondition m_key;
>- CodeBlock* m_codeBlock;
> };
> 
> } } // namespace JSC::DFG
>diff --git a/Source/JavaScriptCore/runtime/FunctionRareData.h b/Source/JavaScriptCore/runtime/FunctionRareData.h
>index 132c27960266f7f0fef59ca6de256345f02f5324..9849d8feb64437aba6b0ea56d18d91c103ac23e6 100644
>--- a/Source/JavaScriptCore/runtime/FunctionRareData.h
>+++ b/Source/JavaScriptCore/runtime/FunctionRareData.h
>@@ -110,23 +110,25 @@ class FunctionRareData final : public JSCell {
> return m_allocationProfileClearingWatchpoint.get();
> }
> 
>-protected:
>- FunctionRareData(VM&);
>- ~FunctionRareData();
>-
>-private:
>-
> class AllocationProfileClearingWatchpoint final : public Watchpoint {
> public:
> AllocationProfileClearingWatchpoint(FunctionRareData* rareData)
>- : m_rareData(rareData)
>+ : Watchpoint(Watchpoint::Type::FunctionRareDataAllocationProfileClearing)
>+ , m_rareData(rareData)
> { }
>- protected:
>- void fireInternal(VM&, const FireDetail&) override;
>+
>+ void fireInternal(VM&, const FireDetail&);
>+
> private:
>- FunctionRareData* m_rareData;
>+ // Own destructor may not be called. Keep members trivially destructible.
>+ PackedAlignedPtr<FunctionRareData, MarkedBlock::atomSize> m_rareData;
> };
> 
>+protected:
>+ FunctionRareData(VM&);
>+ ~FunctionRareData();
>+
>+private:
> friend class LLIntOffsetsExtractor;
> 
> // Ideally, there would only be one allocation profile for subclassing but due to Reflect.construct we
>diff --git a/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp b/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..64a392f364d5d0a9562ef930245da9924b3f246b
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp
>@@ -0,0 +1,63 @@
>+/*
>+ * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ * notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ * notice, this list of conditions and the following disclaimer in the
>+ * documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "ObjectToStringAdaptiveStructureWatchpoint.h"
>+
>+#include "ObjectPropertyConditionSet.h"
>+#include "StructureRareData.h"
>+
>+namespace JSC {
>+
>+ObjectToStringAdaptiveStructureWatchpoint::ObjectToStringAdaptiveStructureWatchpoint(const ObjectPropertyCondition& key, StructureRareData* structureRareData)
>+ : Watchpoint(Watchpoint::Type::ObjectToStringAdaptiveStructure)
>+ , m_structureRareData(structureRareData)
>+ , m_key(key)
>+{
>+ RELEASE_ASSERT(key.watchingRequiresStructureTransitionWatchpoint());
>+ RELEASE_ASSERT(!key.watchingRequiresReplacementWatchpoint());
>+}
>+
>+void ObjectToStringAdaptiveStructureWatchpoint::install(VM& vm)
>+{
>+ RELEASE_ASSERT(m_key.isWatchable());
>+
>+ m_key.object()->structure(vm)->addTransitionWatchpoint(this);
>+}
>+
>+void ObjectToStringAdaptiveStructureWatchpoint::fireInternal(VM& vm, const FireDetail&)
>+{
>+ if (!m_structureRareData->isLive())
>+ return;
>+
>+ if (m_key.isWatchable(PropertyCondition::EnsureWatchability)) {
>+ install(vm);
>+ return;
>+ }
>+
>+ m_structureRareData->clearObjectToStringValue();
>+}
>+
>+} // namespace JSC
>diff --git a/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.h b/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..bcf46fa8ccf169d9503046aff8210432d9b8973d
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.h
>@@ -0,0 +1,51 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ * notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ * notice, this list of conditions and the following disclaimer in the
>+ * documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "ObjectPropertyCondition.h"
>+#include "Watchpoint.h"
>+
>+namespace JSC {
>+
>+class StructureRareData;
>+
>+class ObjectToStringAdaptiveStructureWatchpoint final : public Watchpoint {
>+public:
>+ ObjectToStringAdaptiveStructureWatchpoint(const ObjectPropertyCondition&, StructureRareData*);
>+
>+ void install(VM&);
>+
>+ const ObjectPropertyCondition& key() const { return m_key; }
>+
>+ void fireInternal(VM&, const FireDetail&);
>+ 
>+private:
>+ // Own destructor may not be called. Keep members trivially destructible.
>+ PackedAlignedPtr<StructureRareData, MarkedBlock::atomSize> m_structureRareData;
>+ ObjectPropertyCondition m_key;
>+};
>+
>+}
>diff --git a/Source/JavaScriptCore/runtime/StructureRareData.cpp b/Source/JavaScriptCore/runtime/StructureRareData.cpp
>index 5c1c5f7f9bf226ccaad40d94dd6ccd9cde97cfc3..99a8d9f7daac217e4c81e7e7126e9c02b374ed3f 100644
>--- a/Source/JavaScriptCore/runtime/StructureRareData.cpp
>+++ b/Source/JavaScriptCore/runtime/StructureRareData.cpp
>@@ -32,6 +32,7 @@
> #include "JSString.h"
> #include "JSCInlines.h"
> #include "ObjectPropertyConditionSet.h"
>+#include "ObjectToStringAdaptiveStructureWatchpoint.h"
> 
> namespace JSC {
> 
>@@ -90,22 +91,6 @@ class ObjectToStringAdaptiveInferredPropertyValueWatchpoint final : public Adapt
> StructureRareData* m_structureRareData;
> };
> 
>-class ObjectToStringAdaptiveStructureWatchpoint final : public Watchpoint {
>-public:
>- ObjectToStringAdaptiveStructureWatchpoint(const ObjectPropertyCondition&, StructureRareData*);
>-
>- void install(VM&);
>-
>- const ObjectPropertyCondition& key() const { return m_key; }
>-
>-protected:
>- void fireInternal(VM&, const FireDetail&) override;
>- 
>-private:
>- ObjectPropertyCondition m_key;
>- StructureRareData* m_structureRareData;
>-};
>-
> void StructureRareData::setObjectToStringValue(ExecState* exec, VM& vm, Structure* ownStructure, JSString* value, PropertySlot toStringTagSymbolSlot)
> {
> if (m_giveUpOnObjectToStringValueCache)
>@@ -164,7 +149,7 @@ void StructureRareData::setObjectToStringValue(ExecState* exec, VM& vm, Structur
> m_objectToStringValue.set(vm, this, value);
> }
> 
>-inline void StructureRareData::clearObjectToStringValue()
>+void StructureRareData::clearObjectToStringValue()
> {
> m_objectToStringAdaptiveWatchpointSet.clear();
> m_objectToStringAdaptiveInferredValueWatchpoint.reset();
>@@ -189,34 +174,6 @@ void StructureRareData::finalizeUnconditionally(VM& vm)
> 
> // ------------- Methods for Object.prototype.toString() helper watchpoint classes --------------
> 
>-ObjectToStringAdaptiveStructureWatchpoint::ObjectToStringAdaptiveStructureWatchpoint(const ObjectPropertyCondition& key, StructureRareData* structureRareData)
>- : m_key(key)
>- , m_structureRareData(structureRareData)
>-{
>- RELEASE_ASSERT(key.watchingRequiresStructureTransitionWatchpoint());
>- RELEASE_ASSERT(!key.watchingRequiresReplacementWatchpoint());
>-}
>-
>-void ObjectToStringAdaptiveStructureWatchpoint::install(VM& vm)
>-{
>- RELEASE_ASSERT(m_key.isWatchable());
>-
>- m_key.object()->structure(vm)->addTransitionWatchpoint(this);
>-}
>-
>-void ObjectToStringAdaptiveStructureWatchpoint::fireInternal(VM& vm, const FireDetail&)
>-{
>- if (!m_structureRareData->isLive())
>- return;
>-
>- if (m_key.isWatchable(PropertyCondition::EnsureWatchability)) {
>- install(vm);
>- return;
>- }
>-
>- m_structureRareData->clearObjectToStringValue();
>-}
>-
> ObjectToStringAdaptiveInferredPropertyValueWatchpoint::ObjectToStringAdaptiveInferredPropertyValueWatchpoint(const ObjectPropertyCondition& key, StructureRareData* structureRareData)
> : Base(key)
> , m_structureRareData(structureRareData)
>diff --git a/Source/JavaScriptCore/runtime/StructureRareData.h b/Source/JavaScriptCore/runtime/StructureRareData.h
>index e03b23f22b294a1248c1eed9e01408a554842a25..9ca7fc4272522f954d1457be3d93b232d71c9017 100644
>--- a/Source/JavaScriptCore/runtime/StructureRareData.h
>+++ b/Source/JavaScriptCore/runtime/StructureRareData.h
>@@ -35,8 +35,8 @@ namespace JSC {
> 
> class JSPropertyNameEnumerator;
> class Structure;
>-class ObjectToStringAdaptiveStructureWatchpoint;
> class ObjectToStringAdaptiveInferredPropertyValueWatchpoint;
>+class ObjectToStringAdaptiveStructureWatchpoint;
> 
> class StructureRareData final : public JSCell {
> public:
>diff --git a/Source/WTF/WTF.xcodeproj/project.pbxproj b/Source/WTF/WTF.xcodeproj/project.pbxproj
>index 8d5efaf23be0ca90d8bf882d6556fa4680196f34..30204fcd8882fa155c61745a3f33d892689b787b 100644
>--- a/Source/WTF/WTF.xcodeproj/project.pbxproj
>+++ b/Source/WTF/WTF.xcodeproj/project.pbxproj
>@@ -658,6 +658,7 @@
> 		E311FB161F0A568B003C08DE /* ThreadGroup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadGroup.h; sourceTree = "<group>"; };
> 		E3200AB41E9A536D003B59D2 /* PlatformRegisters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformRegisters.h; sourceTree = "<group>"; };
> 		E33D5F871FBED66700BF625E /* RecursableLambda.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RecursableLambda.h; sourceTree = "<group>"; };
>+		E34CD0D022810A020020D299 /* Packed.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Packed.h; sourceTree = "<group>"; };
> 		E360C7642127B85B00C90F0E /* UnalignedAccess.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnalignedAccess.h; sourceTree = "<group>"; };
> 		E360C7652127B85C00C90F0E /* Unexpected.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Unexpected.h; sourceTree = "<group>"; };
> 		E388886D20C9095100E632BC /* WorkerPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WorkerPool.cpp; sourceTree = "<group>"; };
>@@ -1056,6 +1057,7 @@
> 				7CBBA07319BB7FDC00BBF025 /* OSObjectPtr.h */,
> 				A8A472DA151A825B004123FF /* OSRandomSource.cpp */,
> 				A8A472DB151A825B004123FF /* OSRandomSource.h */,
>+				E34CD0D022810A020020D299 /* Packed.h */,
> 				A8A472DF151A825B004123FF /* PackedIntVector.h */,
> 				A8A472E0151A825B004123FF /* PageAllocation.h */,
> 				A8A472E3151A825B004123FF /* PageBlock.cpp */,
>diff --git a/Source/WTF/wtf/Bag.h b/Source/WTF/wtf/Bag.h
>index 1f85720db9dacdb89fde1321b332004e886d6783..897d2991b013a4a606ab38fa47c761fef1c9c1a7 100644
>--- a/Source/WTF/wtf/Bag.h
>+++ b/Source/WTF/wtf/Bag.h
>@@ -28,31 +28,35 @@
> #include <wtf/DumbPtrTraits.h>
> #include <wtf/FastMalloc.h>
> #include <wtf/Noncopyable.h>
>+#include <wtf/Packed.h>
> 
> namespace WTF {
> 
> namespace Private {
> 
>-template<typename T>
>+template<typename T, typename PassedPtrTraits = DumbPtrTraits<T>>
> class BagNode {
> WTF_MAKE_FAST_ALLOCATED;
> public:
>+ using PtrTraits = typename PassedPtrTraits::template RebindTraits<BagNode>;
>+
> template<typename... Args>
> BagNode(Args&&... args)
> : m_item(std::forward<Args>(args)...)
> { }
> 
> T m_item;
>- BagNode* m_next { nullptr };
>+ typename PtrTraits::StorageType m_next { nullptr };
> };
> 
> } // namespace Private
> 
>-template<typename T, typename PtrTraits = DumbPtrTraits<Private::BagNode<T>>>
>+template<typename T, typename PassedPtrTraits = DumbPtrTraits<T>>
> class Bag {
> WTF_MAKE_NONCOPYABLE(Bag);
> WTF_MAKE_FAST_ALLOCATED;
>- using Node = Private::BagNode<T>;
>+ using Node = Private::BagNode<T, PassedPtrTraits>;
>+ using PtrTraits = typename PassedPtrTraits::template RebindTraits<Node>;
> 
> public:
> Bag() = default;
>@@ -83,7 +87,7 @@ class Bag {
> Node* head = this->unwrappedHead();
> while (head) {
> Node* current = head;
>- head = current->m_next;
>+ head = Node::PtrTraits::unwrap(current->m_next);
> delete current;
> }
> m_head = nullptr;
>@@ -112,7 +116,7 @@ class Bag {
> 
> iterator& operator++()
> {
>- m_node = m_node->m_next;
>+ m_node = Node::PtrTraits::unwrap(m_node->m_next);
> return *this;
> }
> 
>@@ -156,6 +160,10 @@ class Bag {
> typename PtrTraits::StorageType m_head { nullptr };
> };
> 
>+template<typename T>
>+using PackedBag = Bag<T, PackedPtrTraits<T>>;
>+
> } // namespace WTF
> 
> using WTF::Bag;
>+using WTF::PackedBag;
>diff --git a/Source/WTF/wtf/CMakeLists.txt b/Source/WTF/wtf/CMakeLists.txt
>index e60ec0be6e1c3431d6f3fd6e86cd7e671d58852a..6d6408019cfd48e9aea0c20736a965b1cce1d0f0 100644
>--- a/Source/WTF/wtf/CMakeLists.txt
>+++ b/Source/WTF/wtf/CMakeLists.txt
>@@ -150,6 +150,7 @@ set(WTF_PUBLIC_HEADERS
> OptionSet.h
> Optional.h
> OrderMaker.h
>+ Packed.h
> PackedIntVector.h
> PageAllocation.h
> PageBlock.h
>diff --git a/Source/WTF/wtf/DumbPtrTraits.h b/Source/WTF/wtf/DumbPtrTraits.h
>index 982a36882570969217fdcc849724888ff82bad44..51deba76bffe03d5dabc37d5751372e16226345f 100644
>--- a/Source/WTF/wtf/DumbPtrTraits.h
>+++ b/Source/WTF/wtf/DumbPtrTraits.h
>@@ -32,6 +32,8 @@ namespace WTF {
> 
> template<typename T>
> struct DumbPtrTraits {
>+ template<typename U> using RebindTraits = DumbPtrTraits;
>+
> using StorageType = T*;
> 
> template<typename U>
>diff --git a/Source/WTF/wtf/DumbValueTraits.h b/Source/WTF/wtf/DumbValueTraits.h
>index fbc63223148eb6f4b48c35e3e87bb78dab9032d5..77c53e95f3969279a9c55987fa908a2cb1febdbf 100644
>--- a/Source/WTF/wtf/DumbValueTraits.h
>+++ b/Source/WTF/wtf/DumbValueTraits.h
>@@ -32,6 +32,8 @@ namespace WTF {
> 
> template<typename T>
> struct DumbValueTraits {
>+ template<typename U> using RebindTraits = DumbValueTraits;
>+
> using StorageType = T;
> 
> template<typename U>
>diff --git a/Source/WTF/wtf/MathExtras.h b/Source/WTF/wtf/MathExtras.h
>index 8080533dd792f0f437b66e347c2d11beb3944e95..a460debb6e2861fc5737abfdfb61395d76ab23aa 100644
>--- a/Source/WTF/wtf/MathExtras.h
>+++ b/Source/WTF/wtf/MathExtras.h
>@@ -692,6 +692,16 @@ inline unsigned getMSBSet(T t)
> return bitSize - 1 - clz(t);
> }
> 
>+template <typename T> constexpr unsigned getLSBSetConstexpr(T value)
>+{
>+ using UnsignedT = typename std::make_unsigned<T>::type;
>+ unsigned result = 0;
>+ UnsignedT unsignedValue = static_cast<UnsignedT>(value);
>+ while (unsignedValue >>= 1)
>+ ++result;
>+ return result;
>+}
>+
> } // namespace WTF
> 
> using WTF::opaque;
>diff --git a/Source/WTF/wtf/Packed.h b/Source/WTF/wtf/Packed.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..a83a2087cfb94a33eae9890c21e2ebcce378a9a8
>--- /dev/null
>+++ b/Source/WTF/wtf/Packed.h
>@@ -0,0 +1,229 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ * notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ * notice, this list of conditions and the following disclaimer in the
>+ * documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include <array>
>+#include <wtf/MathExtras.h>
>+#include <wtf/StdLibExtras.h>
>+#include <wtf/UnalignedAccess.h>
>+
>+namespace WTF {
>+
>+template<typename T>
>+class Packed {
>+public:
>+ static constexpr bool isPackedType = true;
>+
>+ Packed()
>+ : Packed(T { })
>+ {
>+ }
>+
>+ Packed(const T& value)
>+ {
>+ unalignedStore<T>(m_storage.data(), value);
>+ }
>+
>+ T get() const
>+ {
>+ return unalignedLoad<T>(m_storage.data());
>+ }
>+
>+ void set(const T& value)
>+ {
>+ unalignedStore<T>(m_storage.data(), value);
>+ }
>+
>+ Packed<T>& operator=(const T& value)
>+ {
>+ set(value);
>+ return *this;
>+ }
>+
>+ template<class U>
>+ T exchange(U&& newValue)
>+ {
>+ T oldValue = get();
>+ set(std::forward(newValue));
>+ return oldValue;
>+ }
>+
>+ void swap(Packed& other)
>+ {
>+ m_storage.swap(other.m_storage);
>+ }
>+
>+ template<typename Other, typename = std::enable_if_t<Other::isPackedType>>
>+ void swap(Other& other)
>+ {
>+ T t1 = get();
>+ T t2 = other.get();
>+ std::swap(t1, t2);
>+ set(t1);
>+ other.set(t2);
>+ }
>+
>+ void swap(T& t2)
>+ {
>+ T t1 = get();
>+ std::swap(t1, t2);
>+ set(t1);
>+ }
>+
>+private:
>+ std::array<uint8_t, sizeof(T)> m_storage;
>+};
>+
>+template<typename T, size_t alignment = alignof(T)>
>+class PackedAlignedPtr {
>+public:
>+ static constexpr bool isPackedType = true;
>+ static constexpr unsigned alignmentShiftSizeIfEffective = getLSBSetConstexpr(hasOneBitSet(alignment) ? alignment : (roundUpToPowerOfTwo(alignment) >> 1));
>+ static constexpr unsigned storageSizeWithoutAlignmentShift = roundUpToMultipleOf<8>(WTF_CPU_EFFECTIVE_ADDRESS_WIDTH) / 8;
>+ static constexpr unsigned storageSizeWithAlignmentShift = roundUpToMultipleOf<8>(WTF_CPU_EFFECTIVE_ADDRESS_WIDTH - alignmentShiftSizeIfEffective) / 8;
>+ static constexpr bool isAlignmentShiftEffective = storageSizeWithoutAlignmentShift > storageSizeWithAlignmentShift;
>+ static constexpr unsigned alignmentShiftSize = isAlignmentShiftEffective ? alignmentShiftSizeIfEffective : 0;
>+ static constexpr unsigned storageSize = storageSizeWithAlignmentShift;
>+
>+ constexpr PackedAlignedPtr()
>+ : m_storage()
>+ {
>+ }
>+
>+ constexpr PackedAlignedPtr(std::nullptr_t)
>+ : m_storage()
>+ {
>+ }
>+
>+ PackedAlignedPtr(T* value)
>+ {
>+ set(value);
>+ }
>+
>+ T* get() const
>+ {
>+ uintptr_t value = 0;
>+#if CPU(LITTLE_ENDIAN)
>+ memcpy(&value, m_storage.data(), storageSize);
>+#else
>+ memcpy(bitwise_cast<uint8_t*>(&value) + (sizeof(void*) - storageSize), m_storage.data(), storageSize);
>+#endif
>+ if (isAlignmentShiftEffective)
>+ value <<= alignmentShiftSize;
>+ return bitwise_cast<T*>(value);
>+ }
>+
>+ void set(T* passedValue)
>+ {
>+ uintptr_t value = bitwise_cast<uintptr_t>(passedValue);
>+ if (isAlignmentShiftEffective)
>+ value >>= alignmentShiftSize;
>+#if CPU(LITTLE_ENDIAN)
>+ memcpy(m_storage.data(), &value, storageSize);
>+#else
>+ memcpy(m_storage.data(), bitwise_cast<uint8_t*>(&value) + (sizeof(void*) - storageSize));
>+#endif
>+ }
>+
>+ void clear()
>+ {
>+ set(nullptr);
>+ }
>+
>+ T* operator->() const { return get(); }
>+ T& operator*() const { return *get(); }
>+ bool operator!() const { return !get(); }
>+
>+ PackedAlignedPtr& operator=(T* value)
>+ {
>+ set(value);
>+ return *this;
>+ }
>+
>+ template<class U>
>+ T exchange(U&& newValue)
>+ {
>+ T oldValue = get();
>+ set(std::forward(newValue));
>+ return oldValue;
>+ }
>+
>+ void swap(std::nullptr_t) { clear(); }
>+
>+ void swap(PackedAlignedPtr& other)
>+ {
>+ m_storage.swap(other.m_storage);
>+ }
>+
>+ template<typename Other, typename = std::enable_if_t<Other::isPackedType>>
>+ void swap(Other& other)
>+ {
>+ T t1 = get();
>+ T t2 = other.get();
>+ std::swap(t1, t2);
>+ set(t1);
>+ other.set(t2);
>+ }
>+
>+ void swap(T& t2)
>+ {
>+ T t1 = get();
>+ std::swap(t1, t2);
>+ set(t1);
>+ }
>+
>+private:
>+ std::array<uint8_t, storageSize> m_storage;
>+};
>+
>+template<typename T>
>+class Packed<T*> : public PackedAlignedPtr<T, 1> {
>+public:
>+ using Base = PackedAlignedPtr<T, 1>;
>+ using Base::Base;
>+};
>+
>+template<typename T>
>+using PackedPtr = Packed<T*>;
>+
>+template<typename T>
>+struct PackedPtrTraits {
>+ template<typename U> using RebindTraits = PackedPtrTraits;
>+
>+ using StorageType = PackedPtr<T>;
>+
>+ template<class U> static ALWAYS_INLINE T* exchange(StorageType& ptr, U&& newValue) { return ptr.exchange(newValue); }
>+
>+ template<typename Other> static ALWAYS_INLINE void swap(PackedPtr<T>& a, Other& b) { a.swap(b); }
>+
>+ static ALWAYS_INLINE T* unwrap(const StorageType& ptr) { return ptr.get(); }
>+};
>+
>+} // namespace WTF
>+
>+using WTF::Packed;
>+using WTF::PackedAlignedPtr;
>+using WTF::PackedPtr;
>diff --git a/Source/WTF/wtf/Platform.h b/Source/WTF/wtf/Platform.h
>index 6e5e02f6fcfede0fd014cd98267436cbe552dfec..623a8aba4a0b56bfea04b419653ee77b6cd971f3 100644
>--- a/Source/WTF/wtf/Platform.h
>+++ b/Source/WTF/wtf/Platform.h
>@@ -352,6 +352,17 @@
> #endif
> #endif
> 
>+#if CPU(ADDRESS64)
>+#if OS(DARWIN) && CPU(ARM64)
>+#define WTF_CPU_EFFECTIVE_ADDRESS_WIDTH 36
>+#else
>+/* We strongly assume that effective address width is <= 48 in 64bit architectures (e.g. NaN boxing). */
>+#define WTF_CPU_EFFECTIVE_ADDRESS_WIDTH 48
>+#endif
>+#else
>+#define WTF_CPU_EFFECTIVE_ADDRESS_WIDTH 32
>+#endif
>+
> /* ==== OS() - underlying operating system; only to be used for mandated low-level services like 
> virtual memory, not to choose a GUI toolkit ==== */
> 
>diff --git a/Source/WTF/wtf/SentinelLinkedList.h b/Source/WTF/wtf/SentinelLinkedList.h
>index ce79890f6fe3897ee0e2da89d23e07fdddd1c28e..75b467a09fa04c01077d65b77055a96b87f2ae6a 100644
>--- a/Source/WTF/wtf/SentinelLinkedList.h
>+++ b/Source/WTF/wtf/SentinelLinkedList.h
>@@ -36,31 +36,29 @@
> 
> #pragma once
> 
>+#include <wtf/Packed.h>
>+
> namespace WTF {
> 
> enum SentinelTag { Sentinel };
> 
>-template<typename T>
>+template<typename T, typename PassedPtrTraits = DumbPtrTraits<T>>
> class BasicRawSentinelNode {
> WTF_MAKE_FAST_ALLOCATED;
> public:
>+ using PtrTraits = typename PassedPtrTraits::template RebindTraits<BasicRawSentinelNode>;
>+
> BasicRawSentinelNode(SentinelTag)
>- : m_next(0)
>- , m_prev(0)
> {
> }
> 
>- BasicRawSentinelNode()
>- : m_next(0)
>- , m_prev(0)
>- {
>- }
>+ BasicRawSentinelNode() = default;
> 
> void setPrev(BasicRawSentinelNode* prev) { m_prev = prev; }
> void setNext(BasicRawSentinelNode* next) { m_next = next; }
> 
>- T* prev() { return static_cast<T*>(m_prev); }
>- T* next() { return static_cast<T*>(m_next); }
>+ T* prev() { return static_cast<T*>(PtrTraits::unwrap(m_prev)); }
>+ T* next() { return static_cast<T*>(PtrTraits::unwrap(m_next)); }
> 
> bool isOnList() const
> {
>@@ -74,8 +72,8 @@ class BasicRawSentinelNode {
> void append(BasicRawSentinelNode*);
> 
> private:
>- BasicRawSentinelNode* m_next;
>- BasicRawSentinelNode* m_prev;
>+ typename PtrTraits::StorageType m_next { nullptr };
>+ typename PtrTraits::StorageType m_prev { nullptr };
> };
> 
> template <typename T, typename RawNode = T> class SentinelLinkedList {
>@@ -118,20 +116,20 @@ template <typename T, typename RawNode = T> class SentinelLinkedList {
> RawNode m_tailSentinel;
> };
> 
>-template <typename T> void BasicRawSentinelNode<T>::remove()
>+template <typename T, typename PtrTraits> void BasicRawSentinelNode<T, PtrTraits>::remove()
> {
>- SentinelLinkedList<T, BasicRawSentinelNode<T>>::remove(static_cast<T*>(this));
>+ SentinelLinkedList<T, BasicRawSentinelNode>::remove(static_cast<T*>(this));
> }
> 
>-template <typename T> void BasicRawSentinelNode<T>::prepend(BasicRawSentinelNode* node)
>+template <typename T, typename PtrTraits> void BasicRawSentinelNode<T, PtrTraits>::prepend(BasicRawSentinelNode* node)
> {
>- SentinelLinkedList<T, BasicRawSentinelNode<T>>::prepend(
>+ SentinelLinkedList<T, BasicRawSentinelNode>::prepend(
> static_cast<T*>(this), static_cast<T*>(node));
> }
> 
>-template <typename T> void BasicRawSentinelNode<T>::append(BasicRawSentinelNode* node)
>+template <typename T, typename PtrTraits> void BasicRawSentinelNode<T, PtrTraits>::append(BasicRawSentinelNode* node)
> {
>- SentinelLinkedList<T, BasicRawSentinelNode<T>>::append(
>+ SentinelLinkedList<T, BasicRawSentinelNode>::append(
> static_cast<T*>(this), static_cast<T*>(node));
> }
> 
>@@ -140,10 +138,10 @@ template <typename T, typename RawNode> inline SentinelLinkedList<T, RawNode>::S
> , m_tailSentinel(Sentinel)
> {
> m_headSentinel.setNext(&m_tailSentinel);
>- m_headSentinel.setPrev(0);
>+ m_headSentinel.setPrev(nullptr);
> 
> m_tailSentinel.setPrev(&m_headSentinel);
>- m_tailSentinel.setNext(0);
>+ m_tailSentinel.setNext(nullptr);
> }
> 
> template <typename T, typename RawNode> inline typename SentinelLinkedList<T, RawNode>::iterator SentinelLinkedList<T, RawNode>::begin()
>@@ -200,8 +198,8 @@ template <typename T, typename RawNode> inline void SentinelLinkedList<T, RawNod
> prev->setNext(next);
> next->setPrev(prev);
> 
>- node->setPrev(0);
>- node->setNext(0);
>+ node->setPrev(nullptr);
>+ node->setNext(nullptr);
> }
> 
> template <typename T, typename RawNode>
>@@ -271,7 +269,11 @@ inline void SentinelLinkedList<T, RawNode>::takeFrom(SentinelLinkedList<T, RawNo
> other.m_tailSentinel.setPrev(&other.m_headSentinel);
> }
> 
>+template<typename T>
>+using PackedRawSentinelNode = BasicRawSentinelNode<T, PackedPtrTraits<T>>;
>+
> }
> 
> using WTF::BasicRawSentinelNode;
>+using WTF::PackedRawSentinelNode;
> using WTF::SentinelLinkedList;
>diff --git a/Source/WTF/wtf/StdLibExtras.h b/Source/WTF/wtf/StdLibExtras.h
>index 35ec44eb7ec9724aa1c59ecd280e4d6cdbcd3670..9de1b9f877370ef62784d13663dec82e246a868d 100644
>--- a/Source/WTF/wtf/StdLibExtras.h
>+++ b/Source/WTF/wtf/StdLibExtras.h
>@@ -172,14 +172,10 @@ template<typename T> char (&ArrayLengthHelperFunction(T (&)[0]))[0];
> #endif
> #define WTF_ARRAY_LENGTH(array) sizeof(::WTF::ArrayLengthHelperFunction(array))
> 
>-ALWAYS_INLINE constexpr size_t roundUpToMultipleOfImpl0(size_t remainderMask, size_t x)
>-{
>- return (x + remainderMask) & ~remainderMask;
>-}
>-
> ALWAYS_INLINE constexpr size_t roundUpToMultipleOfImpl(size_t divisor, size_t x)
> {
>- return roundUpToMultipleOfImpl0(divisor - 1, x);
>+ size_t remainderMask = divisor - 1;
>+ return (x + remainderMask) & ~remainderMask;
> }
> 
> // Efficient implementation that takes advantage of powers of two.
>@@ -201,6 +197,29 @@ template<size_t divisor, typename T> inline T* roundUpToMultipleOf(T* x)
> return reinterpret_cast<T*>(roundUpToMultipleOf<divisor>(reinterpret_cast<size_t>(x)));
> }
> 
>+ALWAYS_INLINE constexpr size_t roundDownToMultipleOfImpl(size_t divisor, size_t x)
>+{
>+ return x & ~(divisor - 1);
>+}
>+
>+inline size_t roundDownToMultipleOf(size_t divisor, size_t x)
>+{
>+ ASSERT(divisor && !(divisor & (divisor - 1)));
>+ return roundDownToMultipleOfImpl(divisor, x);
>+}
>+
>+template<size_t divisor> constexpr size_t roundDownToMultipleOf(size_t x)
>+{
>+ static_assert(divisor && !(divisor & (divisor - 1)), "divisor must be a power of two!");
>+ return roundDownToMultipleOfImpl(divisor, x);
>+}
>+
>+template<size_t divisor, typename T> inline T* roundDownToMultipleOf(T* x)
>+{
>+ static_assert(sizeof(T*) == sizeof(size_t), "");
>+ return reinterpret_cast<T*>(roundDownToMultipleOf<divisor>(reinterpret_cast<size_t>(x)));
>+}
>+
> enum BinarySearchMode {
> KeyMustBePresentInArray,
> KeyMightNotBePresentInArray,
>@@ -587,5 +606,6 @@ using WTF::isStatelessLambda;
> using WTF::is8ByteAligned;
> using WTF::mergeDeduplicatedSorted;
> using WTF::roundUpToMultipleOf;
>+using WTF::roundDownToMultipleOf;
> using WTF::safeCast;
> using WTF::tryBinarySearch;

Actions: View | Formatted Diff | Diff

Attachments on bug 197730: 369460 | 369461 | 369465 | 369466 | 369467 | 369468 | 369471 | 369472 | 369474 | 369475 | 369477 | 369492 | 369518 | 369520 | 369522 | 369618 | 369619 | 369627