Changeset 263824 in webkit

Timestamp:

Jul 1, 2020, 4:50:37 PM (6 years ago)

Author:

keith_miller@apple.com

Message:

Rename zeroExtend32ToPtr to zeroExtend32ToWord
​https://bugs.webkit.org/show_bug.cgi?id=213866

Reviewed by Saam Barati.

The old name no longer makes sense now that we have configurations
where sizeof(void*) != sizeof(CPURegister).

• assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::branchTruncateDoubleToInt32):
(JSC::MacroAssemblerARM64::zeroExtend32ToWord):
(JSC::MacroAssemblerARM64::branchMul32):
(JSC::MacroAssemblerARM64::zeroExtend32ToPtr): Deleted.

• assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::zeroExtend32ToWord):
(JSC::MacroAssemblerARMv7::zeroExtend32ToPtr): Deleted.

• assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::zeroExtend32ToWord):
(JSC::MacroAssemblerMIPS::zeroExtend32ToPtr): Deleted.

• assembler/MacroAssemblerX86Common.h:

(JSC::MacroAssemblerX86Common::add32):
(JSC::MacroAssemblerX86Common::and32):
(JSC::MacroAssemblerX86Common::mul32):
(JSC::MacroAssemblerX86Common::or32):
(JSC::MacroAssemblerX86Common::xor32):
(JSC::MacroAssemblerX86Common::zeroExtend32ToWord):
(JSC::MacroAssemblerX86Common::branchAdd32):
(JSC::MacroAssemblerX86Common::zeroExtend32ToPtr): Deleted.

• b3/air/AirOpcode.opcodes:
• bytecode/AccessCase.cpp:

(JSC::AccessCase::generateWithGuard):

• dfg/DFGOSRExit.cpp:

(JSC::DFG::OSRExit::compileExit):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileStringSlice):
(JSC::DFG::SpeculativeJIT::compileValueToInt32):
(JSC::DFG::SpeculativeJIT::compileUInt32ToNumber):
(JSC::DFG::SpeculativeJIT::setIntTypedArrayLoadResult):
(JSC::DFG::SpeculativeJIT::compileArithDiv):
(JSC::DFG::SpeculativeJIT::compileCreateRest):
(JSC::DFG::SpeculativeJIT::compileArraySlice):
(JSC::DFG::SpeculativeJIT::compileArrayIndexOf):
(JSC::DFG::SpeculativeJIT::compileNewTypedArrayWithSize):
(JSC::DFG::SpeculativeJIT::emitAllocateButterfly):
(JSC::DFG::SpeculativeJIT::compileWeakMapGet):
(JSC::DFG::SpeculativeJIT::emitInitializeButterfly):

• dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::fillSpeculateInt32Internal):
(JSC::DFG::SpeculativeJIT::compile):

• ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::reboxAccordingToFormat):

• jit/CallFrameShuffler64.cpp:

(JSC::CallFrameShuffler::emitBox):

• jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_has_indexed_property):

• jit/JITOpcodes32_64.cpp:

(JSC::JIT::emit_op_has_indexed_property):

• jit/JITPropertyAccess.cpp:

(JSC::JIT::emit_op_put_by_val):

• jit/JSInterfaceJIT.h:

(JSC::JSInterfaceJIT::emitLoadInt32):

• wasm/js/JSToWasm.cpp:

(JSC::Wasm::boxWasmResult):

• wasm/js/WasmToJS.cpp:

(JSC::Wasm::wasmToJS):

• wasm/js/WebAssemblyFunction.cpp:

(JSC::WebAssemblyFunction::jsCallEntrypointSlow):

• yarr/YarrJIT.cpp:

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• assembler/MacroAssemblerARM64.h (modified) (3 diffs)
• assembler/MacroAssemblerARMv7.h (modified) (1 diff)
• assembler/MacroAssemblerMIPS.h (modified) (1 diff)
• assembler/MacroAssemblerX86Common.h (modified) (10 diffs)
• b3/air/AirOpcode.opcodes (modified) (1 diff)
• bytecode/AccessCase.cpp (modified) (5 diffs)
• dfg/DFGOSRExit.cpp (modified) (1 diff)
• dfg/DFGSpeculativeJIT.cpp (modified) (15 diffs)
• dfg/DFGSpeculativeJIT64.cpp (modified) (6 diffs)
• ftl/FTLOSRExitCompiler.cpp (modified) (2 diffs)
• jit/AssemblyHelpers.h (modified) (1 diff)
• jit/CallFrameShuffler64.cpp (modified) (1 diff)
• jit/JITOpcodes.cpp (modified) (1 diff)
• jit/JITOpcodes32_64.cpp (modified) (1 diff)
• jit/JITPropertyAccess.cpp (modified) (1 diff)
• jit/JSInterfaceJIT.h (modified) (1 diff)
• wasm/js/JSToWasm.cpp (modified) (1 diff)
• wasm/js/WasmToJS.cpp (modified) (2 diffs)
• wasm/js/WebAssemblyFunction.cpp (modified) (1 diff)
• yarr/YarrJIT.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2020-07-01  Keith Miller  <keith_miller@apple.com>
+
+        Rename zeroExtend32ToPtr to zeroExtend32ToWord
+        https://bugs.webkit.org/show_bug.cgi?id=213866
+
+        Reviewed by Saam Barati.
+
+        The old name no longer makes sense now that we have configurations
+        where sizeof(void*) != sizeof(CPURegister).
+
+        * assembler/MacroAssemblerARM64.h:
+        (JSC::MacroAssemblerARM64::branchTruncateDoubleToInt32):
+        (JSC::MacroAssemblerARM64::zeroExtend32ToWord):
+        (JSC::MacroAssemblerARM64::branchMul32):
+        (JSC::MacroAssemblerARM64::zeroExtend32ToPtr): Deleted.
+        * assembler/MacroAssemblerARMv7.h:
+        (JSC::MacroAssemblerARMv7::zeroExtend32ToWord):
+        (JSC::MacroAssemblerARMv7::zeroExtend32ToPtr): Deleted.
+        * assembler/MacroAssemblerMIPS.h:
+        (JSC::MacroAssemblerMIPS::zeroExtend32ToWord):
+        (JSC::MacroAssemblerMIPS::zeroExtend32ToPtr): Deleted.
+        * assembler/MacroAssemblerX86Common.h:
+        (JSC::MacroAssemblerX86Common::add32):
+        (JSC::MacroAssemblerX86Common::and32):
+        (JSC::MacroAssemblerX86Common::mul32):
+        (JSC::MacroAssemblerX86Common::or32):
+        (JSC::MacroAssemblerX86Common::xor32):
+        (JSC::MacroAssemblerX86Common::zeroExtend32ToWord):
+        (JSC::MacroAssemblerX86Common::branchAdd32):
+        (JSC::MacroAssemblerX86Common::zeroExtend32ToPtr): Deleted.
+        * b3/air/AirOpcode.opcodes:
+        * bytecode/AccessCase.cpp:
+        (JSC::AccessCase::generateWithGuard):
+        * dfg/DFGOSRExit.cpp:
+        (JSC::DFG::OSRExit::compileExit):
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::compileStringSlice):
+        (JSC::DFG::SpeculativeJIT::compileValueToInt32):
+        (JSC::DFG::SpeculativeJIT::compileUInt32ToNumber):
+        (JSC::DFG::SpeculativeJIT::setIntTypedArrayLoadResult):
+        (JSC::DFG::SpeculativeJIT::compileArithDiv):
+        (JSC::DFG::SpeculativeJIT::compileCreateRest):
+        (JSC::DFG::SpeculativeJIT::compileArraySlice):
+        (JSC::DFG::SpeculativeJIT::compileArrayIndexOf):
+        (JSC::DFG::SpeculativeJIT::compileNewTypedArrayWithSize):
+        (JSC::DFG::SpeculativeJIT::emitAllocateButterfly):
+        (JSC::DFG::SpeculativeJIT::compileWeakMapGet):
+        (JSC::DFG::SpeculativeJIT::emitInitializeButterfly):
+        * dfg/DFGSpeculativeJIT64.cpp:
+        (JSC::DFG::SpeculativeJIT::fillSpeculateInt32Internal):
+        (JSC::DFG::SpeculativeJIT::compile):
+        * ftl/FTLOSRExitCompiler.cpp:
+        (JSC::FTL::reboxAccordingToFormat):
+        * jit/CallFrameShuffler64.cpp:
+        (JSC::CallFrameShuffler::emitBox):
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_has_indexed_property):
+        * jit/JITOpcodes32_64.cpp:
+        (JSC::JIT::emit_op_has_indexed_property):
+        * jit/JITPropertyAccess.cpp:
+        (JSC::JIT::emit_op_put_by_val):
+        * jit/JSInterfaceJIT.h:
+        (JSC::JSInterfaceJIT::emitLoadInt32):
+        * wasm/js/JSToWasm.cpp:
+        (JSC::Wasm::boxWasmResult):
+        * wasm/js/WasmToJS.cpp:
+        (JSC::Wasm::wasmToJS):
+        * wasm/js/WebAssemblyFunction.cpp:
+        (JSC::WebAssemblyFunction::jsCallEntrypointSlow):
+        * yarr/YarrJIT.cpp:
+
 2020-07-01  Saam Barati  <sbarati@apple.com>
 

trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

@@ -1900 +1900 @@
         // Truncate to a 64-bit integer in dataTempRegister, copy the low 32-bit to dest.
         m_assembler.fcvtzs<64, 64>(getCachedDataTempRegisterIDAndInvalidate(), src);
-        zeroExtend32ToPtr(dataTempRegister, dest);
+        zeroExtend32ToWord(dataTempRegister, dest);
         // Check the low 32-bits sign extend to be equal to the full value.
         m_assembler.cmp<64>(dataTempRegister, dataTempRegister, Assembler::SXTW, 0);
@@ -2516 +2516 @@
     }
 
-    void zeroExtend32ToPtr(RegisterID src, RegisterID dest)
+    void zeroExtend32ToWord(RegisterID src, RegisterID dest)
     {
         m_assembler.uxtw(dest, src);
@@ -3196 +3196 @@
         m_assembler.asr<32>(scratch2, dest, 31);
         // After a mul32 the top 32 bits of the register should be clear.
-        zeroExtend32ToPtr(dest, dest);
+        zeroExtend32ToWord(dest, dest);
         // Check that bits 31..63 of the original result were all equal.
         return branch32(NotEqual, scratch2, scratch1);

trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

@@ -1426 +1426 @@
     }
 
-    void zeroExtend32ToPtr(RegisterID src, RegisterID dest)
+    void zeroExtend32ToWord(RegisterID src, RegisterID dest)
     {
         move(src, dest);

trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h

@@ -1693 +1693 @@
     }
 
-    void zeroExtend32ToPtr(RegisterID src, RegisterID dest)
+    void zeroExtend32ToWord(RegisterID src, RegisterID dest)
     {
         if (src != dest || m_fixedWidth)

trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

@@ -209 +209 @@
     {
         if (!imm.m_value) {
-            zeroExtend32ToPtr(src, dest);
+            zeroExtend32ToWord(src, dest);
             return;
         }
@@ -334 +334 @@
     {
         if (op1 == op2)
-            zeroExtend32ToPtr(op1, dest);
+            zeroExtend32ToWord(op1, dest);
         else if (op1 == dest)
             and32(op2, dest);
@@ -351 +351 @@
             and32(op2, dest);
         } else {
-            zeroExtend32ToPtr(op2, dest);
+            zeroExtend32ToWord(op2, dest);
             and32(op1, dest);
         }
@@ -495 +495 @@
             mul32(op2, dest);
         } else {
-            zeroExtend32ToPtr(op2, dest);
+            zeroExtend32ToWord(op2, dest);
             mul32(op1, dest);
         }
@@ -670 +670 @@
     {
         if (op1 == op2)
-            zeroExtend32ToPtr(op1, dest);
+            zeroExtend32ToWord(op1, dest);
         else if (op1 == dest)
             or32(op2, dest);
@@ -687 +687 @@
             or32(op2, dest);
         } else {
-            zeroExtend32ToPtr(op2, dest);
+            zeroExtend32ToWord(op2, dest);
             or32(op1, dest);
         }
@@ -1030 +1030 @@
             xor32(op2, dest);
         } else {
-            zeroExtend32ToPtr(op2, dest);
+            zeroExtend32ToWord(op2, dest);
             xor32(op1, dest);
         }
@@ -2288 +2288 @@
     }
 
-    void zeroExtend32ToPtr(RegisterID src, RegisterID dest)
+    void zeroExtend32ToWord(RegisterID src, RegisterID dest)
     {
         m_assembler.movl_rr(src, dest);
     }
 
-    void zeroExtend32ToPtr(TrustedImm32 src, RegisterID dest)
+    void zeroExtend32ToWord(TrustedImm32 src, RegisterID dest)
     {
         m_assembler.movl_i32r(src.m_value, dest);
@@ -2376 +2376 @@
     }
 
-    void zeroExtend32ToPtr(RegisterID src, RegisterID dest)
+    void zeroExtend32ToWord(RegisterID src, RegisterID dest)
     {
         move(src, dest);
@@ -2823 +2823 @@
             return branchAdd32(cond, op2, dest);
         }
-        zeroExtend32ToPtr(op2, dest);
+        zeroExtend32ToWord(op2, dest);
         return branchAdd32(cond, op1, dest);
     }

trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes

@@ -643 +643 @@
 
 Move32 U:G:32, ZD:G:32
-    Tmp, Tmp as zeroExtend32ToPtr
+    Tmp, Tmp as zeroExtend32ToWord
     Addr, Tmp as load32
     Index, Tmp as load32
     Tmp, Addr as store32
     Tmp, Index as store32
-    x86: Imm, Tmp as zeroExtend32ToPtr
+    x86: Imm, Tmp as zeroExtend32ToWord
     x86: Imm, Addr as store32
     x86: Imm, Index as store32

trunk/Source/JavaScriptCore/bytecode/AccessCase.cpp

@@ -938 +938 @@
         jit.loadPtr(CCallHelpers::Address(baseGPR, ScopedArguments::offsetOfScope()), scratch2GPR);
         jit.loadPtr(CCallHelpers::Address(scratchGPR, ScopedArgumentsTable::offsetOfArguments()), scratchGPR);
-        jit.zeroExtend32ToPtr(propertyGPR, scratch3GPR);
+        jit.zeroExtend32ToWord(propertyGPR, scratch3GPR);
         jit.load32(CCallHelpers::BaseIndex(scratchGPR, scratch3GPR, CCallHelpers::TimesFour), scratchGPR);
         failAndIgnore.append(jit.branch32(CCallHelpers::Equal, scratchGPR, CCallHelpers::TrustedImm32(ScopeOffset::invalidOffset)));
@@ -983 +983 @@
         state.failAndRepatch.append(jit.branch32(CCallHelpers::AboveOrEqual, propertyGPR, scratchGPR));
         state.failAndRepatch.append(jit.branchTestPtr(CCallHelpers::NonZero, CCallHelpers::Address(baseGPR, DirectArguments::offsetOfMappedArguments())));
-        jit.zeroExtend32ToPtr(propertyGPR, scratchGPR);
+        jit.zeroExtend32ToWord(propertyGPR, scratchGPR);
         jit.loadValue(CCallHelpers::BaseIndex(baseGPR, scratchGPR, CCallHelpers::TimesEight, DirectArguments::storageOffset()), valueRegs);
         state.succeed();
@@ -1114 +1114 @@
         jit.loadPtr(CCallHelpers::Address(scratch2GPR, StringImpl::dataOffset()), scratch2GPR);
         auto is16Bit = jit.branchTest32(CCallHelpers::Zero, scratchGPR, CCallHelpers::TrustedImm32(StringImpl::flagIs8Bit()));
-        jit.zeroExtend32ToPtr(propertyGPR, scratchGPR);
+        jit.zeroExtend32ToWord(propertyGPR, scratchGPR);
         jit.load8(CCallHelpers::BaseIndex(scratch2GPR, scratchGPR, CCallHelpers::TimesOne, 0), scratch2GPR);
         auto is8BitLoadDone = jit.jump();
         is16Bit.link(&jit);
-        jit.zeroExtend32ToPtr(propertyGPR, scratchGPR);
+        jit.zeroExtend32ToWord(propertyGPR, scratchGPR);
         jit.load16(CCallHelpers::BaseIndex(scratch2GPR, scratchGPR, CCallHelpers::TimesTwo, 0), scratch2GPR);
         is8BitLoadDone.link(&jit);
@@ -1178 +1178 @@
             isOutOfBounds = jit.branch32(CCallHelpers::AboveOrEqual, propertyGPR, CCallHelpers::Address(scratchGPR, ArrayStorage::vectorLengthOffset()));
 
-            jit.zeroExtend32ToPtr(propertyGPR, scratch2GPR);
+            jit.zeroExtend32ToWord(propertyGPR, scratch2GPR);
 #if USE(JSVALUE64)
             jit.loadValue(CCallHelpers::BaseIndex(scratchGPR, scratch2GPR, CCallHelpers::TimesEight, ArrayStorage::vectorOffset()), JSValueRegs(scratchGPR));
@@ -1212 +1212 @@
             jit.loadPtr(CCallHelpers::Address(baseGPR, JSObject::butterflyOffset()), scratchGPR);
             isOutOfBounds = jit.branch32(CCallHelpers::AboveOrEqual, propertyGPR, CCallHelpers::Address(scratchGPR, Butterfly::offsetOfPublicLength()));
-            jit.zeroExtend32ToPtr(propertyGPR, scratch2GPR);
+            jit.zeroExtend32ToWord(propertyGPR, scratch2GPR);
             if (m_type == IndexedDoubleLoad) {
                 RELEASE_ASSERT(state.scratchFPR != InvalidFPRReg);

trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp

@@ -735 +735 @@
 #if USE(JSVALUE64)
             jit.load64(scratch + index, GPRInfo::regT0);
-            jit.zeroExtend32ToPtr(GPRInfo::regT0, GPRInfo::regT0);
+            jit.zeroExtend32ToWord(GPRInfo::regT0, GPRInfo::regT0);
             jit.or64(GPRInfo::numberTagRegister, GPRInfo::regT0);
             jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

@@ -1711 +1711 @@
 
     // Load the character into scratchReg
-    m_jit.zeroExtend32ToPtr(startIndexGPR, startIndexGPR);
+    m_jit.zeroExtend32ToWord(startIndexGPR, startIndexGPR);
     auto is16Bit = m_jit.branchTest32(MacroAssembler::Zero, MacroAssembler::Address(temp2GPR, StringImpl::flagsOffset()), TrustedImm32(StringImpl::flagIs8Bit()));
 
@@ -2519 +2519 @@
         GPRReg op1GPR = op1.gpr();
         GPRReg resultGPR = result.gpr();
-        m_jit.zeroExtend32ToPtr(op1GPR, resultGPR);
+        m_jit.zeroExtend32ToWord(op1GPR, resultGPR);
         strictInt32Result(resultGPR, node, DataFormatInt32);
         return;
@@ -2604 +2604 @@
 
             isInteger.link(&m_jit);
-            m_jit.zeroExtend32ToPtr(gpr, resultGpr);
+            m_jit.zeroExtend32ToWord(gpr, resultGpr);
 
             converted.link(&m_jit);
@@ -2691 +2691 @@
             SpeculateInt32Operand op1(this, node->child1());
             GPRTemporary result(this, Reuse, op1);
-            m_jit.zeroExtend32ToPtr(op1.gpr(), result.gpr());
+            m_jit.zeroExtend32ToWord(op1.gpr(), result.gpr());
             strictInt52Result(result.gpr(), node);
             return;
@@ -3111 +3111 @@
     if (node->shouldSpeculateInt52()) {
         ASSERT(enableInt52());
-        m_jit.zeroExtend32ToPtr(resultReg, resultReg);
+        m_jit.zeroExtend32ToWord(resultReg, resultReg);
         strictInt52Result(resultReg, node);
         return;
@@ -5561 +5561 @@
             JITCompiler::Jump notNeg2ToThe31 =
                 m_jit.branch32(JITCompiler::NotEqual, op1GPR, TrustedImm32(-2147483647-1));
-            m_jit.zeroExtend32ToPtr(op1GPR, eax.gpr());
+            m_jit.zeroExtend32ToWord(op1GPR, eax.gpr());
             done.append(m_jit.jump());
         
@@ -8286 +8286 @@
 
         CCallHelpers::Jump skipLoop = m_jit.branch32(MacroAssembler::Equal, arrayLengthGPR, TrustedImm32(0));
-        m_jit.zeroExtend32ToPtr(arrayLengthGPR, currentLengthGPR);
+        m_jit.zeroExtend32ToWord(arrayLengthGPR, currentLengthGPR);
         m_jit.addPtr(Imm32(sizeof(Register) * node->numberOfArgumentsToSkip()), argumentsStartGPR);
 
@@ -8956 +8956 @@
 
     m_jit.loadPtr(MacroAssembler::Address(resultGPR, JSObject::butterflyOffset()), resultButterfly);
-    m_jit.zeroExtend32ToPtr(tempGPR, tempGPR);
-    m_jit.zeroExtend32ToPtr(loadIndex, loadIndex);
+    m_jit.zeroExtend32ToWord(tempGPR, tempGPR);
+    m_jit.zeroExtend32ToWord(loadIndex, loadIndex);
     auto done = m_jit.branchPtr(MacroAssembler::AboveOrEqual, loadIndex, tempGPR);
 
@@ -9014 +9014 @@
 #endif
 
-            m_jit.zeroExtend32ToPtr(lengthGPR, lengthGPR);
-            m_jit.zeroExtend32ToPtr(indexGPR, indexGPR);
+            m_jit.zeroExtend32ToWord(lengthGPR, lengthGPR);
+            m_jit.zeroExtend32ToWord(indexGPR, indexGPR);
 
             auto loop = m_jit.label();
@@ -9122 +9122 @@
 #endif
 
-        m_jit.zeroExtend32ToPtr(lengthGPR, lengthGPR);
-        m_jit.zeroExtend32ToPtr(indexGPR, indexGPR);
+        m_jit.zeroExtend32ToWord(lengthGPR, lengthGPR);
+        m_jit.zeroExtend32ToWord(indexGPR, indexGPR);
 
         auto loop = m_jit.label();
@@ -10435 +10435 @@
 #if CPU(ARM64E)
     // sizeGPR is still boxed as a number and there is no 32-bit variant of the PAC instructions.
-    m_jit.zeroExtend32ToPtr(sizeGPR, scratchGPR);
+    m_jit.zeroExtend32ToWord(sizeGPR, scratchGPR);
     m_jit.tagArrayPtr(scratchGPR, storageGPR);
 #endif
@@ -12472 +12472 @@
     RELEASE_ASSERT(RegisterSet(storageResultGPR, sizeGPR, scratch1, scratch2, scratch3).numberOfSetGPRs() == 5);
     ASSERT((1 << 3) == sizeof(JSValue));
-    m_jit.zeroExtend32ToPtr(sizeGPR, scratch1);
+    m_jit.zeroExtend32ToWord(sizeGPR, scratch1);
     m_jit.lshift32(TrustedImm32(3), scratch1);
     m_jit.add32(TrustedImm32(sizeof(IndexingHeader)), scratch1, scratch2);
@@ -13788 +13788 @@
     if (node->child1().useKind() == WeakSetObjectUse) {
         static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKey>) == sizeof(void*), "");
-        m_jit.zeroExtend32ToPtr(indexGPR, bucketGPR);
+        m_jit.zeroExtend32ToWord(indexGPR, bucketGPR);
         m_jit.lshiftPtr(MacroAssembler::Imm32(sizeof(void*) == 4 ? 2 : 3), bucketGPR);
         m_jit.addPtr(bufferGPR, bucketGPR);
@@ -13794 +13794 @@
         ASSERT(node->child1().useKind() == WeakMapObjectUse);
         static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKeyValue>) == 16, "");
-        m_jit.zeroExtend32ToPtr(indexGPR, bucketGPR);
+        m_jit.zeroExtend32ToWord(indexGPR, bucketGPR);
         m_jit.lshiftPtr(MacroAssembler::Imm32(4), bucketGPR);
         m_jit.addPtr(bufferGPR, bucketGPR);
@@ -14037 +14037 @@
 void SpeculativeJIT::emitInitializeButterfly(GPRReg storageGPR, GPRReg sizeGPR, JSValueRegs emptyValueRegs, GPRReg scratchGPR)
 {
-    m_jit.zeroExtend32ToPtr(sizeGPR, scratchGPR);
+    m_jit.zeroExtend32ToWord(sizeGPR, scratchGPR);
     MacroAssembler::Jump done = m_jit.branchTest32(MacroAssembler::Zero, scratchGPR);
     MacroAssembler::Label loop = m_jit.label();

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

@@ -1024 +1024 @@
                 result = gpr;
             }
-            m_jit.zeroExtend32ToPtr(gpr, result);
+            m_jit.zeroExtend32ToWord(gpr, result);
             returnFormat = DataFormatInt32;
             return result;
@@ -5088 +5088 @@
         DataViewData data = node->dataViewData();
 
-        m_jit.zeroExtend32ToPtr(indexGPR, t2);
+        m_jit.zeroExtend32ToWord(indexGPR, t2);
         if (data.byteSize > 1)
             m_jit.add64(TrustedImm32(data.byteSize - 1), t2);
@@ -5098 +5098 @@
         cageTypedArrayStorage(dataViewGPR, t2);
 
-        m_jit.zeroExtend32ToPtr(indexGPR, t1);
+        m_jit.zeroExtend32ToWord(indexGPR, t1);
         auto baseIndex = JITCompiler::BaseIndex(t2, t1, MacroAssembler::TimesOne);
 
@@ -5289 +5289 @@
         GPRReg isLittleEndianGPR = isLittleEndianOperand ? isLittleEndianOperand->gpr() : InvalidGPRReg;
 
-        m_jit.zeroExtend32ToPtr(indexGPR, t2);
+        m_jit.zeroExtend32ToWord(indexGPR, t2);
         if (data.byteSize > 1)
             m_jit.add64(TrustedImm32(data.byteSize - 1), t2);
@@ -5299 +5299 @@
         cageTypedArrayStorage(dataViewGPR, t2);
 
-        m_jit.zeroExtend32ToPtr(indexGPR, t1);
+        m_jit.zeroExtend32ToWord(indexGPR, t1);
         auto baseIndex = JITCompiler::BaseIndex(t2, t1, MacroAssembler::TimesOne);
 
@@ -5401 +5401 @@
 
                 auto emitBigEndianCode = [&] {
-                    m_jit.zeroExtend32ToPtr(valueGPR, t3);
+                    m_jit.zeroExtend32ToWord(valueGPR, t3);
                     m_jit.byteSwap32(t3);
                     m_jit.store32(t3, baseIndex);

trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp

@@ -53 +53 @@
     switch (format) {
     case DataFormatInt32: {
-        jit.zeroExtend32ToPtr(value, value);
+        jit.zeroExtend32ToWord(value, value);
         jit.or64(GPRInfo::numberTagRegister, value);
         break;
@@ -74 +74 @@
 
     case DataFormatBoolean: {
-        jit.zeroExtend32ToPtr(value, value);
+        jit.zeroExtend32ToWord(value, value);
         jit.or32(MacroAssembler::TrustedImm32(JSValue::ValueFalse), value);
         break;

trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

@@ -1481 +1481 @@
         
         isInt32.link(this);
-        zeroExtend32ToPtr(source, target);
+        zeroExtend32ToWord(source, target);
         or64(GPRInfo::numberTagRegister, target);
         

trunk/Source/JavaScriptCore/jit/CallFrameShuffler64.cpp

@@ -85 +85 @@
             if (verbose)
                 dataLog("   * Boxing ", cachedRecovery.recovery());
-            m_jit.zeroExtend32ToPtr(
+            m_jit.zeroExtend32ToWord(
                 cachedRecovery.recovery().gpr(),
                 cachedRecovery.recovery().gpr());

trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

@@ -1437 +1437 @@
     // to 64-bits is necessary since it's used in the address calculation. We zero extend rather than sign
     // extending since it makes it easier to re-tag the value in the slow case.
-    zeroExtend32ToPtr(regT1, regT1);
+    zeroExtend32ToWord(regT1, regT1);
 
     emitJumpSlowCaseIfNotJSCell(regT0, base);

trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

@@ -1216 +1216 @@
     // to 64-bits is necessary since it's used in the address calculation. We zero extend rather than sign
     // extending since it makes it easier to re-tag the value in the slow case.
-    zeroExtend32ToPtr(regT1, regT1);
+    zeroExtend32ToWord(regT1, regT1);
 
     emitArrayProfilingSiteWithCell(regT0, regT2, profile);

trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

@@ -125 +125 @@
         addSlowCase(notIndex);
         // See comment in op_get_by_val.
-        zeroExtend32ToPtr(regT1, regT1);
+        zeroExtend32ToWord(regT1, regT1);
     }
     emitArrayProfilingSiteWithCell(regT0, regT2, profile);

trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h

@@ -112 +112 @@
         load64(addressFor(virtualRegister), dst);
         Jump notInt32 = branchIfNotInt32(dst);
-        zeroExtend32ToPtr(dst, dst);
+        zeroExtend32ToWord(dst, dst);
         return notInt32;
     }

trunk/Source/JavaScriptCore/wasm/js/JSToWasm.cpp

@@ -50 +50 @@
         break;
     case Wasm::I32:
-        jit.zeroExtend32ToPtr(src.gpr(), dst.payloadGPR());
+        jit.zeroExtend32ToWord(src.gpr(), dst.payloadGPR());
         jit.boxInt32(dst.payloadGPR(), dst, DoNotHaveTagRegisters);
         break;

trunk/Source/JavaScriptCore/wasm/js/WasmToJS.cpp

@@ -146 +146 @@
                 ++marshalledGPRs;
                 if (argType == I32) {
-                    jit.zeroExtend32ToPtr(gprReg, gprReg); // Clear non-int32 and non-tag bits.
+                    jit.zeroExtend32ToWord(gprReg, gprReg); // Clear non-int32 and non-tag bits.
                     jit.boxInt32(gprReg, JSValueRegs(gprReg), DoNotHaveTagRegisters);
                 }
@@ -295 +295 @@
             slowPath.append(jit.branchIfNotNumber(GPRInfo::returnValueGPR, DoNotHaveTagRegisters));
             slowPath.append(jit.branchIfNotInt32(JSValueRegs(GPRInfo::returnValueGPR), DoNotHaveTagRegisters));
-            jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, dest);
+            jit.zeroExtend32ToWord(GPRInfo::returnValueGPR, dest);
             done.append(jit.jump());
 

trunk/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp

@@ -263 +263 @@
                 jit.store32(scratchGPR, calleeFrame.withOffset(wasmCallInfo.params[i].offsetFromSP()));
             else
-                jit.zeroExtend32ToPtr(scratchGPR, wasmCallInfo.params[i].gpr());
+                jit.zeroExtend32ToWord(scratchGPR, wasmCallInfo.params[i].gpr());
             break;
         }

trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp

@@ -3738 +3738 @@
         }
         // The ABI doesn't guarantee the upper bits are zero on unsigned arguments, so clear them ourselves.
-        zeroExtend32ToPtr(index, index);
-        zeroExtend32ToPtr(length, length);
+        zeroExtend32ToWord(index, index);
+        zeroExtend32ToWord(length, length);
 #if OS(WINDOWS)
         if (compileMode == IncludeSubpatterns)
@@ -3756 +3756 @@
 
         // The ABI doesn't guarantee the upper bits are zero on unsigned arguments, so clear them ourselves.
-        zeroExtend32ToPtr(index, index);
-        zeroExtend32ToPtr(length, length);
+        zeroExtend32ToWord(index, index);
+        zeroExtend32ToWord(length, length);
 #elif CPU(ARM_THUMB2)
         push(ARMRegisters::r4);