Diff
Modified: trunk/Source/_javascript_Core/ChangeLog (287595 => 287596)
--- trunk/Source/_javascript_Core/ChangeLog 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/ChangeLog 2022-01-05 00:20:42 UTC (rev 287596)
@@ -1,3 +1,109 @@
+2022-01-04 Yusuke Suzuki <[email protected]>
+
+ [JSC] Remove m_calleeSaveRegisters from CodeBlock::JITData and rename it to BaselineJITData
+ https://bugs.webkit.org/show_bug.cgi?id=234555
+
+ Reviewed by Saam Barati.
+
+ This patch removes m_calleeSaveRegisters from CodeBlock::JITData, and moving it to each JITCode.
+ This is reasonable since m_calleeSaveRegisters information belongs to JITCode, not CodeBlock.
+ And in LLInt, Baseline, and DFG cases, m_calleeSaveRegisters is the same. So we do not have this
+ field in these JITCode. Only FTL can have m_calleeSaveRegisters.
+
+ By removing m_calleeSaveRegisters from CodeBlock::JITData, now it only includes Baseline JIT related
+ data. So this patch renames CodeBlock::JITData to BaselineJITData.
+
+ We also use TrailingArray for BaselineJITData so that we can remove one level indirection when loading
+ JITConstantPool from JITData.
+
+ * bytecode/CodeBlock.cpp:
+ (JSC::CodeBlock::setupWithUnlinkedBaselineCode):
+ (JSC::CodeBlock::~CodeBlock):
+ (JSC::CodeBlock::propagateTransitions):
+ (JSC::CodeBlock::finalizeJITInlineCaches):
+ (JSC::CodeBlock::getICStatusMap):
+ (JSC::CodeBlock::findStubInfo):
+ (JSC::CodeBlock::resetBaselineJITData):
+ (JSC::CodeBlock::stronglyVisitStrongReferences):
+ (JSC::CodeBlock::calleeSaveSpaceAsVirtualRegisters):
+ (JSC::CodeBlock::findPC):
+ (JSC::CodeBlock::ensureJITDataSlow): Deleted.
+ (JSC::CodeBlock::setCalleeSaveRegisters): Deleted.
+ (JSC::CodeBlock::resetJITData): Deleted.
+ (JSC::CodeBlock::calleeSaveRegisters const): Deleted.
+ * bytecode/CodeBlock.h:
+ (JSC::CodeBlock::offsetOfBaselineJITData):
+ (JSC::CodeBlock::baselineJITData):
+ (JSC::CodeBlock::calleeSaveSpaceAsVirtualRegisters):
+ (JSC::CodeBlock::JITData::offsetOfJITConstantPool): Deleted.
+ (JSC::CodeBlock::ensureJITData): Deleted.
+ (JSC::CodeBlock::offsetOfJITData): Deleted.
+ (JSC::CodeBlock::baselineJITConstantPool): Deleted.
+ * bytecode/Repatch.cpp:
+ (JSC::linkPolymorphicCall):
+ * dfg/DFGJITCompiler.h:
+ (JSC::DFG::JITCompiler::emitRestoreCalleeSaves):
+ (JSC::DFG::JITCompiler::emitSaveCalleeSaves):
+ * dfg/DFGOSREntry.cpp:
+ (JSC::DFG::prepareOSREntry):
+ * dfg/DFGOSRExit.cpp:
+ (JSC::DFG::OSRExit::compileExit):
+ * dfg/DFGOSRExitCompilerCommon.cpp:
+ (JSC::DFG::calleeSaveSlot):
+ (JSC::DFG::reifyInlinedCallFrames):
+ (JSC::DFG::adjustAndJumpToTarget):
+ * dfg/DFGPlan.cpp:
+ (JSC::DFG::Plan::compileInThreadImpl):
+ * dfg/DFGSpeculativeJIT32_64.cpp:
+ (JSC::DFG::SpeculativeJIT::emitCall):
+ * dfg/DFGSpeculativeJIT64.cpp:
+ (JSC::DFG::SpeculativeJIT::emitCall):
+ * dfg/DFGStackLayoutPhase.cpp:
+ (JSC::DFG::StackLayoutPhase::run):
+ * ftl/FTLCompile.cpp:
+ (JSC::FTL::compile):
+ * ftl/FTLJITCode.h:
+ (JSC::FTL::JITCode::calleeSaveRegisters const):
+ * ftl/FTLLowerDFGToB3.cpp:
+ (JSC::FTL::DFG::LowerDFGToB3::compileCompareStrictEq):
+ * ftl/FTLOSRExitCompiler.cpp:
+ (JSC::FTL::compileStub):
+ * interpreter/StackVisitor.cpp:
+ (JSC::StackVisitor::Frame::calleeSaveRegistersForUnwinding):
+ * jit/AssemblyHelpers.cpp:
+ (JSC::AssemblyHelpers::executableFor):
+ (JSC::AssemblyHelpers::emitSaveOrCopyLLIntBaselineCalleeSavesFor):
+ * jit/AssemblyHelpers.h:
+ (JSC::AssemblyHelpers::emitSaveThenMaterializeTagRegisters):
+ (JSC::AssemblyHelpers::emitSaveCalleeSavesFor): Deleted.
+ (JSC::AssemblyHelpers::emitRestoreCalleeSavesFor): Deleted.
+ (JSC::AssemblyHelpers::emitSaveCalleeSaves): Deleted.
+ (JSC::AssemblyHelpers::emitRestoreCalleeSaves): Deleted.
+ * jit/BaselineJITCode.h:
+ * jit/CallFrameShuffleData.cpp:
+ * jit/CallFrameShuffleData.h:
+ * jit/JIT.cpp:
+ (JSC::JIT::privateCompileMainPass):
+ (JSC::JIT::emitMaterializeMetadataAndConstantPoolRegisters):
+ (JSC::JIT::emitSaveCalleeSaves):
+ (JSC::JIT::compileAndLinkWithoutFinalizing):
+ * jit/JIT.h:
+ * jit/JITCode.cpp:
+ (JSC::JITCode::calleeSaveRegisters const):
+ * jit/JITCode.h:
+ * jit/JITInlines.h:
+ (JSC::JIT::loadConstant):
+ * jit/JITOpcodes.cpp:
+ (JSC::JIT::emit_op_catch):
+ * jit/RegisterAtOffsetList.cpp:
+ (JSC::RegisterAtOffsetList::dfgCalleeSaveRegisters):
+ * jit/RegisterAtOffsetList.h:
+ * llint/LLIntSlowPaths.cpp:
+ (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+ * llint/LowLevelInterpreter.asm:
+ * tools/VMInspector.cpp:
+ (JSC::VMInspector::dumpRegisters):
+
2022-01-04 Stephan Szabo <[email protected]>
[PlayStation] Fix non-ninja build of zydis
Modified: trunk/Source/_javascript_Core/bytecode/CodeBlock.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/bytecode/CodeBlock.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/bytecode/CodeBlock.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -784,11 +784,9 @@
{
ConcurrentJSLocker locker(m_lock);
- auto& jitData = ensureJITData(locker);
-
- RELEASE_ASSERT(jitData.m_jitConstantPool.isEmpty());
- jitData.m_jitConstantPool = FixedVector<void*>(jitCode->m_constantPool.size());
- jitData.m_stubInfos = FixedVector<StructureStubInfo>(jitCode->m_unlinkedStubInfos.size());
+ ASSERT(!m_baselineJITData);
+ m_baselineJITData = BaselineJITData::create(jitCode->m_constantPool.size());
+ m_baselineJITData->m_stubInfos = FixedVector<StructureStubInfo>(jitCode->m_unlinkedStubInfos.size());
for (auto& unlinkedCallLinkInfo : jitCode->m_unlinkedCalls) {
CallLinkInfo* callLinkInfo = getCallLinkInfoForBytecodeIndex(locker, unlinkedCallLinkInfo.bytecodeIndex);
ASSERT(callLinkInfo);
@@ -799,24 +797,24 @@
auto entry = jitCode->m_constantPool.at(i);
switch (entry.type()) {
case JITConstantPool::Type::GlobalObject:
- jitData.m_jitConstantPool[i] = m_globalObject.get();
+ m_baselineJITData->at(i) = m_globalObject.get();
break;
case JITConstantPool::Type::StructureStubInfo: {
unsigned index = bitwise_cast<uintptr_t>(entry.pointer());
UnlinkedStructureStubInfo& unlinkedStubInfo = jitCode->m_unlinkedStubInfos[index];
- StructureStubInfo& stubInfo = jitData.m_stubInfos[index];
+ StructureStubInfo& stubInfo = m_baselineJITData->m_stubInfos[index];
stubInfo.initializeFromUnlinkedStructureStubInfo(this, unlinkedStubInfo);
- jitData.m_jitConstantPool[i] = &stubInfo;
+ m_baselineJITData->at(i) = &stubInfo;
break;
}
case JITConstantPool::Type::FunctionDecl: {
unsigned index = bitwise_cast<uintptr_t>(entry.pointer());
- jitData.m_jitConstantPool[i] = functionDecl(index);
+ m_baselineJITData->at(i) = functionDecl(index);
break;
}
case JITConstantPool::Type::FunctionExpr: {
unsigned index = bitwise_cast<uintptr_t>(entry.pointer());
- jitData.m_jitConstantPool[i] = functionExpr(index);
+ m_baselineJITData->at(i) = functionExpr(index);
break;
}
}
@@ -905,7 +903,7 @@
// destructors.
#if ENABLE(JIT)
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos) {
stubInfo.aboutToDie();
stubInfo.deref();
@@ -1249,7 +1247,7 @@
#if ENABLE(JIT)
if (JITCode::isJIT(jitType())) {
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos)
stubInfo.propagateTransitions(visitor);
}
@@ -1582,20 +1580,9 @@
}
#if ENABLE(JIT)
-CodeBlock::JITData& CodeBlock::ensureJITDataSlow(const ConcurrentJSLocker&)
-{
- ASSERT(!m_jitData);
- auto jitData = makeUnique<JITData>();
- // calleeSaveRegisters() can access m_jitData without taking a lock from Baseline JIT. This is OK since JITData::m_calleeSaveRegisters is filled in DFG and FTL CodeBlocks.
- // But we should not see garbage pointer in that case. We ensure JITData::m_calleeSaveRegisters is initialized as nullptr before exposing it to BaselineJIT by store-store-fence.
- WTF::storeStoreFence();
- m_jitData = WTFMove(jitData);
- return *m_jitData;
-}
-
void CodeBlock::finalizeJITInlineCaches()
{
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos) {
ConcurrentJSLockerBase locker(NoLockingNecessary);
stubInfo.visitWeakReferences(locker, this);
@@ -1699,7 +1686,7 @@
}
#if ENABLE(JIT)
if (JITCode::isJIT(jitType())) {
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos)
result.add(stubInfo.codeOrigin, ICStatus()).iterator->value.stubInfo = &stubInfo;
}
@@ -1738,7 +1725,7 @@
StructureStubInfo* CodeBlock::findStubInfo(CodeOrigin codeOrigin)
{
ConcurrentJSLocker locker(m_lock);
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos) {
if (stubInfo.codeOrigin == codeOrigin)
return &stubInfo;
@@ -1786,32 +1773,12 @@
return nullptr;
}
-void CodeBlock::setCalleeSaveRegisters(RegisterSet registerSet)
+void CodeBlock::resetBaselineJITData()
{
- auto calleeSaveRegisters = RegisterAtOffsetList(registerSet);
-
- ConcurrentJSLocker locker(m_lock);
- auto& jitData = ensureJITData(locker);
- jitData.m_calleeSaveRegisters = WTFMove(calleeSaveRegisters);
- WTF::storeStoreFence();
- jitData.m_hasCalleeSaveRegisters = true;
-}
-
-void CodeBlock::setCalleeSaveRegisters(RegisterAtOffsetList&& registerAtOffsetList)
-{
- ConcurrentJSLocker locker(m_lock);
- auto& jitData = ensureJITData(locker);
- jitData.m_calleeSaveRegisters = WTFMove(registerAtOffsetList);
- WTF::storeStoreFence();
- jitData.m_hasCalleeSaveRegisters = true;
-}
-
-void CodeBlock::resetJITData()
-{
RELEASE_ASSERT(!JITCode::isJIT(jitType()));
ConcurrentJSLocker locker(m_lock);
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
// We can clear these because no other thread will have references to any stub infos, call
// link infos, or by val infos if we don't have JIT code. Attempts to query these data
// structures using the concurrent API (getICStatusMap and friends) will return nothing if we
@@ -1832,7 +1799,7 @@
// We can clear this because the DFG's queries to these data structures are guarded by whether
// there is JIT code.
- m_jitData = nullptr;
+ m_baselineJITData = nullptr;
}
}
#endif
@@ -1878,7 +1845,7 @@
});
#if ENABLE(JIT)
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos)
stubInfo.visitAggregate(visitor);
}
@@ -2478,18 +2445,6 @@
}
#if !ENABLE(C_LOOP)
-const RegisterAtOffsetList* CodeBlock::calleeSaveRegisters() const
-{
-#if ENABLE(JIT)
- if (auto* jitData = m_jitData.get()) {
- if (jitData->m_hasCalleeSaveRegisters)
- return &jitData->m_calleeSaveRegisters;
- }
-#endif
- return &RegisterAtOffsetList::llintBaselineCalleeSaveRegisters();
-}
-
-
static size_t roundCalleeSaveSpaceAsVirtualRegisters(size_t calleeSaveRegisters)
{
@@ -2502,9 +2457,9 @@
return roundCalleeSaveSpaceAsVirtualRegisters(numberOfLLIntBaselineCalleeSaveRegisters());
}
-size_t CodeBlock::calleeSaveSpaceAsVirtualRegisters()
+size_t CodeBlock::calleeSaveSpaceAsVirtualRegisters(const RegisterAtOffsetList& calleeSaveRegisters)
{
- return roundCalleeSaveSpaceAsVirtualRegisters(calleeSaveRegisters()->size());
+ return roundCalleeSaveSpaceAsVirtualRegisters(calleeSaveRegisters.size());
}
#endif
@@ -3515,7 +3470,7 @@
{
ConcurrentJSLocker locker(m_lock);
- if (auto* jitData = m_jitData.get()) {
+ if (auto* jitData = m_baselineJITData.get()) {
for (auto& stubInfo : jitData->m_stubInfos) {
if (stubInfo.containsPC(pc))
return stubInfo.codeOrigin;
Modified: trunk/Source/_javascript_Core/bytecode/CodeBlock.h (287595 => 287596)
--- trunk/Source/_javascript_Core/bytecode/CodeBlock.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/bytecode/CodeBlock.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -95,6 +95,7 @@
class RegisterAtOffsetList;
class StructureStubInfo;
class BaselineJITCode;
+class BaselineJITData;
DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(CodeBlockRareData);
@@ -246,7 +247,7 @@
std::optional<BytecodeIndex> bytecodeIndexFromCallSiteIndex(CallSiteIndex);
- // Because we might throw out baseline JIT code and all its baseline JIT data (m_jitData),
+ // Because we might throw out baseline JIT code and all its baseline JIT data (m_baselineJITData),
// you need to be careful about the lifetime of when you use the return value of this function.
// The return value may have raw pointers into this data structure that gets thrown away.
// Specifically, you need to ensure that no GC can be finalized (typically that means no
@@ -255,30 +256,10 @@
void getICStatusMap(ICStatusMap& result);
#if ENABLE(JIT)
- struct JITData {
- WTF_MAKE_STRUCT_FAST_ALLOCATED;
- friend class LLIntOffsetsExtractor;
-
- FixedVector<StructureStubInfo> m_stubInfos;
- bool m_hasCalleeSaveRegisters { false };
- RegisterAtOffsetList m_calleeSaveRegisters;
-
- FixedVector<void*> m_jitConstantPool;
- static ptrdiff_t offsetOfJITConstantPool() { return OBJECT_OFFSETOF(JITData, m_jitConstantPool); }
- };
-
void setupWithUnlinkedBaselineCode(Ref<BaselineJITCode>);
- JITData& ensureJITData(const ConcurrentJSLocker& locker)
- {
- if (LIKELY(m_jitData))
- return *m_jitData;
- return ensureJITDataSlow(locker);
- }
- JITData& ensureJITDataSlow(const ConcurrentJSLocker&);
+ static ptrdiff_t offsetOfBaselineJITData() { return OBJECT_OFFSETOF(CodeBlock, m_baselineJITData); }
- static ptrdiff_t offsetOfJITData() { return OBJECT_OFFSETOF(CodeBlock, m_jitData); }
-
StructureStubInfo* addOptimizingStubInfo(AccessType, CodeOrigin);
// O(n) operation. Use getICStatusMap() unless you really only intend to get one stub info.
@@ -293,15 +274,12 @@
std::optional<CodeOrigin> findPC(void* pc);
- void setCalleeSaveRegisters(RegisterSet);
- void setCalleeSaveRegisters(RegisterAtOffsetList&&);
-
// We call this when we want to reattempt compiling something with the baseline JIT. Ideally
// the baseline JIT would not add data to CodeBlock, but instead it would put its data into
// a newly created JITCode, which could be thrown away if we bail on JIT compilation. Then we
// would be able to get rid of this silly function.
// FIXME: https://bugs.webkit.org/show_bug.cgi?id=159061
- void resetJITData();
+ void resetBaselineJITData();
#endif // ENABLE(JIT)
void unlinkIncomingCalls();
@@ -554,10 +532,10 @@
#if ENABLE(JIT)
SimpleJumpTable& baselineSwitchJumpTable(int tableIndex);
StringJumpTable& baselineStringSwitchJumpTable(int tableIndex);
- void* baselineJITConstantPool()
+ BaselineJITData* baselineJITData()
{
- RELEASE_ASSERT(m_jitData && jitType() == JITType::BaselineJIT);
- return m_jitData->m_jitConstantPool.storage();
+ RELEASE_ASSERT(jitType() == JITType::BaselineJIT);
+ return m_baselineJITData.get();
}
#endif
size_t numberOfUnlinkedSwitchJumpTables() const { return m_unlinkedCode->numberOfUnlinkedSwitchJumpTables(); }
@@ -633,15 +611,13 @@
void countReoptimization();
#if !ENABLE(C_LOOP)
- const RegisterAtOffsetList* calleeSaveRegisters() const;
-
static unsigned numberOfLLIntBaselineCalleeSaveRegisters() { return RegisterSet::llintBaselineCalleeSaveRegisters().numberOfSetRegisters(); }
static size_t llintBaselineCalleeSaveSpaceAsVirtualRegisters();
- size_t calleeSaveSpaceAsVirtualRegisters();
+ static size_t calleeSaveSpaceAsVirtualRegisters(const RegisterAtOffsetList&);
#else
static unsigned numberOfLLIntBaselineCalleeSaveRegisters() { return 0; }
static size_t llintBaselineCalleeSaveSpaceAsVirtualRegisters() { return 1; };
- size_t calleeSaveSpaceAsVirtualRegisters() { return 0; }
+ static size_t calleeSaveSpaceAsVirtualRegisters(const RegisterAtOffsetList&) { return 0; }
#endif
#if ENABLE(JIT)
@@ -960,7 +936,7 @@
RefPtr<JITCode> m_jitCode;
#if ENABLE(JIT)
public:
- std::unique_ptr<JITData> m_jitData;
+ std::unique_ptr<BaselineJITData> m_baselineJITData;
private:
#endif
#if ENABLE(DFG_JIT)
Modified: trunk/Source/_javascript_Core/bytecode/Repatch.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/bytecode/Repatch.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/bytecode/Repatch.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -1758,8 +1758,8 @@
if (!frameShuffler && callLinkInfo.isTailCall()) {
// We strongly assume that calleeGPR is not a callee save register in the slow path.
- ASSERT(!callerCodeBlock->calleeSaveRegisters()->find(calleeGPR));
- stubJit.emitRestoreCalleeSaves();
+ ASSERT(!callerCodeBlock->jitCode()->calleeSaveRegisters()->find(calleeGPR));
+ stubJit.emitRestoreCalleeSavesFor(callerCodeBlock->jitCode()->calleeSaveRegisters());
}
CCallHelpers::JumpList slowPath;
Modified: trunk/Source/_javascript_Core/dfg/DFGJITCompiler.h (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGJITCompiler.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGJITCompiler.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -302,6 +302,16 @@
VM& vm() { return m_graph.m_vm; }
+ void emitRestoreCalleeSaves()
+ {
+ emitRestoreCalleeSavesFor(&RegisterAtOffsetList::dfgCalleeSaveRegisters());
+ }
+
+ void emitSaveCalleeSaves()
+ {
+ emitSaveCalleeSavesFor(&RegisterAtOffsetList::dfgCalleeSaveRegisters());
+ }
+
private:
friend class OSRExitJumpPlaceholder;
Modified: trunk/Source/_javascript_Core/dfg/DFGOSREntry.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGOSREntry.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGOSREntry.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -294,7 +294,7 @@
// 6) Copy our callee saves to buffer.
#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
- const RegisterAtOffsetList* registerSaveLocations = codeBlock->calleeSaveRegisters();
+ const RegisterAtOffsetList* registerSaveLocations = codeBlock->jitCode()->calleeSaveRegisters();
RegisterAtOffsetList* allCalleeSaves = RegisterSet::vmCalleeSaveRegisterOffsets();
RegisterSet dontSaveRegisters = RegisterSet(RegisterSet::stackRegisters());
Modified: trunk/Source/_javascript_Core/dfg/DFGOSRExit.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGOSRExit.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGOSRExit.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -738,8 +738,8 @@
CCallHelpers::framePointerRegister, CCallHelpers::stackPointerRegister);
// Restore the DFG callee saves and then save the ones the baseline JIT uses.
- jit.emitRestoreCalleeSaves();
- jit.emitSaveCalleeSavesFor(jit.baselineCodeBlock());
+ jit.emitRestoreCalleeSavesFor(jit.codeBlock()->jitCode()->calleeSaveRegisters());
+ jit.emitSaveCalleeSavesFor(jit.baselineCodeBlock()->jitCode()->calleeSaveRegisters());
// The tag registers are needed to materialize recoveries below.
jit.emitMaterializeTagCheckRegisters();
@@ -770,7 +770,7 @@
if (operand.isTmp())
continue;
- if (operand.isLocal() && operand.toLocal() < static_cast<int>(jit.baselineCodeBlock()->calleeSaveSpaceAsVirtualRegisters()))
+ if (operand.isLocal() && operand.toLocal() < static_cast<int>(CodeBlock::calleeSaveSpaceAsVirtualRegisters(*jit.baselineCodeBlock()->jitCode()->calleeSaveRegisters())))
continue;
switch (recovery.technique()) {
Modified: trunk/Source/_javascript_Core/dfg/DFGOSRExitCompilerCommon.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGOSRExitCompilerCommon.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGOSRExitCompilerCommon.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -230,7 +230,7 @@
CCallHelpers::Address calleeSaveSlot(InlineCallFrame* inlineCallFrame, CodeBlock* baselineCodeBlock, GPRReg calleeSave)
{
- const RegisterAtOffsetList* calleeSaves = baselineCodeBlock->calleeSaveRegisters();
+ const RegisterAtOffsetList* calleeSaves = baselineCodeBlock->jitCode()->calleeSaveRegisters();
for (unsigned i = 0; i < calleeSaves->size(); i++) {
RegisterAtOffset entry = calleeSaves->at(i);
if (entry.reg() != calleeSave)
@@ -314,7 +314,7 @@
} else if (trueCaller) {
CodeBlock* baselineCodeBlockForCaller = jit.baselineCodeBlockFor(*trueCaller);
jit.storePtr(CCallHelpers::TrustedImmPtr(baselineCodeBlockForCaller->metadataTable()), calleeSaveSlot(inlineCallFrame, baselineCodeBlock, JIT::s_metadataGPR));
- jit.storePtr(CCallHelpers::TrustedImmPtr(baselineCodeBlockForCaller->baselineJITConstantPool()), calleeSaveSlot(inlineCallFrame, baselineCodeBlock, JIT::s_constantsGPR));
+ jit.storePtr(CCallHelpers::TrustedImmPtr(baselineCodeBlockForCaller->baselineJITData()), calleeSaveSlot(inlineCallFrame, baselineCodeBlock, JIT::s_constantsGPR));
}
if (!inlineCallFrame->isVarargs())
@@ -407,7 +407,7 @@
jumpTarget = destination.retagged<OSRExitPtrTag>().executableAddress();
} else {
jit.move(CCallHelpers::TrustedImmPtr(codeBlockForExit->metadataTable()), JIT::s_metadataGPR);
- jit.move(CCallHelpers::TrustedImmPtr(codeBlockForExit->baselineJITConstantPool()), JIT::s_constantsGPR);
+ jit.move(CCallHelpers::TrustedImmPtr(codeBlockForExit->baselineJITData()), JIT::s_constantsGPR);
BytecodeIndex exitIndex = exit.m_codeOrigin.bytecodeIndex();
MacroAssemblerCodePtr<JSEntryPtrTag> destination;
Modified: trunk/Source/_javascript_Core/dfg/DFGPlan.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGPlan.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGPlan.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -198,8 +198,6 @@
parse(dfg);
}
- m_codeBlock->setCalleeSaveRegisters(RegisterSet::dfgCalleeSaveRegisters());
-
bool changed = false;
#define RUN_PHASE(phase) \
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -741,7 +741,7 @@
for (unsigned i = numPassedArgs; i < numAllocatedArgs; ++i)
shuffleData.args[i] = ValueRecovery::constant(jsUndefined());
- shuffleData.setupCalleeSaveRegisters(m_jit.codeBlock());
+ shuffleData.setupCalleeSaveRegisters(&RegisterAtOffsetList::dfgCalleeSaveRegisters());
} else {
m_jit.store32(MacroAssembler::TrustedImm32(numPassedArgs), m_jit.calleeFramePayloadSlot(CallFrameSlot::argumentCountIncludingThis));
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT64.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT64.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT64.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -842,7 +842,7 @@
for (unsigned i = numPassedArgs; i < numAllocatedArgs; ++i)
shuffleData.args[i] = ValueRecovery::constant(jsUndefined());
- shuffleData.setupCalleeSaveRegisters(m_jit.codeBlock());
+ shuffleData.setupCalleeSaveRegisters(&RegisterAtOffsetList::dfgCalleeSaveRegisters());
} else {
m_jit.store32(MacroAssembler::TrustedImm32(numPassedArgs), JITCompiler::calleeFramePayloadSlot(CallFrameSlot::argumentCountIncludingThis));
Modified: trunk/Source/_javascript_Core/dfg/DFGStackLayoutPhase.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/dfg/DFGStackLayoutPhase.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/dfg/DFGStackLayoutPhase.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -119,7 +119,7 @@
}
Vector<unsigned> allocation(usedOperands.size());
- m_graph.m_nextMachineLocal = codeBlock()->calleeSaveSpaceAsVirtualRegisters();
+ m_graph.m_nextMachineLocal = CodeBlock::calleeSaveSpaceAsVirtualRegisters(RegisterAtOffsetList::dfgCalleeSaveRegisters());
for (unsigned i = 0; i < usedOperands.size(); ++i) {
if (!usedOperands.getForOperandIndex(i)) {
allocation[i] = UINT_MAX;
Modified: trunk/Source/_javascript_Core/ftl/FTLCompile.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/ftl/FTLCompile.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/ftl/FTLCompile.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -77,7 +77,7 @@
RegisterAtOffsetList registerOffsets = state.proc->calleeSaveRegisterAtOffsetList();
if (shouldDumpDisassembly())
dataLog(tierName, "Unwind info for ", CodeBlockWithJITType(codeBlock, JITType::FTLJIT), ": ", registerOffsets, "\n");
- codeBlock->setCalleeSaveRegisters(WTFMove(registerOffsets));
+ state.jitCode->m_calleeSaveRegisters = RegisterAtOffsetList(WTFMove(registerOffsets));
ASSERT(!(state.proc->frameSize() % sizeof(EncodedJSValue)));
state.jitCode->common.frameRegisterCount = state.proc->frameSize() / sizeof(EncodedJSValue);
Modified: trunk/Source/_javascript_Core/ftl/FTLJITCode.h (287595 => 287596)
--- trunk/Source/_javascript_Core/ftl/FTLJITCode.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/ftl/FTLJITCode.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -70,9 +70,12 @@
void shrinkToFit(const ConcurrentJSLocker&) override;
PCToCodeOriginMap* pcToCodeOriginMap() override { return common.m_pcToCodeOriginMap.get(); }
+
+ const RegisterAtOffsetList* calleeSaveRegisters() const { return &m_calleeSaveRegisters; }
DFG::CommonData common;
Vector<OSRExit> m_osrExit;
+ RegisterAtOffsetList m_calleeSaveRegisters;
SegmentedVector<OSRExitDescriptor, 8> osrExitDescriptors;
Vector<std::unique_ptr<LazySlowPath>> lazySlowPaths;
Modified: trunk/Source/_javascript_Core/ftl/FTLLowerDFGToB3.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/ftl/FTLLowerDFGToB3.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/ftl/FTLLowerDFGToB3.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -10395,7 +10395,7 @@
shuffleData.args.append(ValueRecovery::constant(jsUndefined()));
shuffleData.numPassedArgs = numPassedArgs;
shuffleData.numParameters = jit.codeBlock()->numParameters();
- shuffleData.setupCalleeSaveRegisters(jit.codeBlock());
+ shuffleData.setupCalleeSaveRegisters(state->jitCode->calleeSaveRegisters());
auto* callLinkInfo = state->jitCode->common.addCallLinkInfo(semanticNodeOrigin);
callLinkInfo->setUpCall(CallLinkInfo::DirectTailCall, InvalidGPRReg);
@@ -10555,7 +10555,7 @@
shuffleData.numPassedArgs = numArgs;
shuffleData.numParameters = jit.codeBlock()->numParameters();
- shuffleData.setupCalleeSaveRegisters(jit.codeBlock());
+ shuffleData.setupCalleeSaveRegisters(state->jitCode->calleeSaveRegisters());
auto* callLinkInfo = state->jitCode->common.addCallLinkInfo(codeOrigin);
callLinkInfo->setUpCall(CallLinkInfo::TailCall, GPRInfo::regT0);
@@ -10904,7 +10904,7 @@
CCallHelpers::Jump done;
if (isTailCall) {
slowPath = callLinkInfo->emitTailCallFastPath(jit, GPRInfo::regT0, scopedLambda<void()>([&]{
- jit.emitRestoreCalleeSaves();
+ jit.emitRestoreCalleeSavesFor(state->jitCode->calleeSaveRegisters());
jit.prepareForTailCallSlow();
}));
} else {
@@ -10916,7 +10916,7 @@
auto slowPathStart = jit.label();
if (isTailCall)
- jit.emitRestoreCalleeSaves();
+ jit.emitRestoreCalleeSavesFor(state->jitCode->calleeSaveRegisters());
jit.move(CCallHelpers::TrustedImmPtr(jit.codeBlock()->globalObjectFor(semanticNodeOrigin)), GPRInfo::regT3);
callLinkInfo->emitSlowPath(*vm, jit);
@@ -11185,7 +11185,7 @@
CCallHelpers::Jump done;
if (isTailCall) {
slowPath = callLinkInfo->emitTailCallFastPath(jit, GPRInfo::regT0, scopedLambda<void()>([&]{
- jit.emitRestoreCalleeSaves();
+ jit.emitRestoreCalleeSavesFor(state->jitCode->calleeSaveRegisters());
jit.prepareForTailCallSlow();
}));
} else {
@@ -11197,7 +11197,7 @@
auto slowPathStart = jit.label();
if (isTailCall)
- jit.emitRestoreCalleeSaves();
+ jit.emitRestoreCalleeSavesFor(state->jitCode->calleeSaveRegisters());
jit.move(CCallHelpers::TrustedImmPtr(jit.codeBlock()->globalObjectFor(semanticNodeOrigin)), GPRInfo::regT3);
callLinkInfo->emitSlowPath(*vm, jit);
Modified: trunk/Source/_javascript_Core/ftl/FTLOSRExitCompiler.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/ftl/FTLOSRExitCompiler.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/ftl/FTLOSRExitCompiler.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -181,7 +181,7 @@
sizeof(EncodedJSValue) * (
exit.m_descriptor->m_values.size() + numMaterializations + maxMaterializationNumArguments) +
requiredScratchMemorySizeInBytes() +
- codeBlock->calleeSaveRegisters()->size() * sizeof(uint64_t));
+ codeBlock->jitCode()->calleeSaveRegisters()->size() * sizeof(uint64_t));
EncodedJSValue* scratch = scratchBuffer ? static_cast<EncodedJSValue*>(scratchBuffer->dataBuffer()) : nullptr;
EncodedJSValue* materializationPointers = scratch + exit.m_descriptor->m_values.size();
EncodedJSValue* materializationArguments = materializationPointers + numMaterializations;
@@ -390,8 +390,8 @@
// Before we start messing with the frame, we need to set aside any registers that the
// FTL code was preserving.
- for (unsigned i = codeBlock->calleeSaveRegisters()->size(); i--;) {
- RegisterAtOffset entry = codeBlock->calleeSaveRegisters()->at(i);
+ for (unsigned i = codeBlock->jitCode()->calleeSaveRegisters()->size(); i--;) {
+ RegisterAtOffset entry = codeBlock->jitCode()->calleeSaveRegisters()->at(i);
jit.load64(
MacroAssembler::Address(MacroAssembler::framePointerRegister, entry.offset()),
GPRInfo::regT0);
@@ -402,7 +402,7 @@
// First set up SP so that our data doesn't get clobbered by signals.
unsigned conservativeStackDelta =
- (exit.m_descriptor->m_values.numberOfLocals() + baselineCodeBlock->calleeSaveSpaceAsVirtualRegisters()) * sizeof(Register) +
+ (exit.m_descriptor->m_values.numberOfLocals() + CodeBlock::calleeSaveSpaceAsVirtualRegisters(*baselineCodeBlock->jitCode()->calleeSaveRegisters())) * sizeof(Register) +
maxFrameExtentForSlowPathCall;
conservativeStackDelta = WTF::roundUpToMultipleOf(
stackAlignmentBytes(), conservativeStackDelta);
@@ -412,13 +412,13 @@
jit.checkStackPointerAlignment();
RegisterSet allFTLCalleeSaves = RegisterSet::ftlCalleeSaveRegisters();
- const RegisterAtOffsetList* baselineCalleeSaves = baselineCodeBlock->calleeSaveRegisters();
+ const RegisterAtOffsetList* baselineCalleeSaves = baselineCodeBlock->jitCode()->calleeSaveRegisters();
for (Reg reg = Reg::first(); reg <= Reg::last(); reg = reg.next()) {
if (!allFTLCalleeSaves.get(reg)) {
continue;
}
- unsigned unwindIndex = codeBlock->calleeSaveRegisters()->indexOf(reg);
+ unsigned unwindIndex = codeBlock->jitCode()->calleeSaveRegisters()->indexOf(reg);
const RegisterAtOffset* baselineRegisterOffset = baselineCalleeSaves->find(reg);
if (reg.isGPR()) {
@@ -453,7 +453,7 @@
}
}
- size_t baselineVirtualRegistersForCalleeSaves = baselineCodeBlock->calleeSaveSpaceAsVirtualRegisters();
+ size_t baselineVirtualRegistersForCalleeSaves = CodeBlock::calleeSaveSpaceAsVirtualRegisters(*baselineCodeBlock->jitCode()->calleeSaveRegisters());
if (exit.m_codeOrigin.inlineStackContainsActiveCheckpoint()) {
EncodedJSValue* tmpScratch = scratch + exit.m_descriptor->m_values.tmpIndex(0);
Modified: trunk/Source/_javascript_Core/interpreter/StackVisitor.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/interpreter/StackVisitor.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/interpreter/StackVisitor.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -273,7 +273,7 @@
#endif // ENABLE(WEBASSEMBLY)
if (CodeBlock* codeBlock = this->codeBlock())
- return *codeBlock->calleeSaveRegisters();
+ return *codeBlock->jitCode()->calleeSaveRegisters();
return std::nullopt;
}
Modified: trunk/Source/_javascript_Core/jit/AssemblyHelpers.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/AssemblyHelpers.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/AssemblyHelpers.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -45,11 +45,11 @@
namespace JSC {
-ExecutableBase* AssemblyHelpers::executableFor(const CodeOrigin& codeOrigin)
+ExecutableBase* AssemblyHelpers::executableFor(CodeBlock* codeBlock, const CodeOrigin& codeOrigin)
{
auto* inlineCallFrame = codeOrigin.inlineCallFrame();
if (!inlineCallFrame)
- return m_codeBlock->ownerExecutable();
+ return codeBlock->ownerExecutable();
return inlineCallFrame->baselineCodeBlock->ownerExecutable();
}
@@ -1372,7 +1372,7 @@
{
ASSERT_UNUSED(codeBlock, codeBlock);
ASSERT(JITCode::isBaselineCode(codeBlock->jitType()));
- ASSERT(codeBlock->calleeSaveRegisters() == &RegisterAtOffsetList::llintBaselineCalleeSaveRegisters());
+ ASSERT(codeBlock->jitCode()->calleeSaveRegisters() == &RegisterAtOffsetList::llintBaselineCalleeSaveRegisters());
const RegisterAtOffsetList* calleeSaves = &RegisterAtOffsetList::llintBaselineCalleeSaveRegisters();
RegisterSet dontSaveRegisters = RegisterSet(RegisterSet::stackRegisters());
Modified: trunk/Source/_javascript_Core/jit/AssemblyHelpers.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/AssemblyHelpers.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/AssemblyHelpers.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -316,35 +316,14 @@
void emitSave(const RegisterAtOffsetList&);
void emitRestore(const RegisterAtOffsetList&);
- void emitSaveCalleeSavesFor(CodeBlock* codeBlock)
- {
- ASSERT(codeBlock);
-
- const RegisterAtOffsetList* calleeSaves = codeBlock->calleeSaveRegisters();
- emitSaveCalleeSavesFor(calleeSaves);
- }
-
void emitSaveCalleeSavesFor(const RegisterAtOffsetList* calleeSaves);
enum RestoreTagRegisterMode { UseExistingTagRegisterContents, CopyBaselineCalleeSavedRegistersFromBaseFrame };
void emitSaveOrCopyLLIntBaselineCalleeSavesFor(CodeBlock*, VirtualRegister offsetVirtualRegister, RestoreTagRegisterMode, GPRReg temp1, GPRReg temp2, GPRReg temp3);
-
- void emitRestoreCalleeSavesFor(CodeBlock* codeBlock)
- {
- ASSERT(codeBlock);
- const RegisterAtOffsetList* calleeSaves = codeBlock->calleeSaveRegisters();
- emitRestoreCalleeSavesFor(calleeSaves);
- }
-
void emitRestoreCalleeSavesFor(const RegisterAtOffsetList* calleeSaves);
- void emitSaveCalleeSaves()
- {
- emitSaveCalleeSavesFor(codeBlock());
- }
-
void emitSaveThenMaterializeTagRegisters()
{
#if USE(JSVALUE64)
@@ -357,11 +336,6 @@
emitMaterializeTagCheckRegisters();
#endif
}
-
- void emitRestoreCalleeSaves()
- {
- emitRestoreCalleeSavesFor(codeBlock());
- }
void emitRestoreSavedTagRegisters()
{
@@ -1580,7 +1554,7 @@
return codeBlock()->globalObjectFor(codeOrigin);
}
- ExecutableBase* executableFor(const CodeOrigin& codeOrigin);
+ ExecutableBase* executableFor(CodeBlock*, const CodeOrigin&);
CodeBlock* baselineCodeBlockFor(const CodeOrigin& codeOrigin)
{
Modified: trunk/Source/_javascript_Core/jit/BaselineJITCode.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/BaselineJITCode.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/BaselineJITCode.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -28,6 +28,7 @@
#include "CallLinkInfo.h"
#include "JITCode.h"
#include "JITCodeMap.h"
+#include "StructureStubInfo.h"
#include <wtf/CompactPointerTuple.h>
#if ENABLE(JIT)
@@ -102,6 +103,25 @@
bool m_isShareable { true };
};
+class BaselineJITData final : public TrailingArray<BaselineJITData, void*> {
+ WTF_MAKE_FAST_ALLOCATED;
+ friend class LLIntOffsetsExtractor;
+public:
+ using Base = TrailingArray<BaselineJITData, void*>;
+
+ static std::unique_ptr<BaselineJITData> create(unsigned poolSize)
+ {
+ return std::unique_ptr<BaselineJITData> { new (NotNull, fastMalloc(Base::allocationSize(poolSize))) BaselineJITData(poolSize) };
+ }
+
+ explicit BaselineJITData(unsigned size)
+ : Base(size)
+ {
+ }
+
+ FixedVector<StructureStubInfo> m_stubInfos;
+};
+
} // namespace JSC
#endif // ENABLE(JIT)
Modified: trunk/Source/_javascript_Core/jit/CallFrameShuffleData.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/CallFrameShuffleData.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/CallFrameShuffleData.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -34,11 +34,6 @@
namespace JSC {
-void CallFrameShuffleData::setupCalleeSaveRegisters(CodeBlock* codeBlock)
-{
- setupCalleeSaveRegisters(codeBlock->calleeSaveRegisters());
-}
-
void CallFrameShuffleData::setupCalleeSaveRegisters(const RegisterAtOffsetList* registerSaveLocations)
{
RegisterSet calleeSaveRegisters { RegisterSet::vmCalleeSaveRegisters() };
Modified: trunk/Source/_javascript_Core/jit/CallFrameShuffleData.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/CallFrameShuffleData.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/CallFrameShuffleData.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -53,7 +53,6 @@
GPRReg numberTagRegister { InvalidGPRReg };
#endif
- void setupCalleeSaveRegisters(CodeBlock*);
void setupCalleeSaveRegisters(const RegisterAtOffsetList*);
ValueRecovery callee;
};
Modified: trunk/Source/_javascript_Core/jit/JIT.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/JIT.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/JIT.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -274,8 +274,7 @@
if (opcodeID != op_catch) {
loadPtr(addressFor(CallFrameSlot::codeBlock), regT0);
loadPtr(Address(regT0, CodeBlock::offsetOfMetadataTable()), regT1);
- loadPtr(Address(regT0, CodeBlock::offsetOfJITData()), regT0);
- loadPtr(Address(regT0, CodeBlock::JITData::offsetOfJITConstantPool()), regT2);
+ loadPtr(Address(regT0, CodeBlock::offsetOfBaselineJITData()), regT2);
auto metadataOK = branchPtr(Equal, regT1, s_metadataGPR);
breakpoint();
@@ -702,10 +701,14 @@
{
loadPtr(addressFor(CallFrameSlot::codeBlock), regT0);
loadPtr(Address(regT0, CodeBlock::offsetOfMetadataTable()), s_metadataGPR);
- loadPtr(Address(regT0, CodeBlock::offsetOfJITData()), regT0);
- loadPtr(Address(regT0, CodeBlock::JITData::offsetOfJITConstantPool()), s_constantsGPR);
+ loadPtr(Address(regT0, CodeBlock::offsetOfBaselineJITData()), s_constantsGPR);
}
+void JIT::emitSaveCalleeSaves()
+{
+ Base::emitSaveCalleeSavesFor(&RegisterAtOffsetList::llintBaselineCalleeSaveRegisters());
+}
+
void JIT::emitRestoreCalleeSaves()
{
Base::emitRestoreCalleeSavesFor(&RegisterAtOffsetList::llintBaselineCalleeSaveRegisters());
@@ -782,7 +785,7 @@
move(regT1, stackPointerRegister);
checkStackPointerAlignment();
- emitSaveCalleeSavesFor(&RegisterAtOffsetList::llintBaselineCalleeSaveRegisters());
+ emitSaveCalleeSaves();
emitMaterializeTagCheckRegisters();
emitMaterializeMetadataAndConstantPoolRegisters();
Modified: trunk/Source/_javascript_Core/jit/JIT.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/JIT.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/JIT.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -893,6 +893,7 @@
void emitMaterializeMetadataAndConstantPoolRegisters();
+ void emitSaveCalleeSaves();
void emitRestoreCalleeSaves();
static bool reportCompileTimes();
Modified: trunk/Source/_javascript_Core/jit/JITCode.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/JITCode.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/JITCode.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -26,6 +26,8 @@
#include "config.h"
#include "JITCode.h"
+#include "FTLJITCode.h"
+
#include <wtf/PrintStream.h>
namespace JSC {
@@ -95,6 +97,26 @@
{
}
+const RegisterAtOffsetList* JITCode::calleeSaveRegisters() const
+{
+ switch (jitType()) {
+#if ENABLE(FTL_JIT)
+ case JITType::FTLJIT:
+ return static_cast<const FTL::JITCode*>(this)->calleeSaveRegisters();
+#endif
+#if ENABLE(DFG_JIT)
+ case JITType::DFGJIT:
+ return &RegisterAtOffsetList::dfgCalleeSaveRegisters();
+#endif
+ default:
+#if !ENABLE(C_LOOP)
+ return &RegisterAtOffsetList::llintBaselineCalleeSaveRegisters();
+#else
+ return nullptr;
+#endif
+ }
+}
+
JITCodeWithCodeRef::JITCodeWithCodeRef(JITType jitType)
: JITCode(jitType)
{
Modified: trunk/Source/_javascript_Core/jit/JITCode.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/JITCode.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/JITCode.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -30,6 +30,7 @@
#include "CodeOrigin.h"
#include "JSCJSValue.h"
#include "MacroAssemblerCodeRef.h"
+#include "RegisterAtOffsetList.h"
#include "RegisterSet.h"
@@ -228,6 +229,8 @@
virtual PCToCodeOriginMap* pcToCodeOriginMap() { return nullptr; }
+ const RegisterAtOffsetList* calleeSaveRegisters() const;
+
private:
JITType m_jitType;
ShareAttribute m_shareAttribute;
Modified: trunk/Source/_javascript_Core/jit/JITInlines.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/JITInlines.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/JITInlines.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -505,7 +505,7 @@
ALWAYS_INLINE void JIT::loadConstant(JITConstantPool::Constant constantIndex, GPRReg result)
{
- loadPtr(Address(s_constantsGPR, FixedVector<void*>::Storage::offsetOfData() + static_cast<uintptr_t>(constantIndex) * sizeof(void*)), result);
+ loadPtr(Address(s_constantsGPR, BaselineJITData::offsetOfData() + static_cast<uintptr_t>(constantIndex) * sizeof(void*)), result);
}
ALWAYS_INLINE void JIT::loadGlobalObject(GPRReg result)
Modified: trunk/Source/_javascript_Core/jit/JITOpcodes.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/JITOpcodes.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/JITOpcodes.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -1064,8 +1064,7 @@
// So we replenish it here.
{
loadPtr(addressFor(CallFrameSlot::codeBlock), regT0);
- loadPtr(Address(regT0, CodeBlock::offsetOfJITData()), regT0);
- loadPtr(Address(regT0, CodeBlock::JITData::offsetOfJITConstantPool()), s_constantsGPR);
+ loadPtr(Address(regT0, CodeBlock::offsetOfBaselineJITData()), s_constantsGPR);
}
callOperationNoExceptionCheck(operationRetrieveAndClearExceptionIfCatchable, &vm());
Modified: trunk/Source/_javascript_Core/jit/RegisterAtOffsetList.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/RegisterAtOffsetList.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/RegisterAtOffsetList.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -80,6 +80,16 @@
return result.get();
}
+const RegisterAtOffsetList& RegisterAtOffsetList::dfgCalleeSaveRegisters()
+{
+ static std::once_flag onceKey;
+ static LazyNeverDestroyed<RegisterAtOffsetList> result;
+ std::call_once(onceKey, [] {
+ result.construct(RegisterSet::dfgCalleeSaveRegisters());
+ });
+ return result.get();
+}
+
} // namespace JSC
#endif // ENABLE(ASSEMBLER)
Modified: trunk/Source/_javascript_Core/jit/RegisterAtOffsetList.h (287595 => 287596)
--- trunk/Source/_javascript_Core/jit/RegisterAtOffsetList.h 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/jit/RegisterAtOffsetList.h 2022-01-05 00:20:42 UTC (rev 287596)
@@ -66,6 +66,7 @@
FixedVector<RegisterAtOffset>::const_iterator end() const { return m_registers.end(); }
static const RegisterAtOffsetList& llintBaselineCalleeSaveRegisters(); // Registers and Offsets saved and used by the LLInt.
+ static const RegisterAtOffsetList& dfgCalleeSaveRegisters(); // Registers and Offsets saved and used by DFG.
private:
FixedVector<RegisterAtOffset> m_registers;
Modified: trunk/Source/_javascript_Core/llint/LLIntSlowPaths.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/llint/LLIntSlowPaths.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/llint/LLIntSlowPaths.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -477,10 +477,8 @@
if (UNLIKELY(Options::returnEarlyFromInfiniteLoopsForFuzzing() && codeBlock->loopHintsAreEligibleForFuzzingEarlyReturn())) {
uintptr_t* ptr = vm.getLoopHintExecutionCounter(pc);
*ptr += codeBlock->llintExecuteCounter().m_activeThreshold;
- if (*ptr >= Options::earlyReturnFromInfiniteLoopsLimit()) {
- codeBlock->ensureJITData(ConcurrentJSLocker(codeBlock->m_lock)); // We're returning to the OSR entry code here, which expects that m_jitData is not null.
+ if (*ptr >= Options::earlyReturnFromInfiniteLoopsLimit())
LLINT_RETURN_TWO(LLInt::fuzzerReturnEarlyFromLoopHintEntrypoint().code().executableAddress(), callFrame->topOfFrame());
- }
}
Modified: trunk/Source/_javascript_Core/llint/LowLevelInterpreter.asm (287595 => 287596)
--- trunk/Source/_javascript_Core/llint/LowLevelInterpreter.asm 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/llint/LowLevelInterpreter.asm 2022-01-05 00:20:42 UTC (rev 287596)
@@ -2612,8 +2612,7 @@
macro loadBaselineJITConstantPool()
# Baseline uses LLInt's PB register for its JIT constant pool.
loadp CodeBlock[cfr], PB
- loadp CodeBlock::m_jitData[PB], PB
- loadp CodeBlock::JITData::m_jitConstantPool + VoidPointerFixedVector::m_storage[PB], PB
+ loadp CodeBlock::m_baselineJITData[PB], PB
end
macro setupReturnToBaselineAfterCheckpointExitIfNeeded()
Modified: trunk/Source/_javascript_Core/tools/VMInspector.cpp (287595 => 287596)
--- trunk/Source/_javascript_Core/tools/VMInspector.cpp 2022-01-05 00:19:20 UTC (rev 287595)
+++ trunk/Source/_javascript_Core/tools/VMInspector.cpp 2022-01-05 00:20:42 UTC (rev 287596)
@@ -402,7 +402,7 @@
--it;
dataLogF("-----------------------------------------------------------------------------\n");
- size_t numberOfCalleeSaveSlots = codeBlock->calleeSaveSpaceAsVirtualRegisters();
+ size_t numberOfCalleeSaveSlots = CodeBlock::calleeSaveSpaceAsVirtualRegisters(*codeBlock->jitCode()->calleeSaveRegisters());
const Register* endOfCalleeSaves = it - numberOfCalleeSaveSlots;
end = it - codeBlock->numVars();
