Diff
Modified: trunk/Source/_javascript_Core/ChangeLog (293086 => 293087)
--- trunk/Source/_javascript_Core/ChangeLog 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/ChangeLog 2022-04-20 07:54:47 UTC (rev 293087)
@@ -1,3 +1,44 @@
+2022-04-20 Mikhail R. Gadelha <mikh...@igalia.com>
+
+ Unify calls and checks for CellTag
+ https://bugs.webkit.org/show_bug.cgi?id=238025
+
+ Reviewed by Yusuke Suzuki.
+
+ This patch moves all the places where cell tags are written and checked
+ when branching: this will be needed when implementing the concurrency on
+ 32 bits archs, so we can focus on changing storeCell, branchIfNotCell and
+ branchIfCell to implement the mutex locks/unlocks.
+
+ It also reduces the code size in JetStream2 by ~1% on average on 32
+ bits platforms.
+
+ * assembler/MacroAssemblerARMv7.h:
+ (JSC::MacroAssemblerARMv7::store8):
+ (JSC::MacroAssemblerARMv7::storePair32):
+ * assembler/MacroAssemblerMIPS.h:
+ (JSC::MacroAssemblerMIPS::storePair32):
+ * dfg/DFGOSRExit.cpp:
+ (JSC::DFG::OSRExit::compileExit):
+ * dfg/DFGOSRExitCompilerCommon.cpp:
+ (JSC::DFG::reifyInlinedCallFrames):
+ * dfg/DFGSpeculativeJIT.cpp:
+ (JSC::DFG::SpeculativeJIT::checkArgumentTypes):
+ * dfg/DFGSpeculativeJIT32_64.cpp:
+ (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
+ (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectStrictEquality):
+ * jit/AssemblyHelpers.cpp:
+ (JSC::AssemblyHelpers::jitAssertIsCell):
+ * jit/AssemblyHelpers.h:
+ (JSC::AssemblyHelpers::storeCell):
+ (JSC::AssemblyHelpers::storeTrustedValue):
+ (JSC::AssemblyHelpers::branchIfNotCell):
+ (JSC::AssemblyHelpers::branchIfCell):
+ * jit/CallFrameShuffler32_64.cpp:
+ (JSC::CallFrameShuffler::emitStore):
+ * jit/JSInterfaceJIT.h:
+ (JSC::JSInterfaceJIT::emitLoadJSCell):
+
2022-04-19 Michael Saboff <msab...@apple.com>
Various WebKit tools need to be told about the system content path
Modified: trunk/Source/_javascript_Core/assembler/AbstractMacroAssembler.h (293086 => 293087)
--- trunk/Source/_javascript_Core/assembler/AbstractMacroAssembler.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/assembler/AbstractMacroAssembler.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -936,6 +936,7 @@
case NearCallMode::Regular:
return CodeLocationLabel<destTag>(tagCodePtr<destTag>(AssemblerType::prepareForAtomicRelinkCallConcurrently(nearCall.dataLocation(), destination.untaggedExecutableAddress())));
}
+ RELEASE_ASSERT_NOT_REACHED();
#else
UNUSED_PARAM(nearCall);
return destination;
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerARM64.h (293086 => 293087)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerARM64.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerARM64.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -1522,6 +1522,7 @@
case Extend::None:
return Assembler::UXTX;
}
+ RELEASE_ASSERT_NOT_REACHED();
}
void load64(Address address, RegisterID dest)
@@ -1951,6 +1952,17 @@
store64(dataTempRegister, address);
}
+ void store64(TrustedImmPtr imm, Address address)
+ {
+ if (!imm.m_value) {
+ store64(ARM64Registers::zr, address);
+ return;
+ }
+
+ moveToCachedReg(imm, dataMemoryTempRegister());
+ store64(dataTempRegister, address);
+ }
+
void store64(TrustedImm64 imm, BaseIndex address)
{
if (!imm.m_value) {
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerARMv7.h (293086 => 293087)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerARMv7.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerARMv7.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -1058,12 +1058,12 @@
store8(src, setupArmAddress(address));
}
- void store8(RegisterID src, const void *address)
+ void store8(RegisterID src, const void* address)
{
store8(src, setupArmAddress(AbsoluteAddress(address)));
}
- void store8(TrustedImm32 imm, const void *address)
+ void store8(TrustedImm32 imm, const void* address)
{
TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
move(imm8, dataTempRegister);
@@ -1103,6 +1103,34 @@
store16(dataTempRegister, address);
}
+ void storePair32(RegisterID src1, TrustedImm32 imm, Address address)
+ {
+ RegisterID scratch = getCachedDataTempRegisterIDAndInvalidate();
+ move(imm, scratch);
+ storePair32(src1, scratch, address);
+ }
+
+ void storePair32(TrustedImmPtr immPtr, TrustedImm32 imm32, Address address)
+ {
+ RegisterID scratch1 = getCachedAddressTempRegisterIDAndInvalidate();
+ move(immPtr, scratch1);
+ RegisterID scratch2 = getCachedDataTempRegisterIDAndInvalidate();
+ move(imm32, scratch2);
+ storePair32(scratch1, scratch2, address);
+ }
+
+ void storePair32(TrustedImm32 imm1, TrustedImm32 imm2, Address address)
+ {
+ RegisterID scratch1 = getCachedAddressTempRegisterIDAndInvalidate();
+ move(imm1, scratch1);
+ RegisterID scratch2 = scratch1;
+ if (imm1.m_value != imm2.m_value) {
+ scratch2 = getCachedDataTempRegisterIDAndInvalidate();
+ move(imm2, scratch2);
+ }
+ storePair32(scratch1, scratch2, address);
+ }
+
void storePair32(RegisterID src1, RegisterID src2, RegisterID dest)
{
storePair32(src1, src2, dest, TrustedImm32(0));
@@ -1140,6 +1168,22 @@
storePair32(src1, src2, Address(scratch, address.offset));
}
+ void storePair32(TrustedImm32 imm1, TrustedImm32 imm2, BaseIndex address)
+ {
+ // We don't have enough temp registers to move both imm and calculate the address
+ store32(imm1, address);
+ store32(imm2, address.withOffset(4));
+ }
+
+ void storePair32(RegisterID src1, TrustedImm32 imm, const void* address)
+ {
+ ArmAddress armAddress = setupArmAddress(AbsoluteAddress(address));
+ ASSERT(armAddress.type == ArmAddress::HasOffset);
+ RegisterID scratch = getCachedDataTempRegisterIDAndInvalidate();
+ move(imm, scratch);
+ storePair32(src1, scratch, Address(armAddress.base, armAddress.u.offset));
+ }
+
void storePair32(RegisterID src1, RegisterID src2, const void* address)
{
ArmAddress armAddress = setupArmAddress(AbsoluteAddress(address));
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerMIPS.h (293086 => 293087)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerMIPS.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerMIPS.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -1651,6 +1651,30 @@
}
}
+ void storePair32(RegisterID src1, TrustedImm32 imm, Address address)
+ {
+ move(imm, addrTempRegister);
+ storePair32(src1, addrTempRegister, address);
+ }
+
+ void storePair32(TrustedImmPtr immPtr, TrustedImm32 imm32, Address address)
+ {
+ move(immPtr, addrTempRegister);
+ move(imm32, dataTempRegister);
+ storePair32(addrTempRegister, dataTempRegister, address);
+ }
+
+ void storePair32(TrustedImm32 imm1, TrustedImm32 imm2, Address address)
+ {
+ move(imm1, addrTempRegister);
+ RegisterID scratch = addrTempRegister;
+ if (imm1.m_value != imm2.m_value) {
+ scratch = dataTempRegister;
+ move(imm2, scratch);
+ }
+ storePair32(addrTempRegister, scratch, address);
+ }
+
void storePair32(RegisterID src1, RegisterID src2, RegisterID dest)
{
storePair32(src1, src2, dest, TrustedImm32(0));
@@ -1673,6 +1697,19 @@
store32(src2, address.withOffset(4));
}
+ void storePair32(TrustedImm32 imm1, TrustedImm32 imm2, BaseIndex address)
+ {
+ store32(imm1, address);
+ store32(imm2, address.withOffset(4));
+ }
+
+ void storePair32(RegisterID src1, TrustedImm32 imm, const void* address)
+ {
+ move(TrustedImmPtr(address), addrTempRegister);
+ move(imm, dataTempRegister);
+ storePair32(src1, dataTempRegister, addrTempRegister);
+ }
+
void storePair32(RegisterID src1, RegisterID src2, const void* address)
{
move(TrustedImmPtr(address), addrTempRegister);
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerX86_64.h (293086 => 293087)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerX86_64.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerX86_64.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -1021,6 +1021,12 @@
store64(scratchRegister(), address);
}
+ void store64(TrustedImmPtr imm, Address address)
+ {
+ move(imm, scratchRegister());
+ store64(scratchRegister(), address);
+ }
+
void store64(TrustedImm64 imm, BaseIndex address)
{
move(imm, scratchRegister());
@@ -1037,7 +1043,7 @@
{
transfer64(src, dest);
}
-
+
DataLabel32 store64WithAddressOffsetPatch(RegisterID src, Address address)
{
padBeforePatch();
Modified: trunk/Source/_javascript_Core/dfg/DFGOSRExit.cpp (293086 => 293087)
--- trunk/Source/_javascript_Core/dfg/DFGOSRExit.cpp 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/dfg/DFGOSRExit.cpp 2022-04-20 07:54:47 UTC (rev 293087)
@@ -638,8 +638,7 @@
break;
case UnboxedCellInGPR:
- jit.store32(
- AssemblyHelpers::TrustedImm32(JSValue::CellTag),
+ jit.storeCell(
&bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag);
break;
@@ -647,8 +646,7 @@
jit.load32(
AssemblyHelpers::payloadFor(recovery.virtualRegister()),
JSRInfo::jsRegT10.payloadGPR());
- jit.move(AssemblyHelpers::TrustedImm32(JSValue::CellTag), JSRInfo::jsRegT10.tagGPR());
- jit.storeValue(JSRInfo::jsRegT10, scratch + index);
+ jit.storeCell(JSRInfo::jsRegT10, scratch + index);
break;
#endif
Modified: trunk/Source/_javascript_Core/dfg/DFGOSRExitCompilerCommon.cpp (293086 => 293087)
--- trunk/Source/_javascript_Core/dfg/DFGOSRExitCompilerCommon.cpp 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/dfg/DFGOSRExitCompilerCommon.cpp 2022-04-20 07:54:47 UTC (rev 293087)
@@ -322,14 +322,8 @@
jit.storePtr(callerFrameGPR, AssemblyHelpers::addressForByteOffset(inlineCallFrame->callerFrameOffset()));
uint32_t locationBits = CallSiteIndex(baselineCodeBlock->bytecodeIndexForExit(codeOrigin->bytecodeIndex())).bits();
jit.store32(AssemblyHelpers::TrustedImm32(locationBits), AssemblyHelpers::tagFor(VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::argumentCountIncludingThis)));
-#if USE(JSVALUE64)
if (!inlineCallFrame->isClosureCall)
- jit.store64(AssemblyHelpers::TrustedImm64(JSValue::encode(JSValue(inlineCallFrame->calleeConstant()))), AssemblyHelpers::addressFor(VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::callee)));
-#else // USE(JSVALUE64) // so this is the 32-bit part
- jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor(VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::callee)));
- if (!inlineCallFrame->isClosureCall)
- jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->calleeConstant()), AssemblyHelpers::payloadFor(VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::callee)));
-#endif // USE(JSVALUE64) // ending the #else part, so directly above is the 32-bit part
+ jit.storeCell(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->calleeConstant()), AssemblyHelpers::addressFor(VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::callee)));
}
// Don't need to set the toplevel code origin if we only did inline tail calls
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT.cpp (293086 => 293087)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT.cpp 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT.cpp 2022-04-20 07:54:47 UTC (rev 293087)
@@ -2412,7 +2412,7 @@
break;
}
case FlushedCell: {
- speculationCheck(BadType, valueSource, node, m_jit.branch32(MacroAssembler::NotEqual, JITCompiler::tagFor(virtualRegister), TrustedImm32(JSValue::CellTag)));
+ speculationCheck(BadType, valueSource, node, m_jit.branchIfNotCell(JITCompiler::tagFor(virtualRegister)));
break;
}
default:
@@ -9793,13 +9793,7 @@
if (bitVector->get(i)) {
SpeculateCellOperand immutableButterfly(this, use);
GPRReg immutableButterflyGPR = immutableButterfly.gpr();
-#if USE(JSVALUE64)
- m_jit.store64(immutableButterflyGPR, &buffer[i]);
-#else
- char* pointer = static_cast<char*>(static_cast<void*>(&buffer[i]));
- m_jit.store32(immutableButterflyGPR, pointer + PayloadOffset);
- m_jit.store32(TrustedImm32(JSValue::CellTag), pointer + TagOffset);
-#endif
+ m_jit.storeCell(immutableButterflyGPR, &buffer[i]);
} else {
JSValueOperand input(this, use);
JSValueRegs inputRegs = input.jsValueRegs();
@@ -10162,7 +10156,7 @@
#if USE(JSVALUE64)
auto found = m_jit.branch64(CCallHelpers::Equal, MacroAssembler::BaseIndex(storageGPR, indexGPR, MacroAssembler::TimesEight), searchElementGPR);
#else
- auto skip = m_jit.branch32(CCallHelpers::NotEqual, MacroAssembler::BaseIndex(storageGPR, indexGPR, MacroAssembler::TimesEight, TagOffset), TrustedImm32(JSValue::CellTag));
+ auto skip = m_jit.branchIfNotCell(MacroAssembler::BaseIndex(storageGPR, indexGPR, MacroAssembler::TimesEight, TagOffset));
m_jit.load32(MacroAssembler::BaseIndex(storageGPR, indexGPR, MacroAssembler::TimesEight, PayloadOffset), tempGPR);
auto found = m_jit.branch32(CCallHelpers::Equal, tempGPR, searchElementGPR);
skip.link(&m_jit);
@@ -11427,18 +11421,8 @@
resultGPR, TrustedImmPtr(node->structure()), butterfly, scratch1GPR, scratch2GPR,
slowPath);
-#if USE(JSVALUE64)
- m_jit.store64(
- operandGPR, JITCompiler::Address(resultGPR, JSWrapperObject::internalValueOffset()));
-#else
- m_jit.store32(
- TrustedImm32(JSValue::CellTag),
- JITCompiler::Address(resultGPR, JSWrapperObject::internalValueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
- m_jit.store32(
- operandGPR,
- JITCompiler::Address(resultGPR, JSWrapperObject::internalValueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
-#endif
-
+ m_jit.storeCell(operandGPR, JITCompiler::Address(resultGPR, JSWrapperObject::internalValueOffset()));
+
m_jit.mutatorFence(vm());
addSlowPathGenerator(slowPathCall(
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp (293086 => 293087)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp 2022-04-20 07:54:47 UTC (rev 293087)
@@ -1109,10 +1109,7 @@
BadType,
JSValueSource(JITCompiler::addressFor(virtualRegister)),
edge,
- m_jit.branch32(
- MacroAssembler::NotEqual,
- JITCompiler::tagFor(virtualRegister),
- TrustedImm32(JSValue::CellTag)));
+ m_jit.branchIfNotCell(JITCompiler::tagFor(virtualRegister)));
}
GPRReg gpr = allocate();
m_jit.load32(JITCompiler::payloadFor(virtualRegister), gpr);
@@ -1277,7 +1274,8 @@
DFG_TYPE_CHECK(JSValueSource::unboxedCell(op1GPR), objectChild, SpecObject, m_jit.branchIfNotObject(op1GPR));
- branch32(MacroAssembler::NotEqual, op2.tagGPR(), TrustedImm32(JSValue::CellTag), notTaken);
+ MacroAssembler::Jump notCell = m_jit.branchIfNotCell(op2.tagGPR());
+ addBranch(notCell, notTaken);
if (taken == nextBlock()) {
branch32(MacroAssembler::NotEqual, op1GPR, op2GPR, notTaken);
Modified: trunk/Source/_javascript_Core/jit/AssemblyHelpers.cpp (293086 => 293087)
--- trunk/Source/_javascript_Core/jit/AssemblyHelpers.cpp 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/jit/AssemblyHelpers.cpp 2022-04-20 07:54:47 UTC (rev 293087)
@@ -180,7 +180,7 @@
void AssemblyHelpers::jitAssertIsCell(GPRReg gpr)
{
- Jump checkCell = branch32(Equal, gpr, TrustedImm32(JSValue::CellTag));
+ Jump checkCell = branchIfCell(gpr);
abortWithReason(AHIsNotCell);
checkCell.link(this);
}
Modified: trunk/Source/_javascript_Core/jit/AssemblyHelpers.h (293086 => 293087)
--- trunk/Source/_javascript_Core/jit/AssemblyHelpers.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/jit/AssemblyHelpers.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -139,17 +139,42 @@
#endif
}
- template<typename T>
- void storeCell(T cell, Address address)
+ template<typename T, typename U>
+ void storeCell(T cell, U address)
{
#if USE(JSVALUE64)
store64(cell, address);
#else
- store32(cell, address.withOffset(PayloadOffset));
- store32(TrustedImm32(JSValue::CellTag), address.withOffset(TagOffset));
+ static_assert(!PayloadOffset && TagOffset == 4, "Assumes little-endian system");
+ storePair32(cell, TrustedImm32(JSValue::CellTag), address);
#endif
}
-
+
+ template<typename U>
+ void storeCell(JSValueRegs regs, U address)
+ {
+#if USE(JSVALUE64)
+ store64(regs.gpr(), address);
+#else
+ static_assert(!PayloadOffset && TagOffset == 4, "Assumes little-endian system");
+ move(AssemblyHelpers::TrustedImm32(JSValue::CellTag), regs.tagGPR());
+ storePair32(regs.payloadGPR(), regs.tagGPR(), address);
+#endif
+ }
+
+#if USE(JSVALUE32_64)
+ void storeCell(const void* address)
+ {
+#if ENABLE(CONCURRENT_JS)
+ if (Options::useConcurrentJIT()) {
+ store32Concurrently(AssemblyHelpers::TrustedImm32(JSValue::CellTag), address);
+ return;
+ }
+#endif
+ store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), address);
+ }
+#endif
+
void loadCell(Address address, GPRReg gpr)
{
#if USE(JSVALUE64)
@@ -158,7 +183,7 @@
load32(address.withOffset(PayloadOffset), gpr);
#endif
}
-
+
void storeValue(JSValueRegs regs, Address address)
{
#if USE(JSVALUE64)
@@ -287,8 +312,7 @@
#if USE(JSVALUE64)
store64(TrustedImm64(JSValue::encode(value)), address);
#else
- store32(TrustedImm32(value.tag()), address.withOffset(TagOffset));
- store32(TrustedImm32(value.payload()), address.withOffset(PayloadOffset));
+ storePair32(TrustedImm32(value.payload()), TrustedImm32(value.tag()), address);
#endif
}
@@ -297,8 +321,7 @@
#if USE(JSVALUE64)
store64(TrustedImm64(JSValue::encode(value)), address);
#else
- store32(TrustedImm32(value.tag()), address.withOffset(TagOffset));
- store32(TrustedImm32(value.payload()), address.withOffset(PayloadOffset));
+ storePair32(TrustedImm32(value.payload()), TrustedImm32(value.tag()), address);
#endif
}
@@ -637,15 +660,16 @@
#endif
}
- Jump branchIfNotCell(GPRReg reg, TagRegistersMode mode = HaveTagRegisters)
+ template<typename T>
+ Jump branchIfNotCell(T maybeCell, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == HaveTagRegisters)
- return branchTest64(NonZero, reg, GPRInfo::notCellMaskRegister);
- return branchTest64(NonZero, reg, TrustedImm64(JSValue::NotCellMask));
+ return branchTest64(NonZero, maybeCell, GPRInfo::notCellMaskRegister);
+ return branchTest64(NonZero, maybeCell, TrustedImm64(JSValue::NotCellMask));
#else
UNUSED_PARAM(mode);
- return branch32(MacroAssembler::NotEqual, reg, TrustedImm32(JSValue::CellTag));
+ return branch32(MacroAssembler::NotEqual, maybeCell, TrustedImm32(JSValue::CellTag));
#endif
}
@@ -657,18 +681,20 @@
return branchIfNotCell(regs.tagGPR(), mode);
#endif
}
-
- Jump branchIfCell(GPRReg reg, TagRegistersMode mode = HaveTagRegisters)
+
+ template<typename T>
+ Jump branchIfCell(T maybeCell, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == HaveTagRegisters)
- return branchTest64(Zero, reg, GPRInfo::notCellMaskRegister);
- return branchTest64(Zero, reg, TrustedImm64(JSValue::NotCellMask));
+ return branchTest64(Zero, maybeCell, GPRInfo::notCellMaskRegister);
+ return branchTest64(Zero, maybeCell, TrustedImm64(JSValue::NotCellMask));
#else
UNUSED_PARAM(mode);
- return branch32(MacroAssembler::Equal, reg, TrustedImm32(JSValue::CellTag));
+ return branch32(MacroAssembler::Equal, maybeCell, TrustedImm32(JSValue::CellTag));
#endif
}
+
Jump branchIfCell(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
@@ -1192,11 +1218,13 @@
ASSERT(virtualRegister.isValid());
return Address(baseGPR, virtualRegister.offset() * sizeof(Register) + TagOffset);
}
+
static Address tagFor(VirtualRegister virtualRegister)
{
ASSERT(virtualRegister.isValid());
return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register) + TagOffset);
}
+
static Address tagFor(Operand operand)
{
ASSERT(!operand.isTmp());
@@ -1208,11 +1236,13 @@
ASSERT(virtualRegister.isValid());
return Address(baseGPR, virtualRegister.offset() * sizeof(Register) + PayloadOffset);
}
+
static Address payloadFor(VirtualRegister virtualRegister)
{
ASSERT(virtualRegister.isValid());
return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register) + PayloadOffset);
}
+
static Address payloadFor(Operand operand)
{
ASSERT(!operand.isTmp());
Modified: trunk/Source/_javascript_Core/jit/CallFrameShuffler32_64.cpp (293086 => 293087)
--- trunk/Source/_javascript_Core/jit/CallFrameShuffler32_64.cpp 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/jit/CallFrameShuffler32_64.cpp 2022-04-20 07:54:47 UTC (rev 293087)
@@ -45,9 +45,7 @@
m_jit.store32(location.recovery().gpr(), address.withOffset(PayloadOffset));
return DataFormatInt32;
case UnboxedCellInGPR:
- m_jit.store32(MacroAssembler::TrustedImm32(JSValue::CellTag),
- address.withOffset(TagOffset));
- m_jit.store32(location.recovery().gpr(), address.withOffset(PayloadOffset));
+ m_jit.storeCell(location.recovery().gpr(), address);
return DataFormatCell;
case Constant:
m_jit.storeTrustedValue(location.recovery().constant(), address);
Modified: trunk/Source/_javascript_Core/jit/JSInterfaceJIT.h (293086 => 293087)
--- trunk/Source/_javascript_Core/jit/JSInterfaceJIT.h 2022-04-20 07:43:04 UTC (rev 293086)
+++ trunk/Source/_javascript_Core/jit/JSInterfaceJIT.h 2022-04-20 07:54:47 UTC (rev 293087)
@@ -59,7 +59,7 @@
{
ASSERT(virtualRegister < VirtualRegister(FirstConstantRegisterIndex));
loadPtr(payloadFor(virtualRegister), payload);
- return branch32(NotEqual, tagFor(virtualRegister), TrustedImm32(JSValue::CellTag));
+ return branchIfNotCell(tagFor(virtualRegister));
}
inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadInt32(VirtualRegister virtualRegister, RegisterID dst)
