[webkit-changes] [93143] branches/safari-534.51-branch

Tue, 16 Aug 2011 12:42:14 -0700

Title: [93143] branches/safari-534.51-branch

Diff

Modified: branches/safari-534.51-branch/LayoutTests/ChangeLog (93142 => 93143)


--- branches/safari-534.51-branch/LayoutTests/ChangeLog	2011-08-16 19:40:10 UTC (rev 93142)
+++ branches/safari-534.51-branch/LayoutTests/ChangeLog	2011-08-16 19:42:07 UTC (rev 93143)
@@ -1,5 +1,37 @@
 2011-08-16  Lucas Forschler  <lforsch...@apple.com>
 
+    Merged 93070
+
+    2011-08-15  Gavin Barraclough  <barraclo...@apple.com>
+
+            https://bugs.webkit.org/show_bug.cgi?id=66263
+            DFG JIT does not always zero extend boolean result of DFG operations
+
+            Reviewed by Sam Weinig.
+
+            * fast/js/kde/script-tests/operators.js:
+            (nonSpeculativeNotInner):
+            (nonSpeculativeNot):
+            (nonSpeculativeLessInner):
+            (nonSpeculativeLess):
+            (nonSpeculativeLessEqInner):
+            (nonSpeculativeLessEq):
+            (nonSpeculativeGreaterInner):
+            (nonSpeculativeGreater):
+            (nonSpeculativeGreaterEqInner):
+            (nonSpeculativeGreaterEq):
+            (nonSpeculativeEqualInner):
+            (nonSpeculativeEqual):
+            (nonSpeculativeNotEqualInner):
+            (nonSpeculativeNotEqual):
+            (nonSpeculativeStrictEqualInner):
+            (nonSpeculativeStrictEqual):
+            (nonSpeculativeStrictNotEqualInner):
+            (nonSpeculativeStrictNotEqual):
+                - Add tests cases that will hit the non-spec path.
+
+2011-08-16  Lucas Forschler  <lforsch...@apple.com>
+
     Merged 93048
 
     2011-08-15  Gavin Barraclough  <barraclo...@apple.com>

Modified: branches/safari-534.51-branch/LayoutTests/fast/js/kde/script-tests/operators.js (93142 => 93143)


--- branches/safari-534.51-branch/LayoutTests/fast/js/kde/script-tests/operators.js	2011-08-16 19:40:10 UTC (rev 93142)
+++ branches/safari-534.51-branch/LayoutTests/fast/js/kde/script-tests/operators.js	2011-08-16 19:42:07 UTC (rev 93143)
@@ -1,3 +1,102 @@
+function nonSpeculativeNotInner(argument, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return !argument;
+}
+function nonSpeculativeNot(argument)
+{
+    return nonSpeculativeNotInner(argument, {}, {});
+}
+
+function nonSpeculativeLessInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a < b;
+}
+function nonSpeculativeLess(a, b)
+{
+    return nonSpeculativeLessInner(a, b, {}, {});
+}
+
+function nonSpeculativeLessEqInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a <= b;
+}
+function nonSpeculativeLessEq(a, b)
+{
+    return nonSpeculativeLessEqInner(a, b, {}, {});
+}
+
+function nonSpeculativeGreaterInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a > b;
+}
+function nonSpeculativeGreater(a, b)
+{
+    return nonSpeculativeGreaterInner(a, b, {}, {});
+}
+
+function nonSpeculativeGreaterEqInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a >= b;
+}
+function nonSpeculativeGreaterEq(a, b)
+{
+    return nonSpeculativeGreaterEqInner(a, b, {}, {});
+}
+
+function nonSpeculativeEqualInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a == b;
+}
+function nonSpeculativeEqual(a, b)
+{
+    return nonSpeculativeEqualInner(a, b, {}, {});
+}
+
+function nonSpeculativeNotEqualInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a != b;
+}
+function nonSpeculativeNotEqual(a, b)
+{
+    return nonSpeculativeNotEqualInner(a, b, {}, {});
+}
+
+function nonSpeculativeStrictEqualInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a === b;
+}
+function nonSpeculativeStrictEqual(a, b)
+{
+    return nonSpeculativeStrictEqualInner(a, b, {}, {});
+}
+
+function nonSpeculativeStrictNotEqualInner(a, b, o1, o2)
+{
+    // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
+    o1 + o2;
+    return a !== b;
+}
+function nonSpeculativeStrictNotEqual(a, b)
+{
+    return nonSpeculativeStrictNotEqualInner(a, b, {}, {});
+}
+
 // operator !
 shouldBeTrue("!undefined");
 shouldBeTrue("!null");
@@ -8,6 +107,15 @@
 shouldBeTrue("!!'a'");
 shouldBeTrue("!''");
 
+shouldBeTrue("nonSpeculativeNot(undefined)");
+shouldBeTrue("nonSpeculativeNot(null)");
+shouldBeTrue("nonSpeculativeNot(!true)");
+shouldBeTrue("nonSpeculativeNot(false)");
+shouldBeTrue("nonSpeculativeNot(!1)");
+shouldBeTrue("nonSpeculativeNot(0)");
+shouldBeTrue("nonSpeculativeNot(!'a')");
+shouldBeTrue("nonSpeculativeNot('')");
+
 // unary plus
 shouldBe("+9", "9");
 shouldBe("var i = 10; +i", "10");
@@ -148,18 +256,31 @@
 shouldBe("2==2", "true");
 shouldBe("1==2", "false");
 
+shouldBe("nonSpeculativeEqual(2,2)", "true");
+shouldBe("nonSpeculativeEqual(1,2)", "false");
+
 shouldBe("1<2", "true");
 shouldBe("1<=2", "true");
 shouldBe("2<1", "false");
 shouldBe("2<=1", "false");
 
+shouldBe("nonSpeculativeLess(1,2)", "true");
+shouldBe("nonSpeculativeLessEq(1,2)", "true");
+shouldBe("nonSpeculativeLess(2,1)", "false");
+shouldBe("nonSpeculativeLessEq(2,1)", "false");
+
 shouldBe("2>1", "true");
 shouldBe("2>=1", "true");
 shouldBe("1>=2", "false");
 shouldBe("1>2", "false");
 
-shouldBe("'abc' == 'abc'", "true");
-shouldBe("'abc' != 'xyz'", "true");
+shouldBe("nonSpeculativeGreater(2,1)", "true");
+shouldBe("nonSpeculativeGreaterEq(2,1)", "true");
+shouldBe("nonSpeculativeGreaterEq(1,2)", "false");
+shouldBe("nonSpeculativeGreater(1,2)", "false");
+
+shouldBeTrue("'abc' == 'abc'");
+shouldBeTrue("'abc' != 'xyz'");
 shouldBeTrue("true == true");
 shouldBeTrue("false == false");
 shouldBeTrue("true != false");
@@ -184,24 +305,68 @@
 shouldBeTrue("false == 0");
 shouldBeTrue("0 == false");
 
+shouldBeTrue("nonSpeculativeEqual('abc', 'abc')");
+shouldBeTrue("nonSpeculativeNotEqual('abc', 'xyz')");
+shouldBeTrue("nonSpeculativeEqual(true, true)");
+shouldBeTrue("nonSpeculativeEqual(false, false)");
+shouldBeTrue("nonSpeculativeNotEqual(true, false)");
+shouldBeTrue("nonSpeculativeNotEqual('a', null)");
+shouldBeTrue("nonSpeculativeNotEqual('a', undefined)");
+shouldBeTrue("nonSpeculativeEqual(null, null)");
+shouldBeTrue("nonSpeculativeEqual(null, undefined)");
+shouldBeTrue("nonSpeculativeEqual(undefined, undefined)");
+shouldBeTrue("nonSpeculativeNotEqual(NaN, NaN)");
+shouldBeTrue("nonSpeculativeNotEqual(true, undefined)");
+shouldBeTrue("nonSpeculativeNotEqual(true, null)");
+shouldBeTrue("nonSpeculativeNotEqual(false, undefined)");
+shouldBeTrue("nonSpeculativeNotEqual(false, null)");
+shouldBeTrue("nonSpeculativeEqual('0', 0)");
+shouldBeTrue("nonSpeculativeEqual(1, '1')");
+shouldBeTrue("nonSpeculativeNotEqual(NaN, NaN)");
+shouldBeTrue("nonSpeculativeNotEqual(NaN, 0)");
+shouldBeTrue("nonSpeculativeNotEqual(NaN, undefined)");
+shouldBeTrue("nonSpeculativeEqual(true, 1)");
+shouldBeTrue("nonSpeculativeNotEqual(true, 2)");
+shouldBeTrue("nonSpeculativeEqual(1, true)");
+shouldBeTrue("nonSpeculativeEqual(false, 0)");
+shouldBeTrue("nonSpeculativeEqual(0, false)");
+
 shouldBe("'abc' < 'abx'", "true");
 shouldBe("'abc' < 'abcd'", "true");
 shouldBe("'abc' < 'abc'", "false");
 shouldBe("'abcd' < 'abcd'", "false");
 shouldBe("'abx' < 'abc'", "false");
 
+shouldBe("nonSpeculativeLess('abc', 'abx')", "true");
+shouldBe("nonSpeculativeLess('abc', 'abcd')", "true");
+shouldBe("nonSpeculativeLess('abc', 'abc')", "false");
+shouldBe("nonSpeculativeLess('abcd', 'abcd')", "false");
+shouldBe("nonSpeculativeLess('abx', 'abc')", "false");
+
 shouldBe("'abc' <= 'abc'", "true");
 shouldBe("'abc' <= 'abx'", "true");
 shouldBe("'abx' <= 'abc'", "false");
 shouldBe("'abcd' <= 'abc'", "false");
 shouldBe("'abc' <= 'abcd'", "true");
 
+shouldBe("nonSpeculativeLessEq('abc', 'abc')", "true");
+shouldBe("nonSpeculativeLessEq('abc', 'abx')", "true");
+shouldBe("nonSpeculativeLessEq('abx', 'abc')", "false");
+shouldBe("nonSpeculativeLessEq('abcd', 'abc')", "false");
+shouldBe("nonSpeculativeLessEq('abc', 'abcd')", "true");
+
 shouldBe("'abc' > 'abx'", "false");
 shouldBe("'abc' > 'abc'", "false");
 shouldBe("'abcd' > 'abc'", "true");
 shouldBe("'abx' > 'abc'", "true");
 shouldBe("'abc' > 'abcd'", "false");
 
+shouldBe("nonSpeculativeGreater('abc', 'abx')", "false");
+shouldBe("nonSpeculativeGreater('abc', 'abc')", "false");
+shouldBe("nonSpeculativeGreater('abcd', 'abc')", "true");
+shouldBe("nonSpeculativeGreater('abx', 'abc')", "true");
+shouldBe("nonSpeculativeGreater('abc', 'abcd')", "false");
+
 shouldBe("'abc' >= 'abc'", "true");
 shouldBe("'abcd' >= 'abc'", "true");
 shouldBe("'abx' >= 'abc'", "true");
@@ -209,6 +374,13 @@
 shouldBe("'abc' >= 'abx'", "false");
 shouldBe("'abc' >= 'abcd'", "false");
 
+shouldBe("nonSpeculativeGreaterEq('abc', 'abc')", "true");
+shouldBe("nonSpeculativeGreaterEq('abcd', 'abc')", "true");
+shouldBe("nonSpeculativeGreaterEq('abx', 'abc')", "true");
+shouldBe("nonSpeculativeGreaterEq('abc', 'abx')", "false");
+shouldBe("nonSpeculativeGreaterEq('abc', 'abx')", "false");
+shouldBe("nonSpeculativeGreaterEq('abc', 'abcd')", "false");
+
 // mixed strings and numbers - results validated in NS+moz+IE5
 shouldBeFalse("'abc' <= 0"); // #35246
 shouldBeTrue("'' <= 0");
@@ -220,32 +392,68 @@
 shouldBeTrue("null <= null");
 shouldBeTrue("6 < '52'");
 shouldBeTrue("6 < '72'"); // #36087
-shouldBe("NaN < 0", "false");
-shouldBe("NaN <= 0", "false");
-shouldBe("NaN > 0", "false");
-shouldBe("NaN >= 0", "false");
+shouldBeFalse("NaN < 0");
+shouldBeFalse("NaN <= 0");
+shouldBeFalse("NaN > 0");
+shouldBeFalse("NaN >= 0");
 
+shouldBeFalse("nonSpeculativeLessEq('abc', 0)"); // #35246
+shouldBeTrue("nonSpeculativeLessEq('', 0)");
+shouldBeTrue("nonSpeculativeLessEq(' ', 0)");
+shouldBeTrue("nonSpeculativeLessEq(null, 0)");
+shouldBeFalse("nonSpeculativeLessEq(0, 'abc')");
+shouldBeTrue("nonSpeculativeLessEq(0, '')");
+shouldBeTrue("nonSpeculativeLessEq(0, null)");
+shouldBeTrue("nonSpeculativeLessEq(null, null)");
+shouldBeTrue("nonSpeculativeLess(6, '52')");
+shouldBeTrue("nonSpeculativeLess(6, '72')"); // #36087
+shouldBeFalse("nonSpeculativeLess(NaN, 0)");
+shouldBeFalse("nonSpeculativeLessEq(NaN, 0)");
+shouldBeFalse("nonSpeculativeGreater(NaN, 0)");
+shouldBeFalse("nonSpeculativeGreaterEq(NaN, 0)");
+
 // strict comparison ===
-shouldBe("0 === false", "false");
+shouldBeFalse("0 === false");
 //shouldBe("undefined === undefined", "true"); // aborts in IE5 (undefined is not defined ;)
-shouldBe("null === null", "true");
-shouldBe("NaN === NaN", "false");
-shouldBe("0.0 === 0", "true");
-shouldBe("'abc' === 'abc'", "true");
-shouldBe("'a' === 'x'", "false");
-shouldBe("1 === '1'", "false");
-shouldBe("'1' === 1", "false");
-shouldBe("true === true", "true");
-shouldBe("false === false", "true");
-shouldBe("true === false", "false");
-shouldBe("Math === Math", "true");
-shouldBe("Math === Boolean", "false");
-shouldBe("Infinity === Infinity", "true");
+shouldBeTrue("null === null");
+shouldBeFalse("NaN === NaN");
+shouldBeTrue("0.0 === 0");
+shouldBeTrue("'abc' === 'abc'");
+shouldBeFalse("'a' === 'x'");
+shouldBeFalse("1 === '1'");
+shouldBeFalse("'1' === 1");
+shouldBeTrue("true === true");
+shouldBeTrue("false === false");
+shouldBeFalse("true === false");
+shouldBeTrue("Math === Math");
+shouldBeFalse("Math === Boolean");
+shouldBeTrue("Infinity === Infinity");
 
+// strict comparison ===
+shouldBeFalse("nonSpeculativeStrictEqual(0, false)");
+//shouldBe("undefined === undefined", "true"); // aborts in IE5 (undefined is not defined ;)
+shouldBeTrue("nonSpeculativeStrictEqual(null, null)");
+shouldBeFalse("nonSpeculativeStrictEqual(NaN, NaN)");
+shouldBeTrue("nonSpeculativeStrictEqual(0.0, 0)");
+shouldBeTrue("nonSpeculativeStrictEqual('abc', 'abc')");
+shouldBeFalse("nonSpeculativeStrictEqual('a', 'x')");
+shouldBeFalse("nonSpeculativeStrictEqual(1, '1')");
+shouldBeFalse("nonSpeculativeStrictEqual('1', 1)");
+shouldBeTrue("nonSpeculativeStrictEqual(true, true)");
+shouldBeTrue("nonSpeculativeStrictEqual(false, false)");
+shouldBeFalse("nonSpeculativeStrictEqual(true, false)");
+shouldBeTrue("nonSpeculativeStrictEqual(Math, Math)");
+shouldBeFalse("nonSpeculativeStrictEqual(Math, Boolean)");
+shouldBeTrue("nonSpeculativeStrictEqual(Infinity, Infinity)");
+
 // !==
 shouldBe("0 !== 0", "false");
 shouldBe("0 !== 1", "true");
 
+// !==
+shouldBe("nonSpeculativeStrictNotEqual(0, 0)", "false");
+shouldBe("nonSpeculativeStrictNotEqual(0, 1)", "true");
+
 shouldBe("typeof undefined", "'undefined'");
 shouldBe("typeof null", "'object'");
 shouldBe("typeof true", "'boolean'");

Modified: branches/safari-534.51-branch/Source/_javascript_Core/ChangeLog (93142 => 93143)


--- branches/safari-534.51-branch/Source/_javascript_Core/ChangeLog	2011-08-16 19:40:10 UTC (rev 93142)
+++ branches/safari-534.51-branch/Source/_javascript_Core/ChangeLog	2011-08-16 19:42:07 UTC (rev 93143)
@@ -1,5 +1,20 @@
 2011-08-16  Lucas Forschler  <lforsch...@apple.com>
 
+    Merged 93070
+
+    2011-08-15  Gavin Barraclough  <barraclo...@apple.com>
+
+            https://bugs.webkit.org/show_bug.cgi?id=66263
+            DFG JIT does not always zero extend boolean result of DFG operations
+
+            Reviewed by Sam Weinig.
+
+            * dfg/DFGOperations.cpp:
+            * dfg/DFGOperations.h:
+                - Change bool return values to a 64-bit type.
+
+2011-08-16  Lucas Forschler  <lforsch...@apple.com>
+
     Merged 93048
 
     2011-08-15  Gavin Barraclough  <barraclo...@apple.com>

Modified: branches/safari-534.51-branch/Source/_javascript_Core/dfg/DFGOperations.cpp (93142 => 93143)


--- branches/safari-534.51-branch/Source/_javascript_Core/dfg/DFGOperations.cpp	2011-08-16 19:40:10 UTC (rev 93142)
+++ branches/safari-534.51-branch/Source/_javascript_Core/dfg/DFGOperations.cpp	2011-08-16 19:42:07 UTC (rev 93143)
@@ -397,32 +397,32 @@
         stubInfo.seen = true;
 }
 
-bool operationCompareLess(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareLess(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     return jsLess<true>(exec, JSValue::decode(encodedOp1), JSValue::decode(encodedOp2));
 }
 
-bool operationCompareLessEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareLessEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     return jsLessEq<true>(exec, JSValue::decode(encodedOp1), JSValue::decode(encodedOp2));
 }
 
-bool operationCompareGreater(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareGreater(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     return jsLess<false>(exec, JSValue::decode(encodedOp2), JSValue::decode(encodedOp1));
 }
 
-bool operationCompareGreaterEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareGreaterEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     return jsLessEq<false>(exec, JSValue::decode(encodedOp2), JSValue::decode(encodedOp1));
 }
 
-bool operationCompareEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     return JSValue::equalSlowCaseInline(exec, JSValue::decode(encodedOp1), JSValue::decode(encodedOp2));
 }
 
-bool operationCompareStrictEqCell(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareStrictEqCell(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     JSValue op1 = JSValue::decode(encodedOp1);
     JSValue op2 = JSValue::decode(encodedOp2);
@@ -433,7 +433,7 @@
     return JSValue::strictEqualSlowCaseInline(exec, op1, op2);
 }
 
-bool operationCompareStrictEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+RegisterSizedBoolean operationCompareStrictEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
 {
     return JSValue::strictEqual(exec, JSValue::decode(encodedOp1), JSValue::decode(encodedOp2));
 }
@@ -684,7 +684,7 @@
     return JSValue::decode(value).toInt32(exec);
 }
 
-bool dfgConvertJSValueToBoolean(ExecState* exec, EncodedJSValue encodedOp)
+RegisterSizedBoolean dfgConvertJSValueToBoolean(ExecState* exec, EncodedJSValue encodedOp)
 {
     return JSValue::decode(encodedOp).toBoolean(exec);
 }

Modified: branches/safari-534.51-branch/Source/_javascript_Core/dfg/DFGOperations.h (93142 => 93143)


--- branches/safari-534.51-branch/Source/_javascript_Core/dfg/DFGOperations.h	2011-08-16 19:40:10 UTC (rev 93142)
+++ branches/safari-534.51-branch/Source/_javascript_Core/dfg/DFGOperations.h	2011-08-16 19:42:07 UTC (rev 93143)
@@ -34,6 +34,8 @@
 
 enum PutKind { Direct, NotDirect };
 
+typedef intptr_t RegisterSizedBoolean;
+
 extern "C" {
 
 // These typedefs provide typechecking when generating calls out to helper routines;
@@ -44,8 +46,8 @@
 typedef EncodedJSValue (*J_DFGOperation_EJI)(ExecState*, EncodedJSValue, Identifier*);
 typedef EncodedJSValue (*J_DFGOperation_EP)(ExecState*, void*);
 typedef EncodedJSValue (*J_DFGOperation_EI)(ExecState*, Identifier*);
-typedef bool (*Z_DFGOperation_EJ)(ExecState*, EncodedJSValue);
-typedef bool (*Z_DFGOperation_EJJ)(ExecState*, EncodedJSValue, EncodedJSValue);
+typedef RegisterSizedBoolean (*Z_DFGOperation_EJ)(ExecState*, EncodedJSValue);
+typedef RegisterSizedBoolean (*Z_DFGOperation_EJJ)(ExecState*, EncodedJSValue, EncodedJSValue);
 typedef void (*V_DFGOperation_EJJJ)(ExecState*, EncodedJSValue, EncodedJSValue, EncodedJSValue);
 typedef void (*V_DFGOperation_EJJP)(ExecState*, EncodedJSValue, EncodedJSValue, void*);
 typedef void (*V_DFGOperation_EJJI)(ExecState*, EncodedJSValue, EncodedJSValue, Identifier*);
@@ -82,13 +84,13 @@
 void operationPutByIdNonStrictOptimize(ExecState*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, Identifier*);
 void operationPutByIdDirectStrictOptimize(ExecState*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, Identifier*);
 void operationPutByIdDirectNonStrictOptimize(ExecState*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, Identifier*);
-bool operationCompareLess(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
-bool operationCompareLessEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
-bool operationCompareGreater(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
-bool operationCompareGreaterEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
-bool operationCompareEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
-bool operationCompareStrictEqCell(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
-bool operationCompareStrictEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareLess(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareLessEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareGreater(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareGreaterEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareStrictEqCell(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
+RegisterSizedBoolean operationCompareStrictEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2);
 void* operationVirtualCall(ExecState*);
 void* operationLinkCall(ExecState*);
 void* operationVirtualConstruct(ExecState*);
@@ -111,7 +113,7 @@
 // These operations implement the implicitly called ToInt32, ToNumber, and ToBoolean conversions from ES5.
 double dfgConvertJSValueToNumber(ExecState*, EncodedJSValue);
 int32_t dfgConvertJSValueToInt32(ExecState*, EncodedJSValue);
-bool dfgConvertJSValueToBoolean(ExecState*, EncodedJSValue);
+RegisterSizedBoolean dfgConvertJSValueToBoolean(ExecState*, EncodedJSValue);
 
 } // extern "C"
 } } // namespace JSC::DFG

_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
http://lists.webkit.org/mailman/listinfo.cgi/webkit-changes

Reply via email to