<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[283970] trunk/Source</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/283970">283970</a></dd>
<dt>Author</dt> <dd>sbarati@apple.com</dd>
<dt>Date</dt> <dd>2021-10-11 23:32:55 -0700 (Mon, 11 Oct 2021)</dd>
</dl>

<h3>Log Message</h3>
<pre>Remove ImplicitAddress
https://bugs.webkit.org/show_bug.cgi?id=230820
<rdar://problem/83826318>

Reviewed by Yusuke Suzuki.

Source/JavaScriptCore:

Because we rely on implicit conversion from RegisterID to int values,
some compilers (aka MSVC) might convert a constant RegisterID that's passed in
to nullptr instead of calling the implicit constructor in ImplicitAddress.

For example, I got bit by this when I had code that did:
loadPtr(regT0, xyz)

This called the loadPtr(void*, RegisterID) function with nullptr passed as
the first argument instead of the loadPtr(ImplicitAddress, RegisterID)
function.

Let's avoid any such problems in the future by just not using ImplicitAddress.

* assembler/AbstractMacroAssembler.h:
(JSC::AbstractMacroAssembler::ImplicitAddress::ImplicitAddress): Deleted.
* assembler/MacroAssembler.h:
(JSC::MacroAssembler::pushToSave):
(JSC::MacroAssembler::popToRestore):
(JSC::MacroAssembler::loadPtr):
(JSC::MacroAssembler::storePtr):
* assembler/MacroAssemblerARM64.h:
(JSC::MacroAssemblerARM64::load64):
(JSC::MacroAssemblerARM64::load32):
(JSC::MacroAssemblerARM64::load16):
(JSC::MacroAssemblerARM64::load16Unaligned):
(JSC::MacroAssemblerARM64::load16SignedExtendTo32):
(JSC::MacroAssemblerARM64::load8):
(JSC::MacroAssemblerARM64::load8SignedExtendTo32):
(JSC::MacroAssemblerARM64::store64):
(JSC::MacroAssemblerARM64::store32):
(JSC::MacroAssemblerARM64::store16):
(JSC::MacroAssemblerARM64::store8):
(JSC::MacroAssemblerARM64::loadDouble):
(JSC::MacroAssemblerARM64::loadFloat):
(JSC::MacroAssemblerARM64::storeDouble):
(JSC::MacroAssemblerARM64::storeFloat):
(JSC::MacroAssemblerARM64::pushToSaveImmediateWithoutTouchingRegisters):
(JSC::MacroAssemblerARM64::popToRestore):
(JSC::MacroAssemblerARM64::pushToSave):
(JSC::MacroAssemblerARM64::storePtrWithPatch):
(JSC::MacroAssemblerARM64::loadAcq8SignedExtendTo32):
(JSC::MacroAssemblerARM64::loadAcq8):
(JSC::MacroAssemblerARM64::storeRel8):
(JSC::MacroAssemblerARM64::loadAcq16SignedExtendTo32):
(JSC::MacroAssemblerARM64::loadAcq16):
(JSC::MacroAssemblerARM64::storeRel16):
(JSC::MacroAssemblerARM64::loadAcq32):
(JSC::MacroAssemblerARM64::loadAcq64):
(JSC::MacroAssemblerARM64::storeRel32):
(JSC::MacroAssemblerARM64::storeRel64):
(JSC::MacroAssemblerARM64::loadLink8):
(JSC::MacroAssemblerARM64::loadLinkAcq8):
(JSC::MacroAssemblerARM64::storeCond8):
(JSC::MacroAssemblerARM64::storeCondRel8):
(JSC::MacroAssemblerARM64::loadLink16):
(JSC::MacroAssemblerARM64::loadLinkAcq16):
(JSC::MacroAssemblerARM64::storeCond16):
(JSC::MacroAssemblerARM64::storeCondRel16):
(JSC::MacroAssemblerARM64::loadLink32):
(JSC::MacroAssemblerARM64::loadLinkAcq32):
(JSC::MacroAssemblerARM64::storeCond32):
(JSC::MacroAssemblerARM64::storeCondRel32):
(JSC::MacroAssemblerARM64::loadLink64):
(JSC::MacroAssemblerARM64::loadLinkAcq64):
(JSC::MacroAssemblerARM64::storeCond64):
(JSC::MacroAssemblerARM64::storeCondRel64):
(JSC::MacroAssemblerARM64::extractSimpleAddress):
* assembler/MacroAssemblerARM64E.h:
(JSC::MacroAssemblerARM64E::atomicXchgAdd8):
(JSC::MacroAssemblerARM64E::atomicXchgAdd16):
(JSC::MacroAssemblerARM64E::atomicXchgAdd32):
(JSC::MacroAssemblerARM64E::atomicXchgAdd64):
(JSC::MacroAssemblerARM64E::atomicXchgXor8):
(JSC::MacroAssemblerARM64E::atomicXchgXor16):
(JSC::MacroAssemblerARM64E::atomicXchgXor32):
(JSC::MacroAssemblerARM64E::atomicXchgXor64):
(JSC::MacroAssemblerARM64E::atomicXchgOr8):
(JSC::MacroAssemblerARM64E::atomicXchgOr16):
(JSC::MacroAssemblerARM64E::atomicXchgOr32):
(JSC::MacroAssemblerARM64E::atomicXchgOr64):
(JSC::MacroAssemblerARM64E::atomicXchgClear8):
(JSC::MacroAssemblerARM64E::atomicXchgClear16):
(JSC::MacroAssemblerARM64E::atomicXchgClear32):
(JSC::MacroAssemblerARM64E::atomicXchgClear64):
(JSC::MacroAssemblerARM64E::atomicXchg8):
(JSC::MacroAssemblerARM64E::atomicXchg16):
(JSC::MacroAssemblerARM64E::atomicXchg32):
(JSC::MacroAssemblerARM64E::atomicXchg64):
(JSC::MacroAssemblerARM64E::atomicStrongCAS8):
(JSC::MacroAssemblerARM64E::atomicStrongCAS16):
(JSC::MacroAssemblerARM64E::atomicStrongCAS32):
(JSC::MacroAssemblerARM64E::atomicStrongCAS64):
* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::or8):
(JSC::MacroAssemblerARMv7::or16):
(JSC::MacroAssemblerARMv7::or32):
(JSC::MacroAssemblerARMv7::load32):
(JSC::MacroAssemblerARMv7::load8):
(JSC::MacroAssemblerARMv7::load8SignedExtendTo32):
(JSC::MacroAssemblerARMv7::load16):
(JSC::MacroAssemblerARMv7::load16SignedExtendTo32):
(JSC::MacroAssemblerARMv7::store32):
(JSC::MacroAssemblerARMv7::store16):
(JSC::MacroAssemblerARMv7::loadDouble):
(JSC::MacroAssemblerARMv7::loadFloat):
(JSC::MacroAssemblerARMv7::storeDouble):
(JSC::MacroAssemblerARMv7::storeFloat):
(JSC::MacroAssemblerARMv7::storePtrWithPatch):
* assembler/MacroAssemblerMIPS.h:
(JSC::MacroAssemblerMIPS::load8):
(JSC::MacroAssemblerMIPS::load8SignedExtendTo32):
(JSC::MacroAssemblerMIPS::load32):
(JSC::MacroAssemblerMIPS::load16):
(JSC::MacroAssemblerMIPS::store8):
(JSC::MacroAssemblerMIPS::store16):
(JSC::MacroAssemblerMIPS::store32):
(JSC::MacroAssemblerMIPS::storePtrWithPatch):
(JSC::MacroAssemblerMIPS::loadFloat):
(JSC::MacroAssemblerMIPS::loadDouble):
(JSC::MacroAssemblerMIPS::storeFloat):
(JSC::MacroAssemblerMIPS::storeDouble):
* assembler/MacroAssemblerX86Common.h:
(JSC::MacroAssemblerX86Common::load32):
(JSC::MacroAssemblerX86Common::load16Unaligned):
(JSC::MacroAssemblerX86Common::load8):
(JSC::MacroAssemblerX86Common::load8SignedExtendTo32):
(JSC::MacroAssemblerX86Common::load16):
(JSC::MacroAssemblerX86Common::store32):
(JSC::MacroAssemblerX86Common::store16):
(JSC::MacroAssemblerX86Common::loadDouble):
(JSC::MacroAssemblerX86Common::loadFloat):
(JSC::MacroAssemblerX86Common::storeDouble):
(JSC::MacroAssemblerX86Common::storeFloat):
* assembler/MacroAssemblerX86_64.h:
(JSC::MacroAssemblerX86_64::load8):
(JSC::MacroAssemblerX86_64::load32):
(JSC::MacroAssemblerX86_64::store32):
(JSC::MacroAssemblerX86_64::load64):
(JSC::MacroAssemblerX86_64::store64):
(JSC::MacroAssemblerX86_64::storePtrWithPatch):
* assembler/testmasm.cpp:
(JSC::testBranchTruncateDoubleToInt32):
(JSC::testLoadPrePostIndex32):
(JSC::testLoadPrePostIndex64):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::compileStringSlice):
(JSC::DFG::SpeculativeJIT::compileGetByValOnString):
(JSC::DFG::SpeculativeJIT::compileClearCatchLocals):
* ftl/FTLLocation.cpp:
(JSC::FTL::Location::restoreInto const):
* ftl/FTLThunks.cpp:
(JSC::FTL::genericGenerationThunkGenerator):
* jit/AssemblyHelpers.cpp:
(JSC::AssemblyHelpers::debugCall):
(JSC::AssemblyHelpers::sanitizeStackInline):
* jit/JITPropertyAccess.cpp:
(JSC::JIT::emitGetVarFromIndirectPointer):
* jit/ThunkGenerators.cpp:
(JSC::arityFixupGenerator):
* wasm/WasmBinding.cpp:
(JSC::Wasm::wasmToWasm):
* yarr/YarrJIT.cpp:

Source/WebCore:

* cssjit/SelectorCompiler.cpp:
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateSelectorChecker):</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerAbstractMacroAssemblerh">trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerh">trunk/Source/JavaScriptCore/assembler/MacroAssembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64Eh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64E.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86_64h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblertestmasmcpp">trunk/Source/JavaScriptCore/assembler/testmasm.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp">trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLLocationcpp">trunk/Source/JavaScriptCore/ftl/FTLLocation.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLThunkscpp">trunk/Source/JavaScriptCore/ftl/FTLThunks.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitAssemblyHelperscpp">trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITPropertyAccesscpp">trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitThunkGeneratorscpp">trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmWasmBindingcpp">trunk/Source/JavaScriptCore/wasm/WasmBinding.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreyarrYarrJITcpp">trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssjitSelectorCompilercpp">trunk/Source/WebCore/cssjit/SelectorCompiler.cpp</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog    2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/ChangeLog       2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -1,5 +1,176 @@
</span><span class="cx"> 2021-10-11  Saam Barati  <sbarati@apple.com>
</span><span class="cx"> 
</span><ins>+        Remove ImplicitAddress
+        https://bugs.webkit.org/show_bug.cgi?id=230820
+        <rdar://problem/83826318>
+
+        Reviewed by Yusuke Suzuki.
+
+        Because we rely on implicit conversion from RegisterID to int values,
+        some compilers (aka MSVC) might convert a constant RegisterID that's passed in
+        to nullptr instead of calling the implicit constructor in ImplicitAddress.
+        
+        For example, I got bit by this when I had code that did:
+        loadPtr(regT0, xyz)
+        
+        This called the loadPtr(void*, RegisterID) function with nullptr passed as
+        the first argument instead of the loadPtr(ImplicitAddress, RegisterID)
+        function.
+        
+        Let's avoid any such problems in the future by just not using ImplicitAddress.
+
+        * assembler/AbstractMacroAssembler.h:
+        (JSC::AbstractMacroAssembler::ImplicitAddress::ImplicitAddress): Deleted.
+        * assembler/MacroAssembler.h:
+        (JSC::MacroAssembler::pushToSave):
+        (JSC::MacroAssembler::popToRestore):
+        (JSC::MacroAssembler::loadPtr):
+        (JSC::MacroAssembler::storePtr):
+        * assembler/MacroAssemblerARM64.h:
+        (JSC::MacroAssemblerARM64::load64):
+        (JSC::MacroAssemblerARM64::load32):
+        (JSC::MacroAssemblerARM64::load16):
+        (JSC::MacroAssemblerARM64::load16Unaligned):
+        (JSC::MacroAssemblerARM64::load16SignedExtendTo32):
+        (JSC::MacroAssemblerARM64::load8):
+        (JSC::MacroAssemblerARM64::load8SignedExtendTo32):
+        (JSC::MacroAssemblerARM64::store64):
+        (JSC::MacroAssemblerARM64::store32):
+        (JSC::MacroAssemblerARM64::store16):
+        (JSC::MacroAssemblerARM64::store8):
+        (JSC::MacroAssemblerARM64::loadDouble):
+        (JSC::MacroAssemblerARM64::loadFloat):
+        (JSC::MacroAssemblerARM64::storeDouble):
+        (JSC::MacroAssemblerARM64::storeFloat):
+        (JSC::MacroAssemblerARM64::pushToSaveImmediateWithoutTouchingRegisters):
+        (JSC::MacroAssemblerARM64::popToRestore):
+        (JSC::MacroAssemblerARM64::pushToSave):
+        (JSC::MacroAssemblerARM64::storePtrWithPatch):
+        (JSC::MacroAssemblerARM64::loadAcq8SignedExtendTo32):
+        (JSC::MacroAssemblerARM64::loadAcq8):
+        (JSC::MacroAssemblerARM64::storeRel8):
+        (JSC::MacroAssemblerARM64::loadAcq16SignedExtendTo32):
+        (JSC::MacroAssemblerARM64::loadAcq16):
+        (JSC::MacroAssemblerARM64::storeRel16):
+        (JSC::MacroAssemblerARM64::loadAcq32):
+        (JSC::MacroAssemblerARM64::loadAcq64):
+        (JSC::MacroAssemblerARM64::storeRel32):
+        (JSC::MacroAssemblerARM64::storeRel64):
+        (JSC::MacroAssemblerARM64::loadLink8):
+        (JSC::MacroAssemblerARM64::loadLinkAcq8):
+        (JSC::MacroAssemblerARM64::storeCond8):
+        (JSC::MacroAssemblerARM64::storeCondRel8):
+        (JSC::MacroAssemblerARM64::loadLink16):
+        (JSC::MacroAssemblerARM64::loadLinkAcq16):
+        (JSC::MacroAssemblerARM64::storeCond16):
+        (JSC::MacroAssemblerARM64::storeCondRel16):
+        (JSC::MacroAssemblerARM64::loadLink32):
+        (JSC::MacroAssemblerARM64::loadLinkAcq32):
+        (JSC::MacroAssemblerARM64::storeCond32):
+        (JSC::MacroAssemblerARM64::storeCondRel32):
+        (JSC::MacroAssemblerARM64::loadLink64):
+        (JSC::MacroAssemblerARM64::loadLinkAcq64):
+        (JSC::MacroAssemblerARM64::storeCond64):
+        (JSC::MacroAssemblerARM64::storeCondRel64):
+        (JSC::MacroAssemblerARM64::extractSimpleAddress):
+        * assembler/MacroAssemblerARM64E.h:
+        (JSC::MacroAssemblerARM64E::atomicXchgAdd8):
+        (JSC::MacroAssemblerARM64E::atomicXchgAdd16):
+        (JSC::MacroAssemblerARM64E::atomicXchgAdd32):
+        (JSC::MacroAssemblerARM64E::atomicXchgAdd64):
+        (JSC::MacroAssemblerARM64E::atomicXchgXor8):
+        (JSC::MacroAssemblerARM64E::atomicXchgXor16):
+        (JSC::MacroAssemblerARM64E::atomicXchgXor32):
+        (JSC::MacroAssemblerARM64E::atomicXchgXor64):
+        (JSC::MacroAssemblerARM64E::atomicXchgOr8):
+        (JSC::MacroAssemblerARM64E::atomicXchgOr16):
+        (JSC::MacroAssemblerARM64E::atomicXchgOr32):
+        (JSC::MacroAssemblerARM64E::atomicXchgOr64):
+        (JSC::MacroAssemblerARM64E::atomicXchgClear8):
+        (JSC::MacroAssemblerARM64E::atomicXchgClear16):
+        (JSC::MacroAssemblerARM64E::atomicXchgClear32):
+        (JSC::MacroAssemblerARM64E::atomicXchgClear64):
+        (JSC::MacroAssemblerARM64E::atomicXchg8):
+        (JSC::MacroAssemblerARM64E::atomicXchg16):
+        (JSC::MacroAssemblerARM64E::atomicXchg32):
+        (JSC::MacroAssemblerARM64E::atomicXchg64):
+        (JSC::MacroAssemblerARM64E::atomicStrongCAS8):
+        (JSC::MacroAssemblerARM64E::atomicStrongCAS16):
+        (JSC::MacroAssemblerARM64E::atomicStrongCAS32):
+        (JSC::MacroAssemblerARM64E::atomicStrongCAS64):
+        * assembler/MacroAssemblerARMv7.h:
+        (JSC::MacroAssemblerARMv7::or8):
+        (JSC::MacroAssemblerARMv7::or16):
+        (JSC::MacroAssemblerARMv7::or32):
+        (JSC::MacroAssemblerARMv7::load32):
+        (JSC::MacroAssemblerARMv7::load8):
+        (JSC::MacroAssemblerARMv7::load8SignedExtendTo32):
+        (JSC::MacroAssemblerARMv7::load16):
+        (JSC::MacroAssemblerARMv7::load16SignedExtendTo32):
+        (JSC::MacroAssemblerARMv7::store32):
+        (JSC::MacroAssemblerARMv7::store16):
+        (JSC::MacroAssemblerARMv7::loadDouble):
+        (JSC::MacroAssemblerARMv7::loadFloat):
+        (JSC::MacroAssemblerARMv7::storeDouble):
+        (JSC::MacroAssemblerARMv7::storeFloat):
+        (JSC::MacroAssemblerARMv7::storePtrWithPatch):
+        * assembler/MacroAssemblerMIPS.h:
+        (JSC::MacroAssemblerMIPS::load8):
+        (JSC::MacroAssemblerMIPS::load8SignedExtendTo32):
+        (JSC::MacroAssemblerMIPS::load32):
+        (JSC::MacroAssemblerMIPS::load16):
+        (JSC::MacroAssemblerMIPS::store8):
+        (JSC::MacroAssemblerMIPS::store16):
+        (JSC::MacroAssemblerMIPS::store32):
+        (JSC::MacroAssemblerMIPS::storePtrWithPatch):
+        (JSC::MacroAssemblerMIPS::loadFloat):
+        (JSC::MacroAssemblerMIPS::loadDouble):
+        (JSC::MacroAssemblerMIPS::storeFloat):
+        (JSC::MacroAssemblerMIPS::storeDouble):
+        * assembler/MacroAssemblerX86Common.h:
+        (JSC::MacroAssemblerX86Common::load32):
+        (JSC::MacroAssemblerX86Common::load16Unaligned):
+        (JSC::MacroAssemblerX86Common::load8):
+        (JSC::MacroAssemblerX86Common::load8SignedExtendTo32):
+        (JSC::MacroAssemblerX86Common::load16):
+        (JSC::MacroAssemblerX86Common::store32):
+        (JSC::MacroAssemblerX86Common::store16):
+        (JSC::MacroAssemblerX86Common::loadDouble):
+        (JSC::MacroAssemblerX86Common::loadFloat):
+        (JSC::MacroAssemblerX86Common::storeDouble):
+        (JSC::MacroAssemblerX86Common::storeFloat):
+        * assembler/MacroAssemblerX86_64.h:
+        (JSC::MacroAssemblerX86_64::load8):
+        (JSC::MacroAssemblerX86_64::load32):
+        (JSC::MacroAssemblerX86_64::store32):
+        (JSC::MacroAssemblerX86_64::load64):
+        (JSC::MacroAssemblerX86_64::store64):
+        (JSC::MacroAssemblerX86_64::storePtrWithPatch):
+        * assembler/testmasm.cpp:
+        (JSC::testBranchTruncateDoubleToInt32):
+        (JSC::testLoadPrePostIndex32):
+        (JSC::testLoadPrePostIndex64):
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::compileStringSlice):
+        (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
+        (JSC::DFG::SpeculativeJIT::compileClearCatchLocals):
+        * ftl/FTLLocation.cpp:
+        (JSC::FTL::Location::restoreInto const):
+        * ftl/FTLThunks.cpp:
+        (JSC::FTL::genericGenerationThunkGenerator):
+        * jit/AssemblyHelpers.cpp:
+        (JSC::AssemblyHelpers::debugCall):
+        (JSC::AssemblyHelpers::sanitizeStackInline):
+        * jit/JITPropertyAccess.cpp:
+        (JSC::JIT::emitGetVarFromIndirectPointer):
+        * jit/ThunkGenerators.cpp:
+        (JSC::arityFixupGenerator):
+        * wasm/WasmBinding.cpp:
+        (JSC::Wasm::wasmToWasm):
+        * yarr/YarrJIT.cpp:
+
+2021-10-11  Saam Barati  <sbarati@apple.com>
+
</ins><span class="cx">         Share more code that uses ScratchRegisterAllocator in the ICs
</span><span class="cx">         https://bugs.webkit.org/show_bug.cgi?id=231125
</span><span class="cx">         <rdar://problem/84066374>
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerAbstractMacroAssemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h   2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h      2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -179,39 +179,6 @@
</span><span class="cx">         intptr_t offset;
</span><span class="cx">     };
</span><span class="cx"> 
</span><del>-    // ImplicitAddress:
-    //
-    // This class is used for explicit 'load' and 'store' operations
-    // (as opposed to situations in which a memory operand is provided
-    // to a generic operation, such as an integer arithmetic instruction).
-    //
-    // In the case of a load (or store) operation we want to permit
-    // addresses to be implicitly constructed, e.g. the two calls:
-    //
-    //     load32(Address(addrReg), destReg);
-    //     load32(addrReg, destReg);
-    //
-    // Are equivalent, and the explicit wrapping of the Address in the former
-    // is unnecessary.
-    struct ImplicitAddress {
-        ImplicitAddress(RegisterID base)
-            : base(base)
-            , offset(0)
-        {
-            ASSERT(base != RegisterID::InvalidGPRReg);
-        }
-
-        ImplicitAddress(Address address)
-            : base(address.base)
-            , offset(address.offset)
-        {
-            ASSERT(base != RegisterID::InvalidGPRReg);
-        }
-
-        RegisterID base;
-        int32_t offset;
-    };
-
</del><span class="cx">     // BaseIndex:
</span><span class="cx">     //
</span><span class="cx">     // Describes a complex addressing mode.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssembler.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssembler.h   2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssembler.h      2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -329,11 +329,11 @@
</span><span class="cx">     void pushToSave(FPRegisterID src)
</span><span class="cx">     {
</span><span class="cx">         subPtr(TrustedImm32(sizeof(double)), stackPointerRegister);
</span><del>-        storeDouble(src, stackPointerRegister);
</del><ins>+        storeDouble(src, Address(stackPointerRegister));
</ins><span class="cx">     }
</span><span class="cx">     void popToRestore(FPRegisterID dest)
</span><span class="cx">     {
</span><del>-        loadDouble(stackPointerRegister, dest);
</del><ins>+        loadDouble(Address(stackPointerRegister), dest);
</ins><span class="cx">         addPtr(TrustedImm32(sizeof(double)), stackPointerRegister);
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="lines">@@ -702,7 +702,7 @@
</span><span class="cx">         xor32(src, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadPtr(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadPtr(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         load32(address, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -752,7 +752,7 @@
</span><span class="cx">         compare32(cond, left, right, dest);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storePtr(RegisterID src, ImplicitAddress address)
</del><ins>+    void storePtr(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store32(src, address);
</span><span class="cx">     }
</span><span class="lines">@@ -767,7 +767,7 @@
</span><span class="cx">         store32(src, address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storePtr(TrustedImmPtr imm, ImplicitAddress address)
</del><ins>+    void storePtr(TrustedImmPtr imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store32(TrustedImm32(imm), address);
</span><span class="cx">     }
</span><span class="lines">@@ -782,7 +782,7 @@
</span><span class="cx">         store32(TrustedImm32(imm), address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storePtr(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void storePtr(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store32(imm, address);
</span><span class="cx">     }
</span><span class="lines">@@ -1050,7 +1050,7 @@
</span><span class="cx">         xor64(TrustedImm64(imm), srcDest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadPtr(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadPtr(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         load64(address, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1089,7 +1089,7 @@
</span><span class="cx">         return load64WithCompactAddressOffsetPatch(address, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storePtr(RegisterID src, ImplicitAddress address)
</del><ins>+    void storePtr(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store64(src, address);
</span><span class="cx">     }
</span><span class="lines">@@ -1104,12 +1104,12 @@
</span><span class="cx">         store64(src, address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storePtr(TrustedImmPtr imm, ImplicitAddress address)
</del><ins>+    void storePtr(TrustedImmPtr imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store64(TrustedImm64(imm), address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storePtr(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void storePtr(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store64(imm, address);
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h      2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -1522,7 +1522,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load64(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load64(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadWithOffset<64>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1677,7 +1677,7 @@
</span><span class="cx">         return result;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadWithOffset<32>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1736,7 +1736,7 @@
</span><span class="cx">         load32(address, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadWithOffset<16>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1772,7 +1772,7 @@
</span><span class="cx">         load<16>(address, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load16Unaligned(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16Unaligned(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         load16(address, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1782,7 +1782,7 @@
</span><span class="cx">         load16(address, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load16SignedExtendTo32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16SignedExtendTo32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadSignedWithOffset<16>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1815,7 +1815,7 @@
</span><span class="cx">         m_assembler.sxth<32>(dest, src);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadWithOffset<8>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1851,7 +1851,7 @@
</span><span class="cx">         m_assembler.ldrb(dest, src, simm);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8SignedExtendTo32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8SignedExtendTo32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadSignedWithOffset<8>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1892,7 +1892,7 @@
</span><span class="cx">         m_assembler.sxtb<32>(dest, src);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store64(RegisterID src, ImplicitAddress address)
</del><ins>+    void store64(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (tryStoreWithOffset<64>(src, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -1941,12 +1941,12 @@
</span><span class="cx">         store64(dataTempRegister, address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store64(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store64(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store64(TrustedImm64(imm.m_value), address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store64(TrustedImm64 imm, ImplicitAddress address)
</del><ins>+    void store64(TrustedImm64 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (!imm.m_value) {
</span><span class="cx">             store64(ARM64Registers::zr, address);
</span><span class="lines">@@ -2036,7 +2036,7 @@
</span><span class="cx">         storeDouble(src2, Address(dest, offset.m_value + 8));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(RegisterID src, ImplicitAddress address)
</del><ins>+    void store32(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (tryStoreWithOffset<32>(src, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2064,7 +2064,7 @@
</span><span class="cx">         store<32>(src, address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store32(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (!imm.m_value) {
</span><span class="cx">             store32(ARM64Registers::zr, address);
</span><span class="lines">@@ -2115,7 +2115,7 @@
</span><span class="cx">         return label;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store16(RegisterID src, ImplicitAddress address)
</del><ins>+    void store16(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (tryStoreWithOffset<16>(src, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2174,7 +2174,7 @@
</span><span class="cx">         m_assembler.strb(src, memoryTempRegister, 0);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store8(RegisterID src, ImplicitAddress address)
</del><ins>+    void store8(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (tryStoreWithOffset<8>(src, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2195,7 +2195,7 @@
</span><span class="cx">         store8(dataTempRegister, address);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store8(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store8(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</span><span class="cx">         if (!imm8.m_value) {
</span><span class="lines">@@ -2460,7 +2460,7 @@
</span><span class="cx">         m_assembler.fdiv<32>(dest, op1, op2);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadDouble(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadDouble(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadWithOffset<64>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2489,7 +2489,7 @@
</span><span class="cx">         m_assembler.ldr<64>(dest, memoryTempRegister, ARM64Registers::zr);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadFloat(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadFloat(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (tryLoadWithOffset<32>(dest, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2742,7 +2742,7 @@
</span><span class="cx">         m_assembler.fsqrt<32>(dest, src);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeDouble(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeDouble(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (tryStoreWithOffset<64>(src, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2771,7 +2771,7 @@
</span><span class="cx">         m_assembler.str<64>(src, address.base, memoryTempRegister);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeFloat(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeFloat(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (tryStoreWithOffset<32>(src, address.base, address.offset))
</span><span class="cx">             return;
</span><span class="lines">@@ -2928,7 +2928,7 @@
</span><span class="cx"> 
</span><span class="cx">         pushPair(reg, reg);
</span><span class="cx">         move(imm, reg);
</span><del>-        store64(reg, stackPointerRegister);
</del><ins>+        store64(reg, Address(stackPointerRegister));
</ins><span class="cx">         load64(Address(stackPointerRegister, 8), reg);
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -2946,7 +2946,7 @@
</span><span class="cx">     
</span><span class="cx">     void popToRestore(FPRegisterID dest)
</span><span class="cx">     {
</span><del>-        loadDouble(stackPointerRegister, dest);
</del><ins>+        loadDouble(Address(stackPointerRegister), dest);
</ins><span class="cx">         add64(TrustedImm32(16), stackPointerRegister);
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="lines">@@ -2953,7 +2953,7 @@
</span><span class="cx">     void pushToSave(FPRegisterID src)
</span><span class="cx">     {
</span><span class="cx">         sub64(TrustedImm32(16), stackPointerRegister);
</span><del>-        storeDouble(src, stackPointerRegister);
</del><ins>+        storeDouble(src, Address(stackPointerRegister));
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     static constexpr ptrdiff_t pushToSaveByteOffset() { return 16; }
</span><span class="lines">@@ -4163,7 +4163,7 @@
</span><span class="cx">         return PatchableJump(result);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</del><ins>+    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         DataLabelPtr label(this);
</span><span class="cx">         moveWithFixedWidth(initialValue, getCachedDataTempRegisterIDAndInvalidate());
</span><span class="lines">@@ -4171,7 +4171,7 @@
</span><span class="cx">         return label;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(ImplicitAddress address)
</del><ins>+    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(Address address)
</ins><span class="cx">     {
</span><span class="cx">         return storePtrWithPatch(TrustedImmPtr(nullptr), address);
</span><span class="cx">     }
</span><span class="lines">@@ -4216,134 +4216,134 @@
</span><span class="cx">         m_assembler.dmbISH();
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadAcq8SignedExtendTo32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadAcq8SignedExtendTo32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldar<8>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadAcq8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadAcq8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         loadAcq8SignedExtendTo32(address, dest);
</span><span class="cx">         and32(TrustedImm32(0xff), dest);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeRel8(RegisterID src, ImplicitAddress address)
</del><ins>+    void storeRel8(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlr<8>(src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadAcq16SignedExtendTo32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadAcq16SignedExtendTo32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldar<16>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadAcq16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadAcq16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         loadAcq16SignedExtendTo32(address, dest);
</span><span class="cx">         and32(TrustedImm32(0xffff), dest);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeRel16(RegisterID src, ImplicitAddress address)
</del><ins>+    void storeRel16(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlr<16>(src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadAcq32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadAcq32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldar<32>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadAcq64(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadAcq64(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldar<64>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeRel32(RegisterID dest, ImplicitAddress address)
</del><ins>+    void storeRel32(RegisterID dest, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlr<32>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeRel64(RegisterID dest, ImplicitAddress address)
</del><ins>+    void storeRel64(RegisterID dest, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlr<64>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLink8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLink8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldxr<8>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLinkAcq8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLinkAcq8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaxr<8>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCond8(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCond8(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stxr<8>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCondRel8(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCondRel8(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlxr<8>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLink16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLink16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldxr<16>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLinkAcq16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLinkAcq16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaxr<16>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCond16(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCond16(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stxr<16>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCondRel16(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCondRel16(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlxr<16>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLink32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLink32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldxr<32>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLinkAcq32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLinkAcq32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaxr<32>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCond32(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCond32(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stxr<32>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCondRel32(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCondRel32(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlxr<32>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLink64(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLink64(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldxr<64>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void loadLinkAcq64(ImplicitAddress address, RegisterID dest)
</del><ins>+    void loadLinkAcq64(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaxr<64>(dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCond64(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCond64(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stxr<64>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void storeCondRel64(RegisterID src, ImplicitAddress address, RegisterID result)
</del><ins>+    void storeCondRel64(RegisterID src, Address address, RegisterID result)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.stlxr<64>(result, src, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="lines">@@ -5204,7 +5204,7 @@
</span><span class="cx">         RELEASE_ASSERT_NOT_REACHED();
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    RegisterID extractSimpleAddress(ImplicitAddress address)
</del><ins>+    RegisterID extractSimpleAddress(Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (!address.offset)
</span><span class="cx">             return address.base;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64Eh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64E.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64E.h     2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64E.h        2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -373,122 +373,122 @@
</span><span class="cx">             m_assembler.retab();
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgAdd8(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgAdd8(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaddal<8>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgAdd16(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgAdd16(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaddal<16>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgAdd32(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgAdd32(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaddal<32>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgAdd64(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgAdd64(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldaddal<64>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgXor8(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgXor8(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldeoral<8>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgXor16(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgXor16(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldeoral<16>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgXor32(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgXor32(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldeoral<32>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgXor64(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgXor64(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldeoral<64>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgOr8(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgOr8(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldsetal<8>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgOr16(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgOr16(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldsetal<16>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgOr32(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgOr32(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldsetal<32>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgOr64(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgOr64(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldsetal<64>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgClear8(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgClear8(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldclral<8>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgClear16(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgClear16(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldclral<16>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgClear32(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgClear32(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldclral<32>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchgClear64(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchgClear64(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.ldclral<64>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchg8(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchg8(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.swpal<8>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchg16(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchg16(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.swpal<16>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchg32(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchg32(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.swpal<32>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicXchg64(RegisterID src, ImplicitAddress address, RegisterID dest)
</del><ins>+    void atomicXchg64(RegisterID src, Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.swpal<64>(src, dest, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicStrongCAS8(RegisterID expectedAndResult, RegisterID newValue, ImplicitAddress address)
</del><ins>+    void atomicStrongCAS8(RegisterID expectedAndResult, RegisterID newValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.casal<8>(expectedAndResult, newValue, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicStrongCAS16(RegisterID expectedAndResult, RegisterID newValue, ImplicitAddress address)
</del><ins>+    void atomicStrongCAS16(RegisterID expectedAndResult, RegisterID newValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.casal<16>(expectedAndResult, newValue, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicStrongCAS32(RegisterID expectedAndResult, RegisterID newValue, ImplicitAddress address)
</del><ins>+    void atomicStrongCAS32(RegisterID expectedAndResult, RegisterID newValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.casal<32>(expectedAndResult, newValue, extractSimpleAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void atomicStrongCAS64(RegisterID expectedAndResult, RegisterID newValue, ImplicitAddress address)
</del><ins>+    void atomicStrongCAS64(RegisterID expectedAndResult, RegisterID newValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.casal<64>(expectedAndResult, newValue, extractSimpleAddress(address));
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h      2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -370,16 +370,16 @@
</span><span class="cx">         ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="cx">         if (armImm.isValid()) {
</span><span class="cx">             move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><del>-            load8(addressTempRegister, dataTempRegister);
</del><ins>+            load8(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">             m_assembler.orr(dataTempRegister, dataTempRegister, armImm);
</span><del>-            store8(dataTempRegister, addressTempRegister);
</del><ins>+            store8(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">         } else {
</span><span class="cx">             move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><del>-            load8(addressTempRegister, dataTempRegister);
</del><ins>+            load8(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">             move(imm, addressTempRegister);
</span><span class="cx">             m_assembler.orr(dataTempRegister, dataTempRegister, addressTempRegister);
</span><span class="cx">             move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><del>-            store8(dataTempRegister, addressTempRegister);
</del><ins>+            store8(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -388,16 +388,16 @@
</span><span class="cx">         ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="cx">         if (armImm.isValid()) {
</span><span class="cx">             move(TrustedImmPtr(dest.m_ptr), addressTempRegister);
</span><del>-            load16(addressTempRegister, dataTempRegister);
</del><ins>+            load16(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">             m_assembler.orr(dataTempRegister, dataTempRegister, armImm);
</span><del>-            store16(dataTempRegister, addressTempRegister);
</del><ins>+            store16(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">         } else {
</span><span class="cx">             move(TrustedImmPtr(dest.m_ptr), addressTempRegister);
</span><del>-            load16(addressTempRegister, dataTempRegister);
</del><ins>+            load16(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">             move(imm, addressTempRegister);
</span><span class="cx">             m_assembler.orr(dataTempRegister, dataTempRegister, addressTempRegister);
</span><span class="cx">             move(TrustedImmPtr(dest.m_ptr), addressTempRegister);
</span><del>-            store16(dataTempRegister, addressTempRegister);
</del><ins>+            store16(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -409,9 +409,9 @@
</span><span class="cx">     void or32(RegisterID src, AbsoluteAddress dest)
</span><span class="cx">     {
</span><span class="cx">         move(TrustedImmPtr(dest.m_ptr), addressTempRegister);
</span><del>-        load32(addressTempRegister, dataTempRegister);
</del><ins>+        load32(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">         or32(src, dataTempRegister);
</span><del>-        store32(dataTempRegister, addressTempRegister);
</del><ins>+        store32(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void or32(TrustedImm32 imm, AbsoluteAddress address)
</span><span class="lines">@@ -419,16 +419,16 @@
</span><span class="cx">         ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm.m_value);
</span><span class="cx">         if (armImm.isValid()) {
</span><span class="cx">             move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><del>-            load32(addressTempRegister, dataTempRegister);
</del><ins>+            load32(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">             m_assembler.orr(dataTempRegister, dataTempRegister, armImm);
</span><del>-            store32(dataTempRegister, addressTempRegister);
</del><ins>+            store32(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">         } else {
</span><span class="cx">             move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><del>-            load32(addressTempRegister, dataTempRegister);
</del><ins>+            load32(Address(addressTempRegister), dataTempRegister);
</ins><span class="cx">             move(imm, addressTempRegister);
</span><span class="cx">             m_assembler.orr(dataTempRegister, dataTempRegister, addressTempRegister);
</span><span class="cx">             move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><del>-            store32(dataTempRegister, addressTempRegister);
</del><ins>+            store32(dataTempRegister, Address(addressTempRegister));
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -754,7 +754,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> public:
</span><del>-    void load32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         load32(setupArmAddress(address), dest);
</span><span class="cx">     }
</span><span class="lines">@@ -800,12 +800,12 @@
</span><span class="cx">         return result;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         load8(setupArmAddress(address), dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8SignedExtendTo32(ImplicitAddress, RegisterID)
</del><ins>+    void load8SignedExtendTo32(Address, RegisterID)
</ins><span class="cx">     {
</span><span class="cx">         UNREACHABLE_FOR_PLATFORM();
</span><span class="cx">     }
</span><span class="lines">@@ -823,7 +823,7 @@
</span><span class="cx">     void load8(const void* address, RegisterID dest)
</span><span class="cx">     {
</span><span class="cx">         move(TrustedImmPtr(address), dest);
</span><del>-        load8(dest, dest);
</del><ins>+        load8(Address(dest), dest);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     DataLabel32 load32WithAddressOffsetPatch(Address address, RegisterID dest)
</span><span class="lines">@@ -862,7 +862,7 @@
</span><span class="cx">         load16SignedExtendTo32(setupArmAddress(address), dest);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void load16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.offset);
</span><span class="cx">         if (armImm.isValid())
</span><span class="lines">@@ -873,7 +873,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void load16SignedExtendTo32(ImplicitAddress, RegisterID)
</del><ins>+    void load16SignedExtendTo32(Address, RegisterID)
</ins><span class="cx">     {
</span><span class="cx">         UNREACHABLE_FOR_PLATFORM();
</span><span class="cx">     }
</span><span class="lines">@@ -903,7 +903,7 @@
</span><span class="cx">         return label;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(RegisterID src, ImplicitAddress address)
</del><ins>+    void store32(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store32(src, setupArmAddress(address));
</span><span class="cx">     }
</span><span class="lines">@@ -913,7 +913,7 @@
</span><span class="cx">         store32(src, setupArmAddress(address));
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store32(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         move(imm, dataTempRegister);
</span><span class="cx">         store32(dataTempRegister, setupArmAddress(address));
</span><span class="lines">@@ -972,7 +972,7 @@
</span><span class="cx">         store8(src, ArmAddress(addrreg, 0));
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void store16(RegisterID src, ImplicitAddress address)
</del><ins>+    void store16(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         store16(src, setupArmAddress(address));
</span><span class="cx">     }
</span><span class="lines">@@ -1043,7 +1043,7 @@
</span><span class="cx">     static bool supportsFloatingPointAbs() { return true; }
</span><span class="cx">     static bool supportsFloatingPointRounding() { return false; }
</span><span class="cx"> 
</span><del>-    void loadDouble(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadDouble(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         RegisterID base = address.base;
</span><span class="cx">         int32_t offset = address.offset;
</span><span class="lines">@@ -1058,7 +1058,7 @@
</span><span class="cx">         m_assembler.vldr(dest, base, offset);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadFloat(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadFloat(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         RegisterID base = address.base;
</span><span class="cx">         int32_t offset = address.offset;
</span><span class="lines">@@ -1112,7 +1112,7 @@
</span><span class="cx">         m_assembler.vldr(dest, addressTempRegister, 0);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeDouble(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeDouble(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         RegisterID base = address.base;
</span><span class="cx">         int32_t offset = address.offset;
</span><span class="lines">@@ -1127,7 +1127,7 @@
</span><span class="cx">         m_assembler.vstr(src, base, offset);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeFloat(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeFloat(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         RegisterID base = address.base;
</span><span class="cx">         int32_t offset = address.offset;
</span><span class="lines">@@ -1145,7 +1145,7 @@
</span><span class="cx">     void storeDouble(FPRegisterID src, TrustedImmPtr address)
</span><span class="cx">     {
</span><span class="cx">         move(address, addressTempRegister);
</span><del>-        storeDouble(src, addressTempRegister);
</del><ins>+        storeDouble(src, Address(addressTempRegister));
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void storeDouble(FPRegisterID src, BaseIndex address)
</span><span class="lines">@@ -2132,13 +2132,13 @@
</span><span class="cx">         return PatchableJump(result);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</del><ins>+    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         DataLabelPtr label = moveWithPatch(initialValue, dataTempRegister);
</span><span class="cx">         store32(dataTempRegister, address);
</span><span class="cx">         return label;
</span><span class="cx">     }
</span><del>-    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(ImplicitAddress address) { return storePtrWithPatch(TrustedImmPtr(nullptr), address); }
</del><ins>+    ALWAYS_INLINE DataLabelPtr storePtrWithPatch(Address address) { return storePtrWithPatch(TrustedImmPtr(nullptr), address); }
</ins><span class="cx"> 
</span><span class="cx">     template<PtrTag resultTag, PtrTag locationTag>
</span><span class="cx">     static FunctionPtr<resultTag> readCallTarget(CodeLocationCall<locationTag> call)
</span><span class="lines">@@ -2249,15 +2249,6 @@
</span><span class="cx">         return ArmAddress(address.base, addressTempRegister);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    ArmAddress setupArmAddress(ImplicitAddress address)
-    {
-        if ((address.offset >= -0xff) && (address.offset <= 0xfff))
-            return ArmAddress(address.base, address.offset);
-
-        move(TrustedImm32(address.offset), addressTempRegister);
-        return ArmAddress(address.base, addressTempRegister);
-    }
-
</del><span class="cx">     RegisterID makeBaseIndexBase(BaseIndex address)
</span><span class="cx">     {
</span><span class="cx">         if (!address.offset)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h       2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h  2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -917,7 +917,7 @@
</span><span class="cx">     // register is passed.
</span><span class="cx"> 
</span><span class="cx">     /* Need to use zero-extened load byte for load8.  */
</span><del>-    void load8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -976,7 +976,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8SignedExtendTo32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8SignedExtendTo32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -1036,7 +1036,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> 
</span><del>-    void load32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -1233,7 +1233,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     /* Need to use zero-extened load half-word for load16.  */
</span><del>-    void load16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -1327,7 +1327,7 @@
</span><span class="cx">         return dataLabel;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store8(RegisterID src, ImplicitAddress address)
</del><ins>+    void store8(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -1406,7 +1406,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store8(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store8(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="lines">@@ -1450,7 +1450,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store16(RegisterID src, ImplicitAddress address)
</del><ins>+    void store16(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth) {
</span><span class="lines">@@ -1488,7 +1488,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(RegisterID src, ImplicitAddress address)
</del><ins>+    void store32(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -1526,7 +1526,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store32(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth) {
</span><span class="lines">@@ -2912,7 +2912,7 @@
</span><span class="cx">         return temp;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</del><ins>+    DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_fixedWidth = true;
</span><span class="cx">         DataLabelPtr dataLabel = moveWithPatch(initialValue, dataTempRegister);
</span><span class="lines">@@ -2921,7 +2921,7 @@
</span><span class="cx">         return dataLabel;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    DataLabelPtr storePtrWithPatch(ImplicitAddress address)
</del><ins>+    DataLabelPtr storePtrWithPatch(Address address)
</ins><span class="cx">     {
</span><span class="cx">         return storePtrWithPatch(TrustedImmPtr(nullptr), address);
</span><span class="cx">     }
</span><span class="lines">@@ -2947,7 +2947,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadFloat(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadFloat(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth) {
</span><span class="lines">@@ -2964,7 +2964,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadDouble(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadDouble(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx"> #if WTF_MIPS_ISA(1)
</span><span class="cx">         /*
</span><span class="lines">@@ -3086,7 +3086,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeFloat(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeFloat(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx">             && !m_fixedWidth)
</span><span class="lines">@@ -3103,7 +3103,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeDouble(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeDouble(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx"> #if WTF_MIPS_ISA(1)
</span><span class="cx">         /*
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h  2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h     2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -1210,7 +1210,7 @@
</span><span class="cx">     // operand objects to loads and store will be implicitly constructed if a
</span><span class="cx">     // register is passed.
</span><span class="cx"> 
</span><del>-    void load32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movl_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1225,7 +1225,7 @@
</span><span class="cx">         load32(address, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load16Unaligned(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16Unaligned(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         load16(address, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1268,7 +1268,7 @@
</span><span class="cx">         m_assembler.movzbl_mr(address.offset, address.base, address.index, address.scale, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movzbl_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1278,7 +1278,7 @@
</span><span class="cx">         m_assembler.movsbl_mr(address.offset, address.base, address.index, address.scale, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load8SignedExtendTo32(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load8SignedExtendTo32(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movsbl_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1293,7 +1293,7 @@
</span><span class="cx">         m_assembler.movsbl_rr(src, dest);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void load16(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load16(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movzwl_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1303,11 +1303,6 @@
</span><span class="cx">         m_assembler.movzwl_mr(address.offset, address.base, address.index, address.scale, dest);
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    void load16(Address address, RegisterID dest)
-    {
-        m_assembler.movzwl_mr(address.offset, address.base, dest);
-    }
-
</del><span class="cx">     void load16SignedExtendTo32(BaseIndex address, RegisterID dest)
</span><span class="cx">     {
</span><span class="cx">         m_assembler.movswl_mr(address.offset, address.base, address.index, address.scale, dest);
</span><span class="lines">@@ -1352,7 +1347,7 @@
</span><span class="cx">         return DataLabel32(this);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(RegisterID src, ImplicitAddress address)
</del><ins>+    void store32(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movl_rm(src, address.offset, address.base);
</span><span class="cx">     }
</span><span class="lines">@@ -1362,7 +1357,7 @@
</span><span class="cx">         m_assembler.movl_rm(src, address.offset, address.base, address.index, address.scale);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store32(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store32(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movl_i32m(imm.m_value, address.offset, address.base);
</span><span class="cx">     }
</span><span class="lines">@@ -1469,7 +1464,7 @@
</span><span class="cx">         m_assembler.movw_im(static_cast<int16_t>(imm.m_value), address.offset, address.base, address.index, address.scale);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store16(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store16(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movw_im(static_cast<int16_t>(imm.m_value), address.offset, address.base);
</span><span class="cx">     }
</span><span class="lines">@@ -1488,11 +1483,11 @@
</span><span class="cx">         m_assembler.movsd_mr(address.asPtr(), dest);
</span><span class="cx"> #else
</span><span class="cx">         move(address, scratchRegister());
</span><del>-        loadDouble(scratchRegister(), dest);
</del><ins>+        loadDouble(Address(scratchRegister()), dest);
</ins><span class="cx"> #endif
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadDouble(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadDouble(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movsd_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1508,11 +1503,11 @@
</span><span class="cx">         m_assembler.movss_mr(address.asPtr(), dest);
</span><span class="cx"> #else
</span><span class="cx">         move(address, scratchRegister());
</span><del>-        loadFloat(scratchRegister(), dest);
</del><ins>+        loadFloat(Address(scratchRegister()), dest);
</ins><span class="cx"> #endif
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void loadFloat(ImplicitAddress address, FPRegisterID dest)
</del><ins>+    void loadFloat(Address address, FPRegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movss_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -1522,7 +1517,7 @@
</span><span class="cx">         m_assembler.movss_mr(address.offset, address.base, address.index, address.scale, dest);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeDouble(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeDouble(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movsd_rm(src, address.offset, address.base);
</span><span class="cx">     }
</span><span class="lines">@@ -1532,7 +1527,7 @@
</span><span class="cx">         m_assembler.movsd_rm(src, address.offset, address.base, address.index, address.scale);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void storeFloat(FPRegisterID src, ImplicitAddress address)
</del><ins>+    void storeFloat(FPRegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movss_rm(src, address.offset, address.base);
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86_64h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h     2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h        2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -106,7 +106,7 @@
</span><span class="cx">     void load8(const void* address, RegisterID dest)
</span><span class="cx">     {
</span><span class="cx">         move(TrustedImmPtr(address), dest);
</span><del>-        load8(dest, dest);
</del><ins>+        load8(Address(dest), dest);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void load16(ExtendedAddress address, RegisterID dest)
</span><span class="lines">@@ -132,7 +132,7 @@
</span><span class="cx">             m_assembler.movl_mEAX(address);
</span><span class="cx">         else {
</span><span class="cx">             move(TrustedImmPtr(address), dest);
</span><del>-            load32(dest, dest);
</del><ins>+            load32(Address(dest), dest);
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -151,7 +151,7 @@
</span><span class="cx">     void store32(TrustedImm32 imm, void* address)
</span><span class="cx">     {
</span><span class="cx">         move(TrustedImmPtr(address), scratchRegister());
</span><del>-        store32(imm, scratchRegister());
</del><ins>+        store32(imm, Address(scratchRegister()));
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     void store32(RegisterID source, void* address)
</span><span class="lines">@@ -160,7 +160,7 @@
</span><span class="cx">             m_assembler.movl_EAXm(address);
</span><span class="cx">         else {
</span><span class="cx">             move(TrustedImmPtr(address), scratchRegister());
</span><del>-            store32(source, scratchRegister());
</del><ins>+            store32(source, Address(scratchRegister()));
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="lines">@@ -918,7 +918,7 @@
</span><span class="cx">         m_assembler.notq_m(dest.offset, dest.base, dest.index, dest.scale);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void load64(ImplicitAddress address, RegisterID dest)
</del><ins>+    void load64(Address address, RegisterID dest)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movq_mr(address.offset, address.base, dest);
</span><span class="cx">     }
</span><span class="lines">@@ -934,7 +934,7 @@
</span><span class="cx">             m_assembler.movq_mEAX(address);
</span><span class="cx">         else {
</span><span class="cx">             move(TrustedImmPtr(address), dest);
</span><del>-            load64(dest, dest);
</del><ins>+            load64(Address(dest), dest);
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -952,7 +952,7 @@
</span><span class="cx">         return DataLabelCompact(this);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store64(RegisterID src, ImplicitAddress address)
</del><ins>+    void store64(RegisterID src, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movq_rm(src, address.offset, address.base);
</span><span class="cx">     }
</span><span class="lines">@@ -968,11 +968,11 @@
</span><span class="cx">             m_assembler.movq_EAXm(address);
</span><span class="cx">         else {
</span><span class="cx">             move(TrustedImmPtr(address), scratchRegister());
</span><del>-            store64(src, scratchRegister());
</del><ins>+            store64(src, Address(scratchRegister()));
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store64(TrustedImm32 imm, ImplicitAddress address)
</del><ins>+    void store64(TrustedImm32 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         m_assembler.movq_i32m(imm.m_value, address.offset, address.base);
</span><span class="cx">     }
</span><span class="lines">@@ -987,7 +987,7 @@
</span><span class="cx">         if (CAN_SIGN_EXTEND_32_64(imm.m_value)) {
</span><span class="cx">             auto addressReg = scratchRegister();
</span><span class="cx">             move(TrustedImmPtr(address), addressReg);
</span><del>-            store64(TrustedImm32(static_cast<int32_t>(imm.m_value)), addressReg);
</del><ins>+            store64(TrustedImm32(static_cast<int32_t>(imm.m_value)), Address(addressReg));
</ins><span class="cx">             return;
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="lines">@@ -998,7 +998,7 @@
</span><span class="cx">         swap(src, X86Registers::eax);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void store64(TrustedImm64 imm, ImplicitAddress address)
</del><ins>+    void store64(TrustedImm64 imm, Address address)
</ins><span class="cx">     {
</span><span class="cx">         if (CAN_SIGN_EXTEND_32_64(imm.m_value)) {
</span><span class="cx">             store64(TrustedImm32(static_cast<int32_t>(imm.m_value)), address);
</span><span class="lines">@@ -1524,7 +1524,7 @@
</span><span class="cx">         return branch32(cond, left, scratchRegister());
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
</del><ins>+    DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, Address address)
</ins><span class="cx">     {
</span><span class="cx">         DataLabelPtr label = moveWithPatch(initialValue, scratchRegister());
</span><span class="cx">         store64(scratchRegister(), address);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblertestmasmcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/testmasm.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/testmasm.cpp       2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/assembler/testmasm.cpp  2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -303,16 +303,16 @@
</span><span class="cx">         jit.subPtr(CCallHelpers::TrustedImm32(stackAlignmentBytes()), MacroAssembler::stackPointerRegister);
</span><span class="cx">         if (isBigEndian) {
</span><span class="cx">             jit.store32(CCallHelpers::TrustedImm32(valAsUInt >> 32),
</span><del>-                MacroAssembler::stackPointerRegister);
</del><ins>+                MacroAssembler::Address(MacroAssembler::stackPointerRegister));
</ins><span class="cx">             jit.store32(CCallHelpers::TrustedImm32(valAsUInt & 0xffffffff),
</span><span class="cx">                 MacroAssembler::Address(MacroAssembler::stackPointerRegister, 4));
</span><span class="cx">         } else {
</span><span class="cx">             jit.store32(CCallHelpers::TrustedImm32(valAsUInt & 0xffffffff),
</span><del>-                MacroAssembler::stackPointerRegister);
</del><ins>+                MacroAssembler::Address(MacroAssembler::stackPointerRegister));
</ins><span class="cx">             jit.store32(CCallHelpers::TrustedImm32(valAsUInt >> 32),
</span><span class="cx">                 MacroAssembler::Address(MacroAssembler::stackPointerRegister, 4));
</span><span class="cx">         }
</span><del>-        jit.loadDouble(MacroAssembler::stackPointerRegister, FPRInfo::fpRegT0);
</del><ins>+        jit.loadDouble(MacroAssembler::Address(MacroAssembler::stackPointerRegister), FPRInfo::fpRegT0);
</ins><span class="cx"> 
</span><span class="cx">         MacroAssembler::Jump done;
</span><span class="cx">         done = jit.branchTruncateDoubleToInt32(FPRInfo::fpRegT0, GPRInfo::returnValueGPR, MacroAssembler::BranchIfTruncateSuccessful);
</span><span class="lines">@@ -2313,7 +2313,7 @@
</span><span class="cx"> 
</span><span class="cx">             // res = *++p1; *p1 = 4; return res;
</span><span class="cx">             jit.load32(CCallHelpers::PreIndexAddress(GPRInfo::argumentGPR0, index), GPRInfo::argumentGPR1);
</span><del>-            jit.store32(CCallHelpers::TrustedImm32(replace), CCallHelpers::ImplicitAddress(GPRInfo::argumentGPR0));
</del><ins>+            jit.store32(CCallHelpers::TrustedImm32(replace), CCallHelpers::Address(GPRInfo::argumentGPR0));
</ins><span class="cx">             jit.move(GPRInfo::argumentGPR1, GPRInfo::returnValueGPR);
</span><span class="cx"> 
</span><span class="cx">             emitFunctionEpilogue(jit);
</span><span class="lines">@@ -2331,7 +2331,7 @@
</span><span class="cx"> 
</span><span class="cx">             // res = *p2++; *p2 = 5; return res;
</span><span class="cx">             jit.load32(CCallHelpers::PostIndexAddress(GPRInfo::argumentGPR0, index), GPRInfo::argumentGPR1);
</span><del>-            jit.store32(CCallHelpers::TrustedImm32(replace), CCallHelpers::ImplicitAddress(GPRInfo::argumentGPR0));
</del><ins>+            jit.store32(CCallHelpers::TrustedImm32(replace), CCallHelpers::Address(GPRInfo::argumentGPR0));
</ins><span class="cx">             jit.move(GPRInfo::argumentGPR1, GPRInfo::returnValueGPR);
</span><span class="cx"> 
</span><span class="cx">             emitFunctionEpilogue(jit);
</span><span class="lines">@@ -2355,7 +2355,7 @@
</span><span class="cx"> 
</span><span class="cx">             // res = *++p1; *p1 = 4; return res;
</span><span class="cx">             jit.load64(CCallHelpers::PreIndexAddress(GPRInfo::argumentGPR0, index), GPRInfo::argumentGPR1);
</span><del>-            jit.store64(CCallHelpers::TrustedImm64(replace), CCallHelpers::ImplicitAddress(GPRInfo::argumentGPR0));
</del><ins>+            jit.store64(CCallHelpers::TrustedImm64(replace), CCallHelpers::Address(GPRInfo::argumentGPR0));
</ins><span class="cx">             jit.move(GPRInfo::argumentGPR1, GPRInfo::returnValueGPR);
</span><span class="cx"> 
</span><span class="cx">             emitFunctionEpilogue(jit);
</span><span class="lines">@@ -2373,7 +2373,7 @@
</span><span class="cx"> 
</span><span class="cx">             // res = *p2++; *p2 = 5; return res;
</span><span class="cx">             jit.load64(CCallHelpers::PostIndexAddress(GPRInfo::argumentGPR0, index), GPRInfo::argumentGPR1);
</span><del>-            jit.store64(CCallHelpers::TrustedImm64(replace), CCallHelpers::ImplicitAddress(GPRInfo::argumentGPR0));
</del><ins>+            jit.store64(CCallHelpers::TrustedImm64(replace), CCallHelpers::Address(GPRInfo::argumentGPR0));
</ins><span class="cx">             jit.move(GPRInfo::argumentGPR1, GPRInfo::returnValueGPR);
</span><span class="cx"> 
</span><span class="cx">             emitFunctionEpilogue(jit);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp    2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp       2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -1918,7 +1918,7 @@
</span><span class="cx"> 
</span><span class="cx">     m_jit.lshift32(MacroAssembler::TrustedImm32(sizeof(void*) == 4 ? 2 : 3), tempGPR);
</span><span class="cx">     m_jit.addPtr(TrustedImmPtr(vm.smallStrings.singleCharacterStrings()), tempGPR);
</span><del>-    m_jit.loadPtr(tempGPR, tempGPR);
</del><ins>+    m_jit.loadPtr(CCallHelpers::Address(tempGPR), tempGPR);
</ins><span class="cx"> 
</span><span class="cx">     addSlowPathGenerator(slowPathCall(bigCharacter, this, operationSingleCharacterString, tempGPR, &vm, tempGPR));
</span><span class="cx"> 
</span><span class="lines">@@ -2634,7 +2634,7 @@
</span><span class="cx">     VM& vm = this->vm();
</span><span class="cx">     m_jit.lshift32(MacroAssembler::TrustedImm32(sizeof(void*) == 4 ? 2 : 3), scratchReg);
</span><span class="cx">     m_jit.addPtr(TrustedImmPtr(vm.smallStrings.singleCharacterStrings()), scratchReg);
</span><del>-    m_jit.loadPtr(scratchReg, scratchReg);
</del><ins>+    m_jit.loadPtr(CCallHelpers::Address(scratchReg), scratchReg);
</ins><span class="cx"> 
</span><span class="cx">     addSlowPathGenerator(
</span><span class="cx">         slowPathCall(
</span><span class="lines">@@ -15339,7 +15339,7 @@
</span><span class="cx">     GPRTemporary scratch(this);
</span><span class="cx">     GPRReg scratchGPR = scratch.gpr();
</span><span class="cx">     m_jit.move(TrustedImmPtr(scratchBuffer->addressOfActiveLength()), scratchGPR);
</span><del>-    m_jit.storePtr(TrustedImmPtr(nullptr), scratchGPR);
</del><ins>+    m_jit.storePtr(TrustedImmPtr(nullptr), CCallHelpers::Address(scratchGPR));
</ins><span class="cx">     noResult(node);
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLLocationcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLLocation.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLLocation.cpp  2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/ftl/FTLLocation.cpp     2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -99,10 +99,10 @@
</span><span class="cx">             jit.move(MacroAssembler::framePointerRegister, result);
</span><span class="cx">             
</span><span class="cx">             for (unsigned i = numFramesToPop - 1; i--;)
</span><del>-                jit.loadPtr(result, result);
</del><ins>+                jit.loadPtr(MacroAssembler::Address(result), result);
</ins><span class="cx">             
</span><span class="cx">             if (gpr() == MacroAssembler::framePointerRegister)
</span><del>-                jit.loadPtr(result, result);
</del><ins>+                jit.loadPtr(MacroAssembler::Address(result), result);
</ins><span class="cx">             else
</span><span class="cx">                 jit.addPtr(MacroAssembler::TrustedImmPtr(sizeof(void*) * 2), result);
</span><span class="cx">         } else
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLThunkscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLThunks.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLThunks.cpp    2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/ftl/FTLThunks.cpp       2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -80,7 +80,7 @@
</span><span class="cx">     
</span><span class="cx">     saveAllRegisters(jit, buffer);
</span><span class="cx"> 
</span><del>-    jit.loadPtr(framePointerRegister, GPRInfo::argumentGPR0);
</del><ins>+    jit.loadPtr(CCallHelpers::Address(framePointerRegister), GPRInfo::argumentGPR0);
</ins><span class="cx">     jit.peek(
</span><span class="cx">         GPRInfo::argumentGPR1,
</span><span class="cx">         (stackMisalignment - pushToSaveByteOffset) / sizeof(void*));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitAssemblyHelperscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp      2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp 2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -1096,7 +1096,7 @@
</span><span class="cx"> 
</span><span class="cx">     for (unsigned i = 0; i < FPRInfo::numberOfRegisters; ++i) {
</span><span class="cx">         move(TrustedImmPtr(buffer + GPRInfo::numberOfRegisters + i), GPRInfo::regT0);
</span><del>-        storeDouble(FPRInfo::toRegister(i), GPRInfo::regT0);
</del><ins>+        storeDouble(FPRInfo::toRegister(i), Address(GPRInfo::regT0));
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> #if CPU(X86_64) || CPU(ARM_THUMB2) || CPU(ARM64) || CPU(MIPS)
</span><span class="lines">@@ -1113,7 +1113,7 @@
</span><span class="cx"> 
</span><span class="cx">     for (unsigned i = 0; i < FPRInfo::numberOfRegisters; ++i) {
</span><span class="cx">         move(TrustedImmPtr(buffer + GPRInfo::numberOfRegisters + i), GPRInfo::regT0);
</span><del>-        loadDouble(GPRInfo::regT0, FPRInfo::toRegister(i));
</del><ins>+        loadDouble(Address(GPRInfo::regT0), FPRInfo::toRegister(i));
</ins><span class="cx">     }
</span><span class="cx">     for (unsigned i = 0; i < GPRInfo::numberOfRegisters; ++i) {
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="lines">@@ -1163,7 +1163,7 @@
</span><span class="cx">     loadPtr(vm.addressOfLastStackTop(), scratch);
</span><span class="cx">     Jump done = branchPtr(BelowOrEqual, stackPointerRegister, scratch);
</span><span class="cx">     Label loop = label();
</span><del>-    storePtr(TrustedImmPtr(nullptr), scratch);
</del><ins>+    storePtr(TrustedImmPtr(nullptr), Address(scratch));
</ins><span class="cx">     addPtr(TrustedImmPtr(sizeof(void*)), scratch);
</span><span class="cx">     branchPtr(Above, stackPointerRegister, scratch).linkTo(loop, this);
</span><span class="cx">     done.link(this);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITPropertyAccesscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp    2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp       2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -2185,7 +2185,7 @@
</span><span class="cx"> void JIT::emitGetVarFromIndirectPointer(JSValue** operand, GPRReg reg)
</span><span class="cx"> {
</span><span class="cx">     loadPtr(operand, reg);
</span><del>-    loadPtr(reg, reg);
</del><ins>+    loadPtr(Address(reg), reg);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitGetClosureVar(VirtualRegister scope, uintptr_t operand)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitThunkGeneratorscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp      2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -600,7 +600,7 @@
</span><span class="cx"> 
</span><span class="cx">     // Move current frame down argumentGPR0 number of slots
</span><span class="cx">     JSInterfaceJIT::Label copyLoop(jit.label());
</span><del>-    jit.load64(JSInterfaceJIT::regT3, extraTemp);
</del><ins>+    jit.load64(CCallHelpers::Address(JSInterfaceJIT::regT3), extraTemp);
</ins><span class="cx">     jit.store64(extraTemp, MacroAssembler::BaseIndex(JSInterfaceJIT::regT3, JSInterfaceJIT::argumentGPR0, JSInterfaceJIT::TimesEight));
</span><span class="cx">     jit.addPtr(JSInterfaceJIT::TrustedImm32(8), JSInterfaceJIT::regT3);
</span><span class="cx">     jit.branchSub32(MacroAssembler::NonZero, JSInterfaceJIT::TrustedImm32(1), JSInterfaceJIT::argumentGPR2).linkTo(copyLoop, &jit);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmBindingcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmBinding.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmBinding.cpp 2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/wasm/WasmBinding.cpp    2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -74,7 +74,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // Tail call into the callee WebAssembly function.
</span><del>-    jit.loadPtr(scratch, scratch);
</del><ins>+    jit.loadPtr(JIT::Address(scratch), scratch);
</ins><span class="cx">     jit.farJump(scratch, WasmEntryPtrTag);
</span><span class="cx"> 
</span><span class="cx">     LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID, LinkBuffer::Profile::WasmThunk, JITCompilationCanFail);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreyarrYarrJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp     2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp        2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -697,7 +697,7 @@
</span><span class="cx"> 
</span><span class="cx">         JumpList notUnicode;
</span><span class="cx"> 
</span><del>-        load16Unaligned(regUnicodeInputAndTrail, resultReg);
</del><ins>+        load16Unaligned(Address(regUnicodeInputAndTrail), resultReg);
</ins><span class="cx"> 
</span><span class="cx">         // Is the character a leading surrogate?
</span><span class="cx">         and32(surrogateTagMask, resultReg, unicodeTemp);
</span><span class="lines">@@ -879,7 +879,7 @@
</span><span class="cx">     {
</span><span class="cx">         ASSERT(!m_pattern.m_body->m_hasFixedSize);
</span><span class="cx">         if (m_compileMode == JITCompileMode::IncludeSubpatterns)
</span><del>-            store32(reg, output);
</del><ins>+            store32(reg, Address(output));
</ins><span class="cx">         else
</span><span class="cx">             move(reg, output);
</span><span class="cx">     }
</span><span class="lines">@@ -887,7 +887,7 @@
</span><span class="cx">     {
</span><span class="cx">         ASSERT(!m_pattern.m_body->m_hasFixedSize);
</span><span class="cx">         if (m_compileMode == JITCompileMode::IncludeSubpatterns)
</span><del>-            load32(output, reg);
</del><ins>+            load32(Address(output), reg);
</ins><span class="cx">         else
</span><span class="cx">             move(output, reg);
</span><span class="cx">     }
</span><span class="lines">@@ -2830,7 +2830,7 @@
</span><span class="cx"> 
</span><span class="cx">                     loadFromFrame(parenthesesFrameLocation + BackTrackInfoParentheses::parenContextHeadIndex(), currParenContextReg);
</span><span class="cx">                     allocateParenContext(newParenContextReg);
</span><del>-                    storePtr(currParenContextReg, newParenContextReg);
</del><ins>+                    storePtr(currParenContextReg, Address(newParenContextReg));
</ins><span class="cx">                     storeToFrame(newParenContextReg, parenthesesFrameLocation + BackTrackInfoParentheses::parenContextHeadIndex());
</span><span class="cx">                     saveParenContext(newParenContextReg, regT2, term->parentheses.subpatternId, term->parentheses.lastSubpatternId, parenthesesFrameLocation);
</span><span class="cx">                     storeToFrame(index, parenthesesFrameLocation + BackTrackInfoParentheses::beginIndex());
</span></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog   2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/WebCore/ChangeLog      2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -1,3 +1,14 @@
</span><ins>+2021-10-11  Saam Barati  <sbarati@apple.com>
+
+        Remove ImplicitAddress
+        https://bugs.webkit.org/show_bug.cgi?id=230820
+        <rdar://problem/83826318>
+
+        Reviewed by Yusuke Suzuki.
+
+        * cssjit/SelectorCompiler.cpp:
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateSelectorChecker):
+
</ins><span class="cx"> 2021-10-11  Myles C. Maxfield  <mmaxfield@apple.com>
</span><span class="cx"> 
</span><span class="cx">         [GPU Process] Unique RenderingResourceIdentifiers Part 6: Uniquify more of RemoteDisplayListRecorder at entry points
</span></span></pre></div>
<a id="trunkSourceWebCorecssjitSelectorCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/cssjit/SelectorCompiler.cpp (283969 => 283970)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/cssjit/SelectorCompiler.cpp 2021-10-12 05:05:01 UTC (rev 283969)
+++ trunk/Source/WebCore/cssjit/SelectorCompiler.cpp    2021-10-12 06:32:55 UTC (rev 283970)
</span><span class="lines">@@ -2081,9 +2081,9 @@
</span><span class="cx">     if (m_selectorContext == SelectorContext::RuleCollector) {
</span><span class="cx">         unsigned specificity = m_selectorFragments.staticSpecificity;
</span><span class="cx">         if (m_functionType == FunctionType::SelectorCheckerWithCheckingContext)
</span><del>-            m_assembler.store32(Assembler::TrustedImm32(specificity), JSC::GPRInfo::argumentGPR2);
</del><ins>+            m_assembler.store32(Assembler::TrustedImm32(specificity), Assembler::Address(JSC::GPRInfo::argumentGPR2));
</ins><span class="cx">         else
</span><del>-            m_assembler.store32(Assembler::TrustedImm32(specificity), JSC::GPRInfo::argumentGPR1);
</del><ins>+            m_assembler.store32(Assembler::TrustedImm32(specificity), Assembler::Address(JSC::GPRInfo::argumentGPR1));
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     computeBacktrackingMemoryRequirements(m_selectorFragments);
</span></span></pre>
</div>
</div>

</body>
</html>