<!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>[210124] trunk</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/210124">210124</a></dd>
<dt>Author</dt> <dd>keith_miller@apple.com</dd>
<dt>Date</dt> <dd>2016-12-22 17:19:55 -0800 (Thu, 22 Dec 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Add BitOr for floating points to B3
https://bugs.webkit.org/show_bug.cgi?id=166446
Reviewed by Saam Barati.
Source/JavaScriptCore:
This patch does some slight refactoring to the ARM assembler,
which groups all the vector floating point instructions together.
* assembler/ARM64Assembler.h:
(JSC::ARM64Assembler::vand):
(JSC::ARM64Assembler::vorr):
(JSC::ARM64Assembler::vectorDataProcessingLogical):
(JSC::ARM64Assembler::vectorDataProcessing2Source): Deleted.
* assembler/MacroAssemblerARM64.h:
(JSC::MacroAssemblerARM64::orDouble):
(JSC::MacroAssemblerARM64::orFloat):
* assembler/MacroAssemblerX86Common.h:
(JSC::MacroAssemblerX86Common::orDouble):
(JSC::MacroAssemblerX86Common::orFloat):
* assembler/X86Assembler.h:
(JSC::X86Assembler::orps_rr):
* b3/B3ConstDoubleValue.cpp:
(JSC::B3::ConstDoubleValue::bitOrConstant):
(JSC::B3::ConstDoubleValue::bitXorConstant):
* b3/B3ConstDoubleValue.h:
* b3/B3ConstFloatValue.cpp:
(JSC::B3::ConstFloatValue::bitOrConstant):
(JSC::B3::ConstFloatValue::bitXorConstant):
* b3/B3ConstFloatValue.h:
* b3/B3LowerToAir.cpp:
(JSC::B3::Air::LowerToAir::lower):
* b3/B3Validate.cpp:
* b3/air/AirInstInlines.h:
(JSC::B3::Air::Inst::shouldTryAliasingDef):
* b3/air/AirOpcode.opcodes:
* b3/testb3.cpp:
(JSC::B3::bitOrDouble):
(JSC::B3::testBitOrArgDouble):
(JSC::B3::testBitOrArgsDouble):
(JSC::B3::testBitOrArgImmDouble):
(JSC::B3::testBitOrImmsDouble):
(JSC::B3::bitOrFloat):
(JSC::B3::testBitOrArgFloat):
(JSC::B3::testBitOrArgsFloat):
(JSC::B3::testBitOrArgImmFloat):
(JSC::B3::testBitOrImmsFloat):
(JSC::B3::testBitOrArgsFloatWithUselessDoubleConversion):
(JSC::B3::run):
Websites/webkit.org:
Update docs to indicate it's cool to use bit ops with floating point.
* docs/b3/intermediate-representation.html:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerARM64Assemblerh">trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerX86Assemblerh">trunk/Source/JavaScriptCore/assembler/X86Assembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstDoubleValuecpp">trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstDoubleValueh">trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstFloatValuecpp">trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstFloatValueh">trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3LowerToAircpp">trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3Validatecpp">trunk/Source/JavaScriptCore/b3/B3Validate.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirInstInlinesh">trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirOpcodeopcodes">trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3testb3cpp">trunk/Source/JavaScriptCore/b3/testb3.cpp</a></li>
<li><a href="#trunkWebsiteswebkitorgChangeLog">trunk/Websites/webkit.org/ChangeLog</a></li>
<li><a href="#trunkWebsiteswebkitorgdocsb3intermediaterepresentationhtml">trunk/Websites/webkit.org/docs/b3/intermediate-representation.html</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -1,3 +1,54 @@
</span><ins>+2016-12-22 Keith Miller <keith_miller@apple.com>
+
+ Add BitOr for floating points to B3
+ https://bugs.webkit.org/show_bug.cgi?id=166446
+
+ Reviewed by Saam Barati.
+
+ This patch does some slight refactoring to the ARM assembler,
+ which groups all the vector floating point instructions together.
+
+ * assembler/ARM64Assembler.h:
+ (JSC::ARM64Assembler::vand):
+ (JSC::ARM64Assembler::vorr):
+ (JSC::ARM64Assembler::vectorDataProcessingLogical):
+ (JSC::ARM64Assembler::vectorDataProcessing2Source): Deleted.
+ * assembler/MacroAssemblerARM64.h:
+ (JSC::MacroAssemblerARM64::orDouble):
+ (JSC::MacroAssemblerARM64::orFloat):
+ * assembler/MacroAssemblerX86Common.h:
+ (JSC::MacroAssemblerX86Common::orDouble):
+ (JSC::MacroAssemblerX86Common::orFloat):
+ * assembler/X86Assembler.h:
+ (JSC::X86Assembler::orps_rr):
+ * b3/B3ConstDoubleValue.cpp:
+ (JSC::B3::ConstDoubleValue::bitOrConstant):
+ (JSC::B3::ConstDoubleValue::bitXorConstant):
+ * b3/B3ConstDoubleValue.h:
+ * b3/B3ConstFloatValue.cpp:
+ (JSC::B3::ConstFloatValue::bitOrConstant):
+ (JSC::B3::ConstFloatValue::bitXorConstant):
+ * b3/B3ConstFloatValue.h:
+ * b3/B3LowerToAir.cpp:
+ (JSC::B3::Air::LowerToAir::lower):
+ * b3/B3Validate.cpp:
+ * b3/air/AirInstInlines.h:
+ (JSC::B3::Air::Inst::shouldTryAliasingDef):
+ * b3/air/AirOpcode.opcodes:
+ * b3/testb3.cpp:
+ (JSC::B3::bitOrDouble):
+ (JSC::B3::testBitOrArgDouble):
+ (JSC::B3::testBitOrArgsDouble):
+ (JSC::B3::testBitOrArgImmDouble):
+ (JSC::B3::testBitOrImmsDouble):
+ (JSC::B3::bitOrFloat):
+ (JSC::B3::testBitOrArgFloat):
+ (JSC::B3::testBitOrArgsFloat):
+ (JSC::B3::testBitOrArgImmFloat):
+ (JSC::B3::testBitOrImmsFloat):
+ (JSC::B3::testBitOrArgsFloatWithUselessDoubleConversion):
+ (JSC::B3::run):
+
</ins><span class="cx"> 2016-12-22 Mark Lam <mark.lam@apple.com>
</span><span class="cx">
</span><span class="cx"> BytecodeGenerator::m_finallyDepth should be unsigned.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerARM64Assemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -621,9 +621,21 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> enum SIMD3Same {
</span><del>- SIMD_LogicalOp_AND = 0x03
</del><ins>+ SIMD_LogicalOp = 0x03
</ins><span class="cx"> };
</span><span class="cx">
</span><ins>+ enum SIMD3SameLogical {
+ // This includes both the U bit and the "size" / opc for convience.
+ SIMD_LogicalOp_AND = 0x00,
+ SIMD_LogicalOp_BIC = 0x01,
+ SIMD_LogicalOp_ORR = 0x02,
+ SIMD_LogicalOp_ORN = 0x03,
+ SIMD_LogacalOp_EOR = 0x80,
+ SIMD_LogicalOp_BSL = 0x81,
+ SIMD_LogicalOp_BIT = 0x82,
+ SIMD_LogicalOp_BIF = 0x83,
+ };
+
</ins><span class="cx"> enum FPIntConvOp {
</span><span class="cx"> FPIntConvOp_FCVTNS = 0x00,
</span><span class="cx"> FPIntConvOp_FCVTNU = 0x01,
</span><span class="lines">@@ -2222,10 +2234,17 @@
</span><span class="cx"> ALWAYS_INLINE void vand(FPRegisterID vd, FPRegisterID vn, FPRegisterID vm)
</span><span class="cx"> {
</span><span class="cx"> CHECK_VECTOR_DATASIZE();
</span><del>- insn(vectorDataProcessing2Source(SIMD_LogicalOp_AND, vm, vn, vd));
</del><ins>+ insn(vectorDataProcessingLogical(SIMD_LogicalOp_AND, vm, vn, vd));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<int datasize>
</span><ins>+ ALWAYS_INLINE void vorr(FPRegisterID vd, FPRegisterID vn, FPRegisterID vm)
+ {
+ CHECK_VECTOR_DATASIZE();
+ insn(vectorDataProcessingLogical(SIMD_LogicalOp_ORR, vm, vn, vd));
+ }
+
+ template<int datasize>
</ins><span class="cx"> ALWAYS_INLINE void frinta(FPRegisterID vd, FPRegisterID vn)
</span><span class="cx"> {
</span><span class="cx"> CHECK_DATASIZE();
</span><span class="lines">@@ -3328,18 +3347,12 @@
</span><span class="cx"> return (0x1e200800 | M << 31 | S << 29 | type << 22 | rm << 16 | opcode << 12 | rn << 5 | rd);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- ALWAYS_INLINE static int vectorDataProcessing2Source(SIMD3Same opcode, unsigned size, FPRegisterID vm, FPRegisterID vn, FPRegisterID vd)
</del><ins>+ ALWAYS_INLINE static int vectorDataProcessingLogical(SIMD3SameLogical uAndSize, FPRegisterID vm, FPRegisterID vn, FPRegisterID vd)
</ins><span class="cx"> {
</span><span class="cx"> const int Q = 0;
</span><del>- return (0xe201c00 | Q << 30 | size << 22 | vm << 16 | opcode << 11 | vn << 5 | vd);
</del><ins>+ return (0xe200400 | Q << 30 | uAndSize << 22 | vm << 16 | SIMD_LogicalOp << 11 | vn << 5 | vd);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- ALWAYS_INLINE static int vectorDataProcessing2Source(SIMD3Same opcode, FPRegisterID vm, FPRegisterID vn, FPRegisterID vd)
- {
- return vectorDataProcessing2Source(opcode, 0, vm, vn, vd);
- }
-
-
</del><span class="cx"> // 'o1' means negate
</span><span class="cx"> ALWAYS_INLINE static int floatingPointDataProcessing3Source(Datasize type, bool o1, FPRegisterID rm, AddOp o2, FPRegisterID ra, FPRegisterID rn, FPRegisterID rd)
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -1941,6 +1941,16 @@
</span><span class="cx"> andDouble(op1, op2, dest);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void orDouble(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
+ {
+ m_assembler.vorr<64>(dest, op1, op2);
+ }
+
+ void orFloat(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
+ {
+ orDouble(op1, op2, dest);
+ }
+
</ins><span class="cx"> void negateDouble(FPRegisterID src, FPRegisterID dest)
</span><span class="cx"> {
</span><span class="cx"> m_assembler.fneg<64>(dest, src);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -1589,6 +1589,36 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void orDouble(FPRegisterID src, FPRegisterID dst)
+ {
+ m_assembler.orps_rr(src, dst);
+ }
+
+ void orDouble(FPRegisterID src1, FPRegisterID src2, FPRegisterID dst)
+ {
+ if (src1 == dst)
+ orDouble(src2, dst);
+ else {
+ moveDouble(src2, dst);
+ orDouble(src1, dst);
+ }
+ }
+
+ void orFloat(FPRegisterID src, FPRegisterID dst)
+ {
+ m_assembler.orps_rr(src, dst);
+ }
+
+ void orFloat(FPRegisterID src1, FPRegisterID src2, FPRegisterID dst)
+ {
+ if (src1 == dst)
+ orFloat(src2, dst);
+ else {
+ moveDouble(src2, dst);
+ orFloat(src1, dst);
+ }
+ }
+
</ins><span class="cx"> void xorDouble(FPRegisterID src, FPRegisterID dst)
</span><span class="cx"> {
</span><span class="cx"> m_assembler.xorps_rr(src, dst);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerX86Assemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/X86Assembler.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/X86Assembler.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/assembler/X86Assembler.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -281,6 +281,7 @@
</span><span class="cx"> OP2_SQRTSD_VsdWsd = 0x51,
</span><span class="cx"> OP2_ANDPS_VpdWpd = 0x54,
</span><span class="cx"> OP2_ANDNPD_VpdWpd = 0x55,
</span><ins>+ OP2_ORPS_VpdWpd = 0x56,
</ins><span class="cx"> OP2_XORPD_VpdWpd = 0x57,
</span><span class="cx"> OP2_MOVD_VdEd = 0x6E,
</span><span class="cx"> OP2_MOVD_EdVd = 0x7E,
</span><span class="lines">@@ -2660,6 +2661,11 @@
</span><span class="cx"> m_formatter.twoByteOp(OP2_ANDPS_VpdWpd, (RegisterID)dst, (RegisterID)src);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void orps_rr(XMMRegisterID src, XMMRegisterID dst)
+ {
+ m_formatter.twoByteOp(OP2_ORPS_VpdWpd, (RegisterID)dst, (RegisterID)src);
+ }
+
</ins><span class="cx"> void xorps_rr(XMMRegisterID src, XMMRegisterID dst)
</span><span class="cx"> {
</span><span class="cx"> m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstDoubleValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -77,6 +77,23 @@
</span><span class="cx"> return proc.add<ConstDoubleValue>(origin(), result);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+Value* ConstDoubleValue::bitOrConstant(Procedure& proc, const Value* other) const
+{
+ if (!other->hasDouble())
+ return nullptr;
+ double result = bitwise_cast<double>(bitwise_cast<uint64_t>(m_value) | bitwise_cast<uint64_t>(other->asDouble()));
+ return proc.add<ConstDoubleValue>(origin(), result);
+}
+
+Value* ConstDoubleValue::bitXorConstant(Procedure& proc, const Value* other) const
+{
+ if (!other->hasDouble())
+ return nullptr;
+ double result = bitwise_cast<double>(bitwise_cast<uint64_t>(m_value) ^ bitwise_cast<uint64_t>(other->asDouble()));
+ return proc.add<ConstDoubleValue>(origin(), result);
+}
+
+
</ins><span class="cx"> Value* ConstDoubleValue::bitwiseCastConstant(Procedure& proc) const
</span><span class="cx"> {
</span><span class="cx"> return proc.add<Const64Value>(origin(), bitwise_cast<int64_t>(m_value));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstDoubleValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -47,6 +47,8 @@
</span><span class="cx"> Value* modConstant(Procedure&, const Value* other) const override;
</span><span class="cx"> Value* mulConstant(Procedure&, const Value* other) const override;
</span><span class="cx"> Value* bitAndConstant(Procedure&, const Value* other) const override;
</span><ins>+ Value* bitOrConstant(Procedure&, const Value* other) const override;
+ Value* bitXorConstant(Procedure&, const Value* other) const override;
</ins><span class="cx"> Value* bitwiseCastConstant(Procedure&) const override;
</span><span class="cx"> Value* doubleToFloatConstant(Procedure&) const override;
</span><span class="cx"> Value* absConstant(Procedure&) const override;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstFloatValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -77,6 +77,22 @@
</span><span class="cx"> return proc.add<ConstFloatValue>(origin(), result);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+Value* ConstFloatValue::bitOrConstant(Procedure& proc, const Value* other) const
+{
+ if (!other->hasFloat())
+ return nullptr;
+ float result = bitwise_cast<float>(bitwise_cast<uint32_t>(m_value) | bitwise_cast<uint32_t>(other->asFloat()));
+ return proc.add<ConstFloatValue>(origin(), result);
+}
+
+Value* ConstFloatValue::bitXorConstant(Procedure& proc, const Value* other) const
+{
+ if (!other->hasFloat())
+ return nullptr;
+ float result = bitwise_cast<float>(bitwise_cast<uint32_t>(m_value) ^ bitwise_cast<uint32_t>(other->asFloat()));
+ return proc.add<ConstFloatValue>(origin(), result);
+}
+
</ins><span class="cx"> Value* ConstFloatValue::bitwiseCastConstant(Procedure& proc) const
</span><span class="cx"> {
</span><span class="cx"> return proc.add<Const32Value>(origin(), bitwise_cast<int32_t>(m_value));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstFloatValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -46,6 +46,8 @@
</span><span class="cx"> Value* divConstant(Procedure&, const Value* other) const override;
</span><span class="cx"> Value* mulConstant(Procedure&, const Value* other) const override;
</span><span class="cx"> Value* bitAndConstant(Procedure&, const Value* other) const override;
</span><ins>+ Value* bitOrConstant(Procedure&, const Value* other) const override;
+ Value* bitXorConstant(Procedure&, const Value* other) const override;
</ins><span class="cx"> Value* bitwiseCastConstant(Procedure&) const override;
</span><span class="cx"> Value* floatToDoubleConstant(Procedure&) const override;
</span><span class="cx"> Value* absConstant(Procedure&) const override;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3LowerToAircpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -2153,7 +2153,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case BitOr: {
</span><del>- appendBinOp<Or32, Or64, Commutative>(
</del><ins>+ appendBinOp<Or32, Or64, OrDouble, OrFloat, Commutative>(
</ins><span class="cx"> m_value->child(0), m_value->child(1));
</span><span class="cx"> return;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Validatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Validate.cpp (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Validate.cpp 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/B3Validate.cpp 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -194,6 +194,7 @@
</span><span class="cx"> case Mod:
</span><span class="cx"> case UMod:
</span><span class="cx"> case BitAnd:
</span><ins>+ case BitOr:
</ins><span class="cx"> case BitXor:
</span><span class="cx"> VALIDATE(!value->kind().traps(), ("At ", *value));
</span><span class="cx"> switch (value->opcode()) {
</span><span class="lines">@@ -219,13 +220,6 @@
</span><span class="cx"> VALIDATE(value->type() == value->child(0)->type(), ("At ", *value));
</span><span class="cx"> VALIDATE(value->type() != Void, ("At ", *value));
</span><span class="cx"> break;
</span><del>- case BitOr:
- VALIDATE(!value->kind().hasExtraBits(), ("At ", *value));
- VALIDATE(value->numChildren() == 2, ("At ", *value));
- VALIDATE(value->type() == value->child(0)->type(), ("At ", *value));
- VALIDATE(value->type() == value->child(1)->type(), ("At ", *value));
- VALIDATE(isInt(value->type()), ("At ", *value));
- break;
</del><span class="cx"> case Shl:
</span><span class="cx"> case SShr:
</span><span class="cx"> case ZShr:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirInstInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -129,6 +129,8 @@
</span><span class="cx"> case Xor64:
</span><span class="cx"> case AndFloat:
</span><span class="cx"> case AndDouble:
</span><ins>+ case OrFloat:
+ case OrDouble:
</ins><span class="cx"> case XorDouble:
</span><span class="cx"> case XorFloat:
</span><span class="cx"> if (args.size() == 3)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirOpcodeopcodes"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -353,6 +353,18 @@
</span><span class="cx"> x86: AndFloat U:F:32, UD:F:32
</span><span class="cx"> Tmp, Tmp
</span><span class="cx">
</span><ins>+OrDouble U:F:64, U:F:64, D:F:64
+ Tmp, Tmp, Tmp
+
+x86: OrDouble U:F:64, UD:F:64
+ Tmp, Tmp
+
+OrFloat U:F:32, U:F:32, D:F:32
+ Tmp, Tmp, Tmp
+
+x86: OrFloat U:F:32, UD:F:32
+ Tmp, Tmp
+
</ins><span class="cx"> x86: XorDouble U:F:64, U:F:64, D:F:64
</span><span class="cx"> Tmp, Tmp, Tmp
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3testb3cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/testb3.cpp (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/testb3.cpp 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Source/JavaScriptCore/b3/testb3.cpp 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -2978,6 +2978,140 @@
</span><span class="cx"> CHECK(compileAndRun<int>(proc, b) == (a | (b | c)));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+double bitOrDouble(double a, double b)
+{
+ return bitwise_cast<double>(bitwise_cast<uint64_t>(a) | bitwise_cast<uint64_t>(b));
+}
+
+void testBitOrArgDouble(double a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argument, argument);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a), bitOrDouble(a, a)));
+}
+
+void testBitOrArgsDouble(double a, double b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
+ Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argumentA, argumentB);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a, b), bitOrDouble(a, b)));
+}
+
+void testBitOrArgImmDouble(double a, double b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
+ Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argumentA, argumentB);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a, b), bitOrDouble(a, b)));
+}
+
+void testBitOrImmsDouble(double a, double b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
+ Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argumentA, argumentB);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<double>(proc), bitOrDouble(a, b)));
+}
+
+float bitOrFloat(float a, float b)
+{
+ return bitwise_cast<float>(bitwise_cast<uint32_t>(a) | bitwise_cast<uint32_t>(b));
+}
+
+void testBitOrArgFloat(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(),
+ root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argument, argument);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), bitOrFloat(a, a)));
+}
+
+void testBitOrArgsFloat(float a, float b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<Value>(proc, BitwiseCast, Origin(),
+ root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
+ Value* argumentB = root->appendNew<Value>(proc, BitwiseCast, Origin(),
+ root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1)));
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argumentA, argumentB);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitOrFloat(a, b)));
+}
+
+void testBitOrArgImmFloat(float a, float b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<Value>(proc, BitwiseCast, Origin(),
+ root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
+ Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argumentA, argumentB);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), bitOrFloat(a, b)));
+}
+
+void testBitOrImmsFloat(float a, float b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<ConstFloatValue>(proc, Origin(), a);
+ Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
+ Value* result = root->appendNew<Value>(proc, BitOr, Origin(), argumentA, argumentB);
+ root->appendNewControlValue(proc, Return, Origin(), result);
+
+ CHECK(isIdentical(compileAndRun<float>(proc), bitOrFloat(a, b)));
+}
+
+void testBitOrArgsFloatWithUselessDoubleConversion(float a, float b)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argumentA = root->appendNew<Value>(proc, BitwiseCast, Origin(),
+ root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)));
+ Value* argumentB = root->appendNew<Value>(proc, BitwiseCast, Origin(),
+ root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1)));
+ Value* argumentAasDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argumentA);
+ Value* argumentBasDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argumentB);
+ Value* doubleResult = root->appendNew<Value>(proc, BitOr, Origin(), argumentAasDouble, argumentBasDouble);
+ Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), doubleResult);
+ root->appendNewControlValue(proc, Return, Origin(), floatResult);
+
+ double doubleA = a;
+ double doubleB = b;
+ float expected = static_cast<float>(bitOrDouble(doubleA, doubleB));
+ CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a), bitwise_cast<int32_t>(b)), expected));
+}
+
</ins><span class="cx"> void testBitXorArgs(int64_t a, int64_t b)
</span><span class="cx"> {
</span><span class="cx"> Procedure proc;
</span><span class="lines">@@ -14447,6 +14581,15 @@
</span><span class="cx"> RUN(testBitOrImmBitOrArgImm32(7, 2, 3));
</span><span class="cx"> RUN(testBitOrImmBitOrArgImm32(6, 1, 6));
</span><span class="cx"> RUN(testBitOrImmBitOrArgImm32(24, 0xffff, 7));
</span><ins>+ RUN_UNARY(testBitOrArgDouble, floatingPointOperands<double>());
+ RUN_BINARY(testBitOrArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
+ RUN_BINARY(testBitOrArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
+ RUN_BINARY(testBitOrImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
+ RUN_UNARY(testBitOrArgFloat, floatingPointOperands<float>());
+ RUN_BINARY(testBitOrArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
+ RUN_BINARY(testBitOrArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
+ RUN_BINARY(testBitOrImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
+ RUN_BINARY(testBitOrArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
</ins><span class="cx">
</span><span class="cx"> RUN_BINARY(testBitXorArgs, int64Operands(), int64Operands());
</span><span class="cx"> RUN_UNARY(testBitXorSameArg, int64Operands());
</span></span></pre></div>
<a id="trunkWebsiteswebkitorgChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Websites/webkit.org/ChangeLog (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Websites/webkit.org/ChangeLog 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Websites/webkit.org/ChangeLog 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -1,3 +1,14 @@
</span><ins>+2016-12-22 Keith Miller <keith_miller@apple.com>
+
+ Add BitOr for floating points to B3
+ https://bugs.webkit.org/show_bug.cgi?id=166446
+
+ Reviewed by Saam Barati.
+
+ Update docs to indicate it's cool to use bit ops with floating point.
+
+ * docs/b3/intermediate-representation.html:
+
</ins><span class="cx"> 2016-12-07 Dean Jackson <dino@apple.com>
</span><span class="cx">
</span><span class="cx"> Remove runtime toggle for pointer-lock
</span></span></pre></div>
<a id="trunkWebsiteswebkitorgdocsb3intermediaterepresentationhtml"></a>
<div class="modfile"><h4>Modified: trunk/Websites/webkit.org/docs/b3/intermediate-representation.html (210123 => 210124)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Websites/webkit.org/docs/b3/intermediate-representation.html 2016-12-23 00:32:25 UTC (rev 210123)
+++ trunk/Websites/webkit.org/docs/b3/intermediate-representation.html 2016-12-23 01:19:55 UTC (rev 210124)
</span><span class="lines">@@ -257,13 +257,13 @@
</span><span class="cx"> spec.</dd>
</span><span class="cx">
</span><span class="cx"> <dt>T BitAnd(T, T)</dt>
</span><del>- <dd>Bitwise and. Valid for Int32 and Int64.</dd>
</del><ins>+ <dd>Bitwise and. Valid for any type except Void.</dd>
</ins><span class="cx">
</span><span class="cx"> <dt>T BitOr(T, T)</dt>
</span><del>- <dd>Bitwise or. Valid for Int32 and Int64.</dd>
</del><ins>+ <dd>Bitwise or. Valid for any type except Void.</dd>
</ins><span class="cx">
</span><span class="cx"> <dt>T BitXor(T, T)</dt>
</span><del>- <dd>Bitwise xor. Valid for Int32 and Int64.</dd>
</del><ins>+ <dd>Bitwise xor. Valid for any type except Void.</dd>
</ins><span class="cx">
</span><span class="cx"> <dt>T Shl(T, Int32)</dt>
</span><span class="cx"> <dd>Shift left. Valid for Int32 and Int64. The shift amount is always Int32. Only the
</span></span></pre>
</div>
</div>
</body>
</html>