[JSC] Use FixedVector in JITConstantPool

ysuzuki@apple.com · ysuzuki@apple.com · commit 2e87117fc944 · 2021-09-29T16:44:10.000Z
https://bugs.webkit.org/show_bug.cgi?id=230937 Reviewed by Keith Miller. This patch changes JITConstantPool to use FixedVector. This allocates exact size of memory and Making sizeof(JITConstantPool) smaller. We also use CompactPointerTuple for JITConstantPool::Value since it is faster for access. To achieve that, in JIT, we append Value to normal Vector. And when finalizing BaselineJITCode we construct JITConstantPool from that Vector. * bytecode/CodeBlock.cpp: (JSC::CodeBlock::setupWithUnlinkedBaselineCode): * jit/BaselineJITCode.h: (JSC::JITConstantPool::JITConstantPool): (JSC::JITConstantPool::add): Deleted. * jit/JIT.cpp: (JSC::JIT::JIT): (JSC::JIT::addToConstantPool): * jit/JIT.h: * jit/JITCall.cpp: (JSC::JIT::compileOpCall): (JSC::JIT::emit_op_iterator_open): (JSC::JIT::emit_op_iterator_next): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): (JSC::JIT::emitNewFuncCommon): (JSC::JIT::emitNewFuncExprCommon): * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emit_op_get_private_name): (JSC::JIT::emit_op_set_private_brand): (JSC::JIT::emit_op_check_private_brand): (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emit_op_put_private_name): (JSC::JIT::emit_op_del_by_id): (JSC::JIT::emit_op_del_by_val): (JSC::JIT::emit_op_try_get_by_id): (JSC::JIT::emit_op_get_by_id_direct): (JSC::JIT::emit_op_get_by_id): (JSC::JIT::emit_op_get_by_id_with_this): (JSC::JIT::emit_op_put_by_id): (JSC::JIT::emit_op_in_by_id): (JSC::JIT::emit_op_in_by_val): (JSC::JIT::emitHasPrivate): (JSC::JIT::emit_op_enumerator_get_by_val): git-svn-id: http://svn.webkit.org/repository/webkit/trunk@283229 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,53 @@
+2021-09-29  Yusuke Suzuki  <ysuzuki@apple.com>
+
+        [JSC] Use FixedVector in JITConstantPool
+        https://bugs.webkit.org/show_bug.cgi?id=230937
+
+        Reviewed by Keith Miller.
+
+        This patch changes JITConstantPool to use FixedVector. This allocates exact size
+        of memory and Making sizeof(JITConstantPool) smaller. We also use CompactPointerTuple
+        for JITConstantPool::Value since it is faster for access.
+
+        To achieve that, in JIT, we append Value to normal Vector. And when finalizing BaselineJITCode
+        we construct JITConstantPool from that Vector.
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::setupWithUnlinkedBaselineCode):
+        * jit/BaselineJITCode.h:
+        (JSC::JITConstantPool::JITConstantPool):
+        (JSC::JITConstantPool::add): Deleted.
+        * jit/JIT.cpp:
+        (JSC::JIT::JIT):
+        (JSC::JIT::addToConstantPool):
+        * jit/JIT.h:
+        * jit/JITCall.cpp:
+        (JSC::JIT::compileOpCall):
+        (JSC::JIT::emit_op_iterator_open):
+        (JSC::JIT::emit_op_iterator_next):
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_instanceof):
+        (JSC::JIT::emitNewFuncCommon):
+        (JSC::JIT::emitNewFuncExprCommon):
+        * jit/JITPropertyAccess.cpp:
+        (JSC::JIT::emit_op_get_by_val):
+        (JSC::JIT::emit_op_get_private_name):
+        (JSC::JIT::emit_op_set_private_brand):
+        (JSC::JIT::emit_op_check_private_brand):
+        (JSC::JIT::emit_op_put_by_val):
+        (JSC::JIT::emit_op_put_private_name):
+        (JSC::JIT::emit_op_del_by_id):
+        (JSC::JIT::emit_op_del_by_val):
+        (JSC::JIT::emit_op_try_get_by_id):
+        (JSC::JIT::emit_op_get_by_id_direct):
+        (JSC::JIT::emit_op_get_by_id):
+        (JSC::JIT::emit_op_get_by_id_with_this):
+        (JSC::JIT::emit_op_put_by_id):
+        (JSC::JIT::emit_op_in_by_id):
+        (JSC::JIT::emit_op_in_by_val):
+        (JSC::JIT::emitHasPrivate):
+        (JSC::JIT::emit_op_enumerator_get_by_val):
+
 2021-09-28  Saam Barati  <sbarati@apple.com>
 
         DoesGCCheck does not use enough bits for nodeIndex
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
@@ -805,31 +805,31 @@ void CodeBlock::setupWithUnlinkedBaselineCode(Ref<BaselineJITCode> jitCode)
         jitData.m_jitConstantPool = FixedVector<void*>(jitCode->m_constantPool.size());
         for (size_t i = 0; i < jitCode->m_constantPool.size(); ++i) {
             auto entry = jitCode->m_constantPool.at(i);
-            switch (entry.type) {
+            switch (entry.type()) {
             case JITConstantPool::Type::GlobalObject:
                 jitData.m_jitConstantPool[i] = m_globalObject.get();
                 break;
             case JITConstantPool::Type::CallLinkInfo: {
-                UnlinkedCallLinkInfo& unlinkedCallLinkInfo = *static_cast<UnlinkedCallLinkInfo*>(entry.payload.get());
+                UnlinkedCallLinkInfo& unlinkedCallLinkInfo = *static_cast<UnlinkedCallLinkInfo*>(entry.pointer());
                 CallLinkInfo* callLinkInfo = jitData.m_callLinkInfos.add(CodeOrigin(unlinkedCallLinkInfo.bytecodeIndex));
                 callLinkInfo->initializeDataIC(vm(), unlinkedCallLinkInfo, GPRInfo::regT0, GPRInfo::regT2);
                 jitData.m_jitConstantPool[i] = callLinkInfo;
                 break;
             }
             case JITConstantPool::Type::StructureStubInfo: {
-                UnlinkedStructureStubInfo& unlinkedStubInfo = *static_cast<UnlinkedStructureStubInfo*>(entry.payload.get());
+                UnlinkedStructureStubInfo& unlinkedStubInfo = *static_cast<UnlinkedStructureStubInfo*>(entry.pointer());
                 StructureStubInfo* stubInfo = jitData.m_stubInfos.add(unlinkedStubInfo.accessType, CodeOrigin(unlinkedStubInfo.bytecodeIndex));
                 stubInfo->initializeFromUnlinkedStructureStubInfo(this, unlinkedStubInfo);
                 jitData.m_jitConstantPool[i] = stubInfo;
                 break;
             }
             case JITConstantPool::Type::FunctionDecl: {
-                unsigned index = bitwise_cast<uintptr_t>(entry.payload.get());
+                unsigned index = bitwise_cast<uintptr_t>(entry.pointer());
                 jitData.m_jitConstantPool[i] = functionDecl(index);
                 break;
             }
             case JITConstantPool::Type::FunctionExpr: {
-                unsigned index = bitwise_cast<uintptr_t>(entry.payload.get());
+                unsigned index = bitwise_cast<uintptr_t>(entry.pointer());
                 jitData.m_jitConstantPool[i] = functionExpr(index);
                 break;
             }
diff --git a/Source/JavaScriptCore/jit/BaselineJITCode.h b/Source/JavaScriptCore/jit/BaselineJITCode.h
@@ -28,6 +28,7 @@
 #include "CallLinkInfo.h"
 #include "JITCode.h"
 #include "JITCodeMap.h"
+#include <wtf/CompactPointerTuple.h>
 
 #if ENABLE(JIT)
 
@@ -55,6 +56,7 @@ class MathICHolder {
 };
 
 class JITConstantPool {
+    WTF_MAKE_NONCOPYABLE(JITConstantPool);
 public:
     using Constant = unsigned;
 
@@ -66,27 +68,22 @@ class JITConstantPool {
         FunctionExpr,
     };
 
-    struct Value {
-        Type type;
-        PackedPtr<void> payload;
-    };
+    using Value = CompactPointerTuple<void*, Type>;
 
     JITConstantPool() = default;
     JITConstantPool(JITConstantPool&&) = default;
     JITConstantPool& operator=(JITConstantPool&&) = default;
 
-    Constant add(Type type, void* payload = nullptr)
+    JITConstantPool(Vector<Value>&& constants)
+        : m_constants(WTFMove(constants))
     {
-        unsigned result = m_constants.size();
-        m_constants.append(Value { type, payload });
-        return result;
     }
 
     size_t size() const { return m_constants.size(); }
     Value at(size_t i) const { return m_constants[i]; }
 
 private:
-    Vector<Value> m_constants;
+    FixedVector<Value> m_constants;
 };
 
 
diff --git a/Source/JavaScriptCore/jit/JIT.cpp b/Source/JavaScriptCore/jit/JIT.cpp
@@ -77,7 +77,7 @@ JIT::JIT(VM& vm, CodeBlock* codeBlock, BytecodeIndex loopOSREntryBytecodeIndex)
     , m_shouldEmitProfiling(false)
     , m_loopOSREntryBytecodeIndex(loopOSREntryBytecodeIndex)
 {
-    m_globalObjectConstant = m_constantPool.add(JITConstantPool::Type::GlobalObject);
+    m_globalObjectConstant = addToConstantPool(JITConstantPool::Type::GlobalObject);
     m_profiledCodeBlock = codeBlock;
     m_unlinkedCodeBlock = codeBlock->unlinkedCodeBlock();
 }
@@ -86,6 +86,13 @@ JIT::~JIT()
 {
 }
 
+JITConstantPool::Constant JIT::addToConstantPool(JITConstantPool::Type type, void* payload)
+{
+    unsigned result = m_constantPool.size();
+    m_constantPool.append(JITConstantPool::Value { payload, type });
+    return result;
+}
+
 #if ENABLE(DFG_JIT)
 void JIT::emitEnterOptimizationCheck()
 {
diff --git a/Source/JavaScriptCore/jit/JIT.h b/Source/JavaScriptCore/jit/JIT.h
@@ -973,6 +973,8 @@ namespace JSC {
 
         void resetSP();
 
+        JITConstantPool::Constant addToConstantPool(JITConstantPool::Type, void* payload = nullptr);
+
         Interpreter* m_interpreter;
 
         Vector<FarCallRecord> m_farCalls;
@@ -1040,7 +1042,7 @@ namespace JSC {
         MathICHolder m_mathICs;
         RefPtr<BaselineJITCode> m_jitCode;
 
-        JITConstantPool m_constantPool;
+        Vector<JITConstantPool::Value> m_constantPool;
         JITConstantPool::Constant m_globalObjectConstant { std::numeric_limits<unsigned>::max() };
         Bag<UnlinkedCallLinkInfo> m_unlinkedCalls;
         Bag<CallLinkInfo> m_evalCallLinkInfos;
diff --git a/Source/JavaScriptCore/jit/JITCall.cpp b/Source/JavaScriptCore/jit/JITCall.cpp
@@ -233,7 +233,7 @@ void JIT::compileOpCall(const Instruction* instruction, unsigned callLinkInfoInd
         info->bytecodeIndex = m_bytecodeIndex;
         info->callType = CallLinkInfo::callTypeFor(opcodeID);
 
-        infoConstant = m_constantPool.add(JITConstantPool::Type::CallLinkInfo, info);
+        infoConstant = addToConstantPool(JITConstantPool::Type::CallLinkInfo, info);
 
         ASSERT(m_callCompilationInfo.size() == callLinkInfoIndex);
         m_callCompilationInfo.append(CallCompilationInfo());
@@ -421,7 +421,7 @@ void JIT::emit_op_iterator_open(const Instruction* instruction)
     UnlinkedStructureStubInfo* stubInfo = m_unlinkedStubInfos.add();
     stubInfo->accessType = AccessType::GetById;
     stubInfo->bytecodeIndex = m_bytecodeIndex;
-    JITConstantPool::Constant stubInfoIndex = m_constantPool.add(JITConstantPool::Type::StructureStubInfo, stubInfo);
+    JITConstantPool::Constant stubInfoIndex = addToConstantPool(JITConstantPool::Type::StructureStubInfo, stubInfo);
     gen.m_unlinkedStubInfoConstantIndex = stubInfoIndex;
     gen.m_unlinkedStubInfo = stubInfo;
 
@@ -518,7 +518,7 @@ void JIT::emit_op_iterator_next(const Instruction* instruction)
         UnlinkedStructureStubInfo* stubInfo = m_unlinkedStubInfos.add();
         stubInfo->accessType = AccessType::GetById;
         stubInfo->bytecodeIndex = m_bytecodeIndex;
-        JITConstantPool::Constant stubInfoIndex = m_constantPool.add(JITConstantPool::Type::StructureStubInfo, stubInfo);
+        JITConstantPool::Constant stubInfoIndex = addToConstantPool(JITConstantPool::Type::StructureStubInfo, stubInfo);
         gen.m_unlinkedStubInfoConstantIndex = stubInfoIndex;
         gen.m_unlinkedStubInfo = stubInfo;
 
@@ -553,7 +553,7 @@ void JIT::emit_op_iterator_next(const Instruction* instruction)
         UnlinkedStructureStubInfo* stubInfo = m_unlinkedStubInfos.add();
         stubInfo->accessType = AccessType::GetById;
         stubInfo->bytecodeIndex = m_bytecodeIndex;
-        JITConstantPool::Constant stubInfoIndex = m_constantPool.add(JITConstantPool::Type::StructureStubInfo, stubInfo);
+        JITConstantPool::Constant stubInfoIndex = addToConstantPool(JITConstantPool::Type::StructureStubInfo, stubInfo);
         gen.m_unlinkedStubInfoConstantIndex = stubInfoIndex;
         gen.m_unlinkedStubInfo = stubInfo;
 
diff --git a/Source/JavaScriptCore/jit/JITOpcodes.cpp b/Source/JavaScriptCore/jit/JITOpcodes.cpp
@@ -180,7 +180,7 @@ void JIT::emit_op_instanceof(const Instruction* currentInstruction)
     UnlinkedStructureStubInfo* stubInfo = m_unlinkedStubInfos.add();
     stubInfo->accessType = AccessType::InstanceOf;
     stubInfo->bytecodeIndex = m_bytecodeIndex;
-    JITConstantPool::Constant stubInfoIndex = m_constantPool.add(JITConstantPool::Type::StructureStubInfo, stubInfo);
+    JITConstantPool::Constant stubInfoIndex = addToConstantPool(JITConstantPool::Type::StructureStubInfo, stubInfo);
     gen.m_unlinkedStubInfoConstantIndex = stubInfoIndex;
     gen.m_unlinkedStubInfo = stubInfo;
 
@@ -1612,7 +1612,7 @@ void JIT::emitNewFuncCommon(const Instruction* currentInstruction)
 #else
     emitLoadPayload(bytecode.m_scope, argumentGPR1);
 #endif
-    auto constant = m_constantPool.add(JITConstantPool::Type::FunctionDecl, bitwise_cast<void*>(static_cast<uintptr_t>(bytecode.m_functionDecl)));
+    auto constant = addToConstantPool(JITConstantPool::Type::FunctionDecl, bitwise_cast<void*>(static_cast<uintptr_t>(bytecode.m_functionDecl)));
     loadConstant(constant, argumentGPR2);
 
     OpcodeID opcodeID = Op::opcodeID;
@@ -1659,7 +1659,7 @@ void JIT::emitNewFuncExprCommon(const Instruction* currentInstruction)
     emitLoadPayload(bytecode.m_scope, argumentGPR1);
 #endif
 
-    auto constant = m_constantPool.add(JITConstantPool::Type::FunctionExpr, bitwise_cast<void*>(static_cast<uintptr_t>(bytecode.m_functionDecl)));
+    auto constant = addToConstantPool(JITConstantPool::Type::FunctionExpr, bitwise_cast<void*>(static_cast<uintptr_t>(bytecode.m_functionDecl)));
     loadConstant(constant, argumentGPR2);
     OpcodeID opcodeID = Op::opcodeID;
 
diff --git a/Source/JavaScriptCore/jit/JITPropertyAccess.cpp b/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ JIT::JIT(VM& vm, CodeBlock* codeBlock, BytecodeIndex loopOSREntryBytecodeIndex)`
`77`	`77`	`, m_shouldEmitProfiling(false)`
`78`	`78`	`, m_loopOSREntryBytecodeIndex(loopOSREntryBytecodeIndex)`
`79`	`79`	`{`
`80`		`- m_globalObjectConstant = m_constantPool.add(JITConstantPool::Type::GlobalObject);`
	`80`	`+ m_globalObjectConstant = addToConstantPool(JITConstantPool::Type::GlobalObject);`
`81`	`81`	`m_profiledCodeBlock = codeBlock;`
`82`	`82`	`m_unlinkedCodeBlock = codeBlock->unlinkedCodeBlock();`
`83`	`83`	`}`
`@@ -86,6 +86,13 @@ JIT::~JIT()`
`86`	`86`	`{`
`87`	`87`	`}`
`88`	`88`
	`89`	`+JITConstantPool::Constant JIT::addToConstantPool(JITConstantPool::Type type, void* payload)`
	`90`	`+{`
	`91`	`+ unsigned result = m_constantPool.size();`
	`92`	`+ m_constantPool.append(JITConstantPool::Value { payload, type });`
	`93`	`+ return result;`
	`94`	`+}`
	`95`	`+`
`89`	`96`	`#if ENABLE(DFG_JIT)`
`90`	`97`	`void JIT::emitEnterOptimizationCheck()`
`91`	`98`	`{`