<!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>[203331] trunk/Source/JavaScriptCore</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/203331">203331</a></dd>
<dt>Author</dt> <dd>utatane.tea@gmail.com</dd>
<dt>Date</dt> <dd>2016-07-17 07:33:26 -0700 (Sun, 17 Jul 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>[JSC] Mask TrustedImm32 to 8bit in MacroAssembler for 8bit operations
https://bugs.webkit.org/show_bug.cgi?id=159334
Reviewed by Filip Pizlo.
Previously, in 8bit operations (like add8, compare8, test8, branch8, branchTest8 etc.),
we require that the given TrustedImm32 is in range of 8bit. While achieving this in
the manual MacroAssembler calling is easy, in Air, we don't guarantee that the higher bit
of the 8bit argument is cleared. So the current assertions are invalid.
This patch relaxes the above restriction. By removing this assertion,
8bit operations can take arbitrary 32bit imms. And only lower 8bit are effective when
emitting the code in these methods.
* assembler/MacroAssembler.h:
(JSC::MacroAssembler::branchTest8):
* assembler/MacroAssemblerARM.h:
(JSC::MacroAssemblerARM::store8):
(JSC::MacroAssemblerARM::branch8):
(JSC::MacroAssemblerARM::branchTest8):
(JSC::MacroAssemblerARM::compare8):
(JSC::MacroAssemblerARM::test8):
* assembler/MacroAssemblerARM64.h:
(JSC::MacroAssemblerARM64::store8):
(JSC::MacroAssemblerARM64::branch8):
(JSC::MacroAssemblerARM64::branchTest8):
(JSC::MacroAssemblerARM64::compare8):
(JSC::MacroAssemblerARM64::test8):
* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::store8):
(JSC::MacroAssemblerARMv7::branch8):
(JSC::MacroAssemblerARMv7::branchTest8):
(JSC::MacroAssemblerARMv7::compare8):
(JSC::MacroAssemblerARMv7::test8):
* assembler/MacroAssemblerMIPS.h:
(JSC::MacroAssemblerMIPS::store8):
(JSC::MacroAssemblerMIPS::branch8):
(JSC::MacroAssemblerMIPS::compare8):
(JSC::MacroAssemblerMIPS::branchTest8):
(JSC::MacroAssemblerMIPS::test8):
* assembler/MacroAssemblerSH4.h:
(JSC::MacroAssemblerSH4::store8):
(JSC::MacroAssemblerSH4::branchTest8):
(JSC::MacroAssemblerSH4::branch8):
(JSC::MacroAssemblerSH4::compare8):
(JSC::MacroAssemblerSH4::test8):
* assembler/MacroAssemblerX86.h:
(JSC::MacroAssemblerX86::store8):
(JSC::MacroAssemblerX86::branch8):
(JSC::MacroAssemblerX86::branchTest8):
* assembler/MacroAssemblerX86Common.h:
(JSC::MacroAssemblerX86Common::add8):
(JSC::MacroAssemblerX86Common::store8):
(JSC::MacroAssemblerX86Common::branch8):
(JSC::MacroAssemblerX86Common::branchTest8):
(JSC::MacroAssemblerX86Common::compare8):
(JSC::MacroAssemblerX86Common::test8):
* assembler/MacroAssemblerX86_64.h:
(JSC::MacroAssemblerX86_64::store8):
(JSC::MacroAssemblerX86_64::branch8):
(JSC::MacroAssemblerX86_64::branchTest8):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerh">trunk/Source/JavaScriptCore/assembler/MacroAssembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.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="#trunkSourceJavaScriptCoreassemblerMacroAssemblerSH4h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.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>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -1,3 +1,67 @@
</span><ins>+2016-07-17 Yusuke Suzuki <utatane.tea@gmail.com>
+
+ [JSC] Mask TrustedImm32 to 8bit in MacroAssembler for 8bit operations
+ https://bugs.webkit.org/show_bug.cgi?id=159334
+
+ Reviewed by Filip Pizlo.
+
+ Previously, in 8bit operations (like add8, compare8, test8, branch8, branchTest8 etc.),
+ we require that the given TrustedImm32 is in range of 8bit. While achieving this in
+ the manual MacroAssembler calling is easy, in Air, we don't guarantee that the higher bit
+ of the 8bit argument is cleared. So the current assertions are invalid.
+
+ This patch relaxes the above restriction. By removing this assertion,
+ 8bit operations can take arbitrary 32bit imms. And only lower 8bit are effective when
+ emitting the code in these methods.
+
+ * assembler/MacroAssembler.h:
+ (JSC::MacroAssembler::branchTest8):
+ * assembler/MacroAssemblerARM.h:
+ (JSC::MacroAssemblerARM::store8):
+ (JSC::MacroAssemblerARM::branch8):
+ (JSC::MacroAssemblerARM::branchTest8):
+ (JSC::MacroAssemblerARM::compare8):
+ (JSC::MacroAssemblerARM::test8):
+ * assembler/MacroAssemblerARM64.h:
+ (JSC::MacroAssemblerARM64::store8):
+ (JSC::MacroAssemblerARM64::branch8):
+ (JSC::MacroAssemblerARM64::branchTest8):
+ (JSC::MacroAssemblerARM64::compare8):
+ (JSC::MacroAssemblerARM64::test8):
+ * assembler/MacroAssemblerARMv7.h:
+ (JSC::MacroAssemblerARMv7::store8):
+ (JSC::MacroAssemblerARMv7::branch8):
+ (JSC::MacroAssemblerARMv7::branchTest8):
+ (JSC::MacroAssemblerARMv7::compare8):
+ (JSC::MacroAssemblerARMv7::test8):
+ * assembler/MacroAssemblerMIPS.h:
+ (JSC::MacroAssemblerMIPS::store8):
+ (JSC::MacroAssemblerMIPS::branch8):
+ (JSC::MacroAssemblerMIPS::compare8):
+ (JSC::MacroAssemblerMIPS::branchTest8):
+ (JSC::MacroAssemblerMIPS::test8):
+ * assembler/MacroAssemblerSH4.h:
+ (JSC::MacroAssemblerSH4::store8):
+ (JSC::MacroAssemblerSH4::branchTest8):
+ (JSC::MacroAssemblerSH4::branch8):
+ (JSC::MacroAssemblerSH4::compare8):
+ (JSC::MacroAssemblerSH4::test8):
+ * assembler/MacroAssemblerX86.h:
+ (JSC::MacroAssemblerX86::store8):
+ (JSC::MacroAssemblerX86::branch8):
+ (JSC::MacroAssemblerX86::branchTest8):
+ * assembler/MacroAssemblerX86Common.h:
+ (JSC::MacroAssemblerX86Common::add8):
+ (JSC::MacroAssemblerX86Common::store8):
+ (JSC::MacroAssemblerX86Common::branch8):
+ (JSC::MacroAssemblerX86Common::branchTest8):
+ (JSC::MacroAssemblerX86Common::compare8):
+ (JSC::MacroAssemblerX86Common::test8):
+ * assembler/MacroAssemblerX86_64.h:
+ (JSC::MacroAssemblerX86_64::store8):
+ (JSC::MacroAssemblerX86_64::branch8):
+ (JSC::MacroAssemblerX86_64::branchTest8):
+
</ins><span class="cx"> 2016-07-16 Chris Dumez <cdumez@apple.com>
</span><span class="cx">
</span><span class="cx"> Unreviewed, rolling out r203318.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssembler.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssembler.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssembler.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -790,7 +790,8 @@
</span><span class="cx"> using MacroAssemblerBase::branchTest8;
</span><span class="cx"> Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><del>- return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
</del><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
+ return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #else // !CPU(X86_64)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -501,14 +501,16 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, ImplicitAddress address)
</span><span class="cx"> {
</span><del>- move(imm, ARMRegisters::S1);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ move(imm8, ARMRegisters::S1);
</ins><span class="cx"> store8(ARMRegisters::S1, address);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, const void* address)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</ins><span class="cx"> move(TrustedImm32(reinterpret_cast<ARMWord>(address)), ARMRegisters::S0);
</span><del>- move(imm, ARMRegisters::S1);
</del><ins>+ move(imm8, ARMRegisters::S1);
</ins><span class="cx"> m_assembler.dtrUp(ARMAssembler::StoreUint8, ARMRegisters::S1, ARMRegisters::S0, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -623,22 +625,24 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, ARMRegisters::S1);
</span><del>- return branch32(cond, ARMRegisters::S1, right);
</del><ins>+ return branch32(cond, ARMRegisters::S1, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(right.m_value & 0xFFFFFF00));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, ARMRegisters::S1);
</span><del>- return branch32(cond, ARMRegisters::S1, right);
</del><ins>+ return branch32(cond, ARMRegisters::S1, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> move(TrustedImmPtr(left.m_ptr), ARMRegisters::S1);
</span><span class="cx"> load8(Address(ARMRegisters::S1), ARMRegisters::S1);
</span><del>- return branch32(cond, ARMRegisters::S1, right);
</del><ins>+ return branch32(cond, ARMRegisters::S1, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch32(RelationalCondition cond, RegisterID left, RegisterID right, int useConstantPool = 0)
</span><span class="lines">@@ -685,21 +689,24 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, ARMRegisters::S1);
</span><del>- return branchTest32(cond, ARMRegisters::S1, mask);
</del><ins>+ return branchTest32(cond, ARMRegisters::S1, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, ARMRegisters::S1);
</span><del>- return branchTest32(cond, ARMRegisters::S1, mask);
</del><ins>+ return branchTest32(cond, ARMRegisters::S1, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> move(TrustedImmPtr(address.m_ptr), ARMRegisters::S1);
</span><span class="cx"> load8(Address(ARMRegisters::S1), ARMRegisters::S1);
</span><del>- return branchTest32(cond, ARMRegisters::S1, mask);
</del><ins>+ return branchTest32(cond, ARMRegisters::S1, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest32(ResultCondition cond, RegisterID reg, RegisterID mask)
</span><span class="lines">@@ -965,8 +972,9 @@
</span><span class="cx">
</span><span class="cx"> void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, ARMRegisters::S1);
</span><del>- compare32(cond, ARMRegisters::S1, right, dest);
</del><ins>+ compare32(cond, ARMRegisters::S1, right8, dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void test32(ResultCondition cond, RegisterID reg, TrustedImm32 mask, RegisterID dest)
</span><span class="lines">@@ -987,8 +995,9 @@
</span><span class="cx">
</span><span class="cx"> void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, ARMRegisters::S1);
</span><del>- test32(cond, ARMRegisters::S1, mask, dest);
</del><ins>+ test32(cond, ARMRegisters::S1, mask8, dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -1408,23 +1408,25 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, void* address)
</span><span class="cx"> {
</span><del>- if (!imm.m_value) {
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ if (!imm8.m_value) {
</ins><span class="cx"> store8(ARM64Registers::zr, address);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- move(imm, getCachedDataTempRegisterIDAndInvalidate());
</del><ins>+ move(imm8, getCachedDataTempRegisterIDAndInvalidate());
</ins><span class="cx"> store8(dataTempRegister, address);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, ImplicitAddress address)
</span><span class="cx"> {
</span><del>- if (!imm.m_value) {
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ if (!imm8.m_value) {
</ins><span class="cx"> store8(ARM64Registers::zr, address);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- move(imm, getCachedDataTempRegisterIDAndInvalidate());
</del><ins>+ move(imm8, getCachedDataTempRegisterIDAndInvalidate());
</ins><span class="cx"> store8(dataTempRegister, address);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2402,23 +2404,23 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(0xffffff00 & right.m_value));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
</span><del>- return branch32(cond, memoryTempRegister, right);
</del><ins>+ return branch32(cond, memoryTempRegister, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(0xffffff00 & right.m_value));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
</span><del>- return branch32(cond, memoryTempRegister, right);
</del><ins>+ return branch32(cond, memoryTempRegister, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(0xffffff00 & right.m_value));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate());
</span><del>- return branch32(cond, memoryTempRegister, right);
</del><ins>+ return branch32(cond, memoryTempRegister, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest32(ResultCondition cond, RegisterID reg, RegisterID mask)
</span><span class="lines">@@ -2545,27 +2547,31 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, getCachedDataTempRegisterIDAndInvalidate());
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address.m_ptr, getCachedDataTempRegisterIDAndInvalidate());
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedDataTempRegisterIDAndInvalidate());
</span><span class="cx"> m_assembler.ldrb(dataTempRegister, address.base, dataTempRegister);
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, getCachedDataTempRegisterIDAndInvalidate());
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch32WithUnalignedHalfWords(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="lines">@@ -2975,8 +2981,9 @@
</span><span class="cx">
</span><span class="cx"> void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
</span><del>- move(right, getCachedDataTempRegisterIDAndInvalidate());
</del><ins>+ move(right8, getCachedDataTempRegisterIDAndInvalidate());
</ins><span class="cx"> compare32(cond, memoryTempRegister, dataTempRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -3000,8 +3007,9 @@
</span><span class="cx">
</span><span class="cx"> void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, getCachedMemoryTempRegisterIDAndInvalidate());
</span><del>- test32(cond, memoryTempRegister, mask, dest);
</del><ins>+ test32(cond, memoryTempRegister, mask8, dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void test64(ResultCondition cond, RegisterID op1, RegisterID op2, RegisterID dest)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -829,13 +829,15 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, void* address)
</span><span class="cx"> {
</span><del>- move(imm, dataTempRegister);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ move(imm8, dataTempRegister);
</ins><span class="cx"> store8(dataTempRegister, address);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, Address address)
</span><span class="cx"> {
</span><del>- move(imm, dataTempRegister);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ move(imm8, dataTempRegister);
</ins><span class="cx"> store8(dataTempRegister, address);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1476,32 +1478,34 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, RegisterID left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- compare32AndSetFlags(left, right);
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
+ compare32AndSetFlags(left, right8);
</ins><span class="cx"> return Jump(makeBranch(cond));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(0xffffff00 & right.m_value));
</del><span class="cx"> // use addressTempRegister incase the branch8 we call uses dataTempRegister. :-/
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, addressTempRegister);
</span><del>- return branch8(cond, addressTempRegister, right);
</del><ins>+ return branch8(cond, addressTempRegister, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(0xffffff00 & right.m_value));
</del><span class="cx"> // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, addressTempRegister);
</span><del>- return branch32(cond, addressTempRegister, right);
</del><ins>+ return branch32(cond, addressTempRegister, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress address, TrustedImm32 right)
</span><span class="cx"> {
</span><span class="cx"> // Use addressTempRegister instead of dataTempRegister, since branch32 uses dataTempRegister.
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><span class="cx"> load8(Address(addressTempRegister), addressTempRegister);
</span><del>- return branch32(cond, addressTempRegister, right);
</del><ins>+ return branch32(cond, addressTempRegister, right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest32(ResultCondition cond, RegisterID reg, RegisterID mask)
</span><span class="lines">@@ -1535,23 +1539,26 @@
</span><span class="cx"> Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, addressTempRegister);
</span><del>- return branchTest32(cond, addressTempRegister, mask);
</del><ins>+ return branchTest32(cond, addressTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, addressTempRegister);
</span><del>- return branchTest32(cond, addressTempRegister, mask);
</del><ins>+ return branchTest32(cond, addressTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><span class="cx"> // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><span class="cx"> load8(Address(addressTempRegister), addressTempRegister);
</span><del>- return branchTest32(cond, addressTempRegister, mask);
</del><ins>+ return branchTest32(cond, addressTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void jump(RegisterID target)
</span><span class="lines">@@ -1778,8 +1785,9 @@
</span><span class="cx">
</span><span class="cx"> void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, addressTempRegister);
</span><del>- compare32(cond, addressTempRegister, right, dest);
</del><ins>+ compare32(cond, addressTempRegister, right8, dest);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void compare32(RelationalCondition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
</span><span class="lines">@@ -1805,8 +1813,9 @@
</span><span class="cx">
</span><span class="cx"> void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, dataTempRegister);
</span><del>- test32(dataTempRegister, mask);
</del><ins>+ test32(dataTempRegister, mask8);
</ins><span class="cx"> m_assembler.it(armV7Condition(cond), false);
</span><span class="cx"> m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(1));
</span><span class="cx"> m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(0));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -1091,11 +1091,12 @@
</span><span class="cx"> li addrTemp, address
</span><span class="cx"> sb src, 0(addrTemp)
</span><span class="cx"> */
</span><del>- if (!imm.m_value && !m_fixedWidth) {
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ if (!imm8.m_value && !m_fixedWidth) {
</ins><span class="cx"> move(TrustedImmPtr(address), addrTempRegister);
</span><span class="cx"> m_assembler.sb(MIPSRegisters::zero, addrTempRegister, 0);
</span><span class="cx"> } else {
</span><del>- move(imm, immTempRegister);
</del><ins>+ move(imm8, immTempRegister);
</ins><span class="cx"> move(TrustedImmPtr(address), addrTempRegister);
</span><span class="cx"> m_assembler.sb(immTempRegister, addrTempRegister, 0);
</span><span class="cx"> }
</span><span class="lines">@@ -1103,12 +1104,13 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, ImplicitAddress address)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</ins><span class="cx"> if (address.offset >= -32768 && address.offset <= 32767
</span><span class="cx"> && !m_fixedWidth) {
</span><del>- if (!imm.m_value)
</del><ins>+ if (!imm8.m_value)
</ins><span class="cx"> m_assembler.sb(MIPSRegisters::zero, address.base, address.offset);
</span><span class="cx"> else {
</span><del>- move(imm, immTempRegister);
</del><ins>+ move(imm8, immTempRegister);
</ins><span class="cx"> m_assembler.sb(immTempRegister, address.base, address.offset);
</span><span class="cx"> }
</span><span class="cx"> } else {
</span><span class="lines">@@ -1119,10 +1121,10 @@
</span><span class="cx"> */
</span><span class="cx"> m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);
</span><span class="cx"> m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
</span><del>- if (!imm.m_value && !m_fixedWidth)
</del><ins>+ if (!imm8.m_value && !m_fixedWidth)
</ins><span class="cx"> m_assembler.sb(MIPSRegisters::zero, addrTempRegister, address.offset);
</span><span class="cx"> else {
</span><del>- move(imm, immTempRegister);
</del><ins>+ move(imm8, immTempRegister);
</ins><span class="cx"> m_assembler.sb(immTempRegister, addrTempRegister, address.offset);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -1444,38 +1446,35 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- // Make sure the immediate value is unsigned 8 bits.
- ASSERT(!(right.m_value & 0xFFFFFF00));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, dataTempRegister);
</span><del>- move(right, immTempRegister);
</del><ins>+ move(right8, immTempRegister);
</ins><span class="cx"> return branch32(cond, dataTempRegister, immTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- // Make sure the immediate value is unsigned 8 bits.
- ASSERT(!(right.m_value & 0xFFFFFF00));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, dataTempRegister);
</span><del>- move(right, immTempRegister);
</del><ins>+ move(right8, immTempRegister);
</ins><span class="cx"> return branch32(cond, dataTempRegister, immTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
</span><span class="cx"> {
</span><del>- // Make sure the immediate value is unsigned 8 bits.
- ASSERT(!(right.m_value & 0xFFFFFF00));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, dataTempRegister);
</span><del>- move(right, immTempRegister);
</del><ins>+ move(right8, immTempRegister);
</ins><span class="cx"> compare32(cond, dataTempRegister, immTempRegister, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(right.m_value & 0xFFFFFF00));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> load8(left, dataTempRegister);
</span><span class="cx"> // Be careful that the previous load8() uses immTempRegister.
</span><span class="cx"> // So, we need to put move() after load8().
</span><del>- move(right, immTempRegister);
</del><ins>+ move(right8, immTempRegister);
</ins><span class="cx"> return branch32(cond, dataTempRegister, immTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1630,21 +1629,24 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, dataTempRegister);
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, dataTempRegister);
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> move(TrustedImmPtr(address.m_ptr), dataTempRegister);
</span><span class="cx"> load8(Address(dataTempRegister), dataTempRegister);
</span><del>- return branchTest32(cond, dataTempRegister, mask);
</del><ins>+ return branchTest32(cond, dataTempRegister, mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump jump()
</span><span class="lines">@@ -2217,14 +2219,15 @@
</span><span class="cx"> void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
</span><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> load8(address, dataTempRegister);
</span><del>- if (mask.m_value == -1 && !m_fixedWidth) {
</del><ins>+ if (mask8.m_value == -1 && !m_fixedWidth) {
</ins><span class="cx"> if (cond == Zero)
</span><span class="cx"> m_assembler.sltiu(dest, dataTempRegister, 1);
</span><span class="cx"> else
</span><span class="cx"> m_assembler.sltu(dest, MIPSRegisters::zero, dataTempRegister);
</span><span class="cx"> } else {
</span><del>- move(mask, immTempRegister);
</del><ins>+ move(mask8, immTempRegister);
</ins><span class="cx"> m_assembler.andInsn(cmpTempRegister, dataTempRegister, immTempRegister);
</span><span class="cx"> if (cond == Zero)
</span><span class="cx"> m_assembler.sltiu(dest, cmpTempRegister, 1);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerSH4h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -921,11 +921,11 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, void* address)
</span><span class="cx"> {
</span><del>- ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</ins><span class="cx"> RegisterID dstptr = claimScratch();
</span><span class="cx"> move(TrustedImmPtr(address), dstptr);
</span><span class="cx"> RegisterID srcval = claimScratch();
</span><del>- move(imm, srcval);
</del><ins>+ move(imm8, srcval);
</ins><span class="cx"> m_assembler.movbRegMem(srcval, dstptr);
</span><span class="cx"> releaseScratch(dstptr);
</span><span class="cx"> releaseScratch(srcval);
</span><span class="lines">@@ -933,12 +933,12 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, Address address)
</span><span class="cx"> {
</span><del>- ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</ins><span class="cx"> RegisterID dstptr = claimScratch();
</span><span class="cx"> move(address.base, dstptr);
</span><span class="cx"> add32(TrustedImm32(address.offset), dstptr);
</span><span class="cx"> RegisterID srcval = claimScratch();
</span><del>- move(imm, srcval);
</del><ins>+ move(imm8, srcval);
</ins><span class="cx"> m_assembler.movbRegMem(srcval, dstptr);
</span><span class="cx"> releaseScratch(dstptr);
</span><span class="cx"> releaseScratch(srcval);
</span><span class="lines">@@ -1595,9 +1595,10 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span><span class="cx"> load8(address, addressTempRegister);
</span><del>- Jump jmp = branchTest32(cond, addressTempRegister, mask);
</del><ins>+ Jump jmp = branchTest32(cond, addressTempRegister, mask8);
</ins><span class="cx"> releaseScratch(addressTempRegister);
</span><span class="cx"> return jmp;
</span><span class="cx"> }
</span><span class="lines">@@ -1604,9 +1605,10 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span><span class="cx"> load8(address, addressTempRegister);
</span><del>- Jump jmp = branchTest32(cond, addressTempRegister, mask);
</del><ins>+ Jump jmp = branchTest32(cond, addressTempRegister, mask8);
</ins><span class="cx"> releaseScratch(addressTempRegister);
</span><span class="cx"> return jmp;
</span><span class="cx"> }
</span><span class="lines">@@ -1613,10 +1615,11 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span><span class="cx"> move(TrustedImmPtr(address.m_ptr), addressTempRegister);
</span><span class="cx"> load8(Address(addressTempRegister), addressTempRegister);
</span><del>- Jump jmp = branchTest32(cond, addressTempRegister, mask);
</del><ins>+ Jump jmp = branchTest32(cond, addressTempRegister, mask8);
</ins><span class="cx"> releaseScratch(addressTempRegister);
</span><span class="cx"> return jmp;
</span><span class="cx"> }
</span><span class="lines">@@ -1633,9 +1636,10 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span><span class="cx"> load8(left, addressTempRegister);
</span><del>- Jump jmp = branch32(cond, addressTempRegister, right);
</del><ins>+ Jump jmp = branch32(cond, addressTempRegister, right8);
</ins><span class="cx"> releaseScratch(addressTempRegister);
</span><span class="cx"> return jmp;
</span><span class="cx"> }
</span><span class="lines">@@ -1642,9 +1646,10 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span><span class="cx"> load8(left, addressTempRegister);
</span><del>- Jump jmp = branch32(cond, addressTempRegister, right);
</del><ins>+ Jump jmp = branch32(cond, addressTempRegister, right8);
</ins><span class="cx"> releaseScratch(addressTempRegister);
</span><span class="cx"> return jmp;
</span><span class="cx"> }
</span><span class="lines">@@ -1651,9 +1656,10 @@
</span><span class="cx">
</span><span class="cx"> void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span><span class="cx"> load8(left, addressTempRegister);
</span><del>- compare32(cond, addressTempRegister, right, dest);
</del><ins>+ compare32(cond, addressTempRegister, right8, dest);
</ins><span class="cx"> releaseScratch(addressTempRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1825,11 +1831,13 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT((cond == Zero) || (cond == NonZero));
</span><span class="cx">
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
+
</ins><span class="cx"> load8(address, dest);
</span><del>- if (mask.m_value == -1)
</del><ins>+ if (mask8.m_value == -1)
</ins><span class="cx"> compare32(0, dest, static_cast<RelationalCondition>(cond));
</span><span class="cx"> else
</span><del>- testlImm(mask.m_value, dest);
</del><ins>+ testlImm(mask8.m_value, dest);
</ins><span class="cx"> if (cond != NonZero) {
</span><span class="cx"> m_assembler.movt(dest);
</span><span class="cx"> return;
</span><span class="lines">@@ -1947,7 +1955,7 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- ASSERT(!(right.m_value & 0xFFFFFF00));
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> RegisterID lefttmp = claimScratch();
</span><span class="cx">
</span><span class="cx"> loadEffectiveAddress(left, lefttmp);
</span><span class="lines">@@ -1954,7 +1962,7 @@
</span><span class="cx">
</span><span class="cx"> load8(lefttmp, lefttmp);
</span><span class="cx"> RegisterID righttmp = claimScratch();
</span><del>- m_assembler.loadConstant(right.m_value, righttmp);
</del><ins>+ m_assembler.loadConstant(right8.m_value, righttmp);
</ins><span class="cx">
</span><span class="cx"> Jump result = branch32(cond, lefttmp, righttmp);
</span><span class="cx"> releaseScratch(lefttmp);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -160,8 +160,8 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, void* address)
</span><span class="cx"> {
</span><del>- ASSERT(-128 <= imm.m_value && imm.m_value < 128);
- m_assembler.movb_i8m(imm.m_value, address);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ m_assembler.movb_i8m(imm8.m_value, address);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void moveDoubleToInts(FPRegisterID src, RegisterID dest1, RegisterID dest2)
</span><span class="lines">@@ -237,17 +237,18 @@
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- m_assembler.cmpb_im(right.m_value, left.m_ptr);
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
+ m_assembler.cmpb_im(right8.m_value, left.m_ptr);
</ins><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><del>- ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
- if (mask.m_value == -1)
</del><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
+ if (mask8.m_value == -1)
</ins><span class="cx"> m_assembler.cmpb_im(0, address.m_ptr);
</span><span class="cx"> else
</span><del>- m_assembler.testb_im(mask.m_value, address.m_ptr);
</del><ins>+ m_assembler.testb_im(mask8.m_value, address.m_ptr);
</ins><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -135,12 +135,14 @@
</span><span class="cx">
</span><span class="cx"> void add8(TrustedImm32 imm, Address address)
</span><span class="cx"> {
</span><del>- m_assembler.addb_im(imm.m_value, address.offset, address.base);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ m_assembler.addb_im(imm8.m_value, address.offset, address.base);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void add8(TrustedImm32 imm, BaseIndex address)
</span><span class="cx"> {
</span><del>- m_assembler.addb_im(imm.m_value, address.offset, address.base, address.index, address.scale);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ m_assembler.addb_im(imm8.m_value, address.offset, address.base, address.index, address.scale);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void add16(TrustedImm32 imm, Address address)
</span><span class="lines">@@ -908,12 +910,14 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, Address address)
</span><span class="cx"> {
</span><del>- m_assembler.movb_i8m(static_cast<int8_t>(imm.m_value), address.offset, address.base);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ m_assembler.movb_i8m(imm8.m_value, address.offset, address.base);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, BaseIndex address)
</span><span class="cx"> {
</span><del>- m_assembler.movb_i8m(static_cast<int8_t>(imm.m_value), address.offset, address.base, address.index, address.scale);
</del><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
+ m_assembler.movb_i8m(imm8.m_value, address.offset, address.base, address.index, address.scale);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static ALWAYS_INLINE RegisterID getUnusedRegister(BaseIndex address)
</span><span class="lines">@@ -2121,7 +2125,8 @@
</span><span class="cx"> public:
</span><span class="cx"> Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- m_assembler.cmpb_im(right.m_value, left.offset, left.base);
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
+ m_assembler.cmpb_im(right8.m_value, left.offset, left.base);
</ins><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2218,32 +2223,28 @@
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><del>- // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values.
- ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
- if (mask.m_value == -1)
</del><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
+ if (mask8.m_value == -1)
</ins><span class="cx"> m_assembler.cmpb_im(0, address.offset, address.base);
</span><span class="cx"> else
</span><del>- m_assembler.testb_im(mask.m_value, address.offset, address.base);
</del><ins>+ m_assembler.testb_im(mask8.m_value, address.offset, address.base);
</ins><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><del>- // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values.
- ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
- if (mask.m_value == -1)
</del><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
+ if (mask8.m_value == -1)
</ins><span class="cx"> m_assembler.cmpb_im(0, address.offset, address.base, address.index, address.scale);
</span><span class="cx"> else
</span><del>- m_assembler.testb_im(mask.m_value, address.offset, address.base, address.index, address.scale);
</del><ins>+ m_assembler.testb_im(mask8.m_value, address.offset, address.base, address.index, address.scale);
</ins><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
</span><span class="cx"> {
</span><del>- // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values.
- ASSERT(right.m_value >= -128 && right.m_value <= 255);
-
- m_assembler.cmpb_im(right.m_value, left.offset, left.base, left.index, left.scale);
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
+ m_assembler.cmpb_im(right8.m_value, left.offset, left.base, left.index, left.scale);
</ins><span class="cx"> return Jump(m_assembler.jCC(x86Condition(cond)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2459,7 +2460,8 @@
</span><span class="cx">
</span><span class="cx"> void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
</span><span class="cx"> {
</span><del>- m_assembler.cmpb_im(right.m_value, left.offset, left.base);
</del><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
+ m_assembler.cmpb_im(right8.m_value, left.offset, left.base);
</ins><span class="cx"> set32(x86Condition(cond), dest);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2489,10 +2491,11 @@
</span><span class="cx">
</span><span class="cx"> void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
</span><span class="cx"> {
</span><del>- if (mask.m_value == -1)
</del><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
+ if (mask8.m_value == -1)
</ins><span class="cx"> m_assembler.cmpb_im(0, address.offset, address.base);
</span><span class="cx"> else
</span><del>- m_assembler.testb_im(mask.m_value, address.offset, address.base);
</del><ins>+ m_assembler.testb_im(mask8.m_value, address.offset, address.base);
</ins><span class="cx"> set32(x86Condition(cond), dest);
</span><span class="cx"> }
</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 (203330 => 203331)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h 2016-07-17 07:16:03 UTC (rev 203330)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h 2016-07-17 14:33:26 UTC (rev 203331)
</span><span class="lines">@@ -137,8 +137,9 @@
</span><span class="cx">
</span><span class="cx"> void store8(TrustedImm32 imm, void* address)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
</ins><span class="cx"> move(TrustedImmPtr(address), scratchRegister());
</span><del>- store8(imm, Address(scratchRegister()));
</del><ins>+ store8(imm8, Address(scratchRegister()));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void store8(RegisterID reg, void* address)
</span><span class="lines">@@ -1210,22 +1211,25 @@
</span><span class="cx"> using MacroAssemblerX86Common::branch8;
</span><span class="cx"> Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
</span><span class="cx"> {
</span><ins>+ TrustedImm32 right8(static_cast<int8_t>(right.m_value));
</ins><span class="cx"> MacroAssemblerX86Common::move(TrustedImmPtr(left.m_ptr), scratchRegister());
</span><del>- return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right);
</del><ins>+ return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> using MacroAssemblerX86Common::branchTest8;
</span><span class="cx"> Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> TrustedImmPtr addr(reinterpret_cast<void*>(address.offset));
</span><span class="cx"> MacroAssemblerX86Common::move(addr, scratchRegister());
</span><del>- return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask);
</del><ins>+ return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><ins>+ TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
</ins><span class="cx"> MacroAssemblerX86Common::move(TrustedImmPtr(address.m_ptr), scratchRegister());
</span><del>- return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask);
</del><ins>+ return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask8);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void convertInt64ToDouble(RegisterID src, FPRegisterID dest)
</span></span></pre>
</div>
</div>
</body>
</html>