Backed out changeset d62d5b78e234 (bug 1316803) for arm64 bustage a=backout
authorWes Kocher <wkocher@mozilla.com>
Tue, 29 Nov 2016 14:57:43 -0800
changeset 324750 754af8c55a9d7f6e786eb1258192fbdd8b364a23
parent 324749 2e6d1dafee00c988288f4b8e3023d4df7bf792fc
child 324751 9607364780c2ad20c0770b62064c66f6ffddbd82
push id24
push usermaklebus@msu.edu
push dateTue, 20 Dec 2016 03:11:33 +0000
reviewersbackout
bugs1316803
milestone53.0a1
backs outd62d5b78e234941e06b71de9de92788697e1619b
Backed out changeset d62d5b78e234 (bug 1316803) for arm64 bustage a=backout
js/src/jit-test/tests/wasm/integer.js
js/src/wasm/WasmBaselineCompile.cpp
--- a/js/src/jit-test/tests/wasm/integer.js
+++ b/js/src/jit-test/tests/wasm/integer.js
@@ -201,18 +201,16 @@ assertEq(testTrunc(13.37), 1);
     testBinary64('shr_s', "0xff00ff0000000", 28, 0xff00ff);
     testBinary64('shr_u', "0x8ffff00ff0000000", 56, 0x8f);
     testBinary64('rotl', 40, 2, 160);
     testBinary64('rotr', 40, 2, 10);
     testBinary64('rotr', "0x1234567812345678", 4, "0x8123456781234567");
     testBinary64('rotl', "0x1234567812345678", 4, "0x2345678123456781");
     testBinary64('rotl', "0x1234567812345678", 60, "0x8123456781234567");
     testBinary64('rotr', "0x1234567812345678", 60, "0x2345678123456781");
-    testBinary64('rotl', "0x0000000000001000", 127, "0x0000000000000800");
-    testBinary64('rotr', "0x0000000000001000", 127, "0x0000000000002000");
     testBinary64('rotr', 40, 0, 40);
     testBinary64('rotl', 40, 0, 40);
     testBinary64('and', 42, 0, 0);
     testBinary64('and', "0x0000000012345678", "0xffff0000ffff0000", "0x0000000012340000");
 
     testComparison64('eq', 40, 40, 1);
     testComparison64('ne', 40, 40, 0);
     testComparison64('lt_s', 40, 40, 0);
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -1687,25 +1687,16 @@ class BaseCompiler
         Stk& v = stk_.back();
         if (v.kind() != Stk::ConstI32)
             return false;
         c = v.i32val();
         stk_.popBack();
         return true;
     }
 
-    MOZ_MUST_USE bool popConstI64(int64_t& c) {
-        Stk& v = stk_.back();
-        if (v.kind() != Stk::ConstI64)
-            return false;
-        c = v.i64val();
-        stk_.popBack();
-        return true;
-    }
-
     // TODO / OPTIMIZE (Bug 1316818): At the moment we use ReturnReg
     // for JoinReg.  It is possible other choices would lead to better
     // register allocation, as ReturnReg is often first in the
     // register set and will be heavily wanted by the register
     // allocator that uses takeFirst().
     //
     // Obvious options:
     //  - pick a register at the back of the register set
@@ -3979,82 +3970,64 @@ BaseCompiler::emitAddI32()
         freeI32(r1);
         pushI32(r0);
     }
 }
 
 void
 BaseCompiler::emitAddI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.add64(Imm64(c), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64(&r0, &r1);
-        masm.add64(r1, r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    // TODO / OPTIMIZE: Ditto check for constant here (Bug 1316803)
+    RegI64 r0, r1;
+    pop2xI64(&r0, &r1);
+    masm.add64(r1, r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitAddF64()
 {
+    // TODO / OPTIMIZE: Ditto check for constant here (Bug 1316803)
     RegF64 r0, r1;
     pop2xF64(&r0, &r1);
     masm.addDouble(r1, r0);
     freeF64(r1);
     pushF64(r0);
 }
 
 void
 BaseCompiler::emitAddF32()
 {
+    // TODO / OPTIMIZE: Ditto check for constant here (Bug 1316803)
     RegF32 r0, r1;
     pop2xF32(&r0, &r1);
     masm.addFloat32(r1, r0);
     freeF32(r1);
     pushF32(r0);
 }
 
 void
 BaseCompiler::emitSubtractI32()
 {
-    int32_t c;
-    if (popConstI32(c)) {
-        RegI32 r = popI32();
-        masm.sub32(Imm32(c), r);
-        pushI32(r);
-    } else {
-        RegI32 r0, r1;
-        pop2xI32(&r0, &r1);
-        masm.sub32(r1, r0);
-        freeI32(r1);
-        pushI32(r0);
-    }
+    RegI32 r0, r1;
+    pop2xI32(&r0, &r1);
+    masm.sub32(r1, r0);
+    freeI32(r1);
+    pushI32(r0);
 }
 
 void
 BaseCompiler::emitSubtractI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.sub64(Imm64(c), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64(&r0, &r1);
-        masm.sub64(r1, r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    RegI64 r0, r1;
+    pop2xI64(&r0, &r1);
+    masm.sub64(r1, r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitSubtractF32()
 {
     RegF32 r0, r1;
     pop2xF32(&r0, &r1);
     masm.subFloat32(r1, r0);
@@ -4414,113 +4387,71 @@ BaseCompiler::emitCopysignF64()
     freeI64(x1);
     freeF64(r1);
     pushF64(r0);
 }
 
 void
 BaseCompiler::emitOrI32()
 {
-    int32_t c;
-    if (popConstI32(c)) {
-        RegI32 r = popI32();
-        masm.or32(Imm32(c), r);
-        pushI32(r);
-    } else {
-        RegI32 r0, r1;
-        pop2xI32(&r0, &r1);
-        masm.or32(r1, r0);
-        freeI32(r1);
-        pushI32(r0);
-    }
+    RegI32 r0, r1;
+    pop2xI32(&r0, &r1);
+    masm.or32(r1, r0);
+    freeI32(r1);
+    pushI32(r0);
 }
 
 void
 BaseCompiler::emitOrI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.or64(Imm64(c), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64(&r0, &r1);
-        masm.or64(r1, r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    RegI64 r0, r1;
+    pop2xI64(&r0, &r1);
+    masm.or64(r1, r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitAndI32()
 {
-    int32_t c;
-    if (popConstI32(c)) {
-        RegI32 r = popI32();
-        masm.and32(Imm32(c), r);
-        pushI32(r);
-    } else {
-        RegI32 r0, r1;
-        pop2xI32(&r0, &r1);
-        masm.and32(r1, r0);
-        freeI32(r1);
-        pushI32(r0);
-    }
+    RegI32 r0, r1;
+    pop2xI32(&r0, &r1);
+    masm.and32(r1, r0);
+    freeI32(r1);
+    pushI32(r0);
 }
 
 void
 BaseCompiler::emitAndI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.and64(Imm64(c), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64(&r0, &r1);
-        masm.and64(r1, r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    RegI64 r0, r1;
+    pop2xI64(&r0, &r1);
+    masm.and64(r1, r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitXorI32()
 {
-    int32_t c;
-    if (popConstI32(c)) {
-        RegI32 r = popI32();
-        masm.xor32(Imm32(c), r);
-        pushI32(r);
-    } else {
-        RegI32 r0, r1;
-        pop2xI32(&r0, &r1);
-        masm.xor32(r1, r0);
-        freeI32(r1);
-        pushI32(r0);
-    }
+    RegI32 r0, r1;
+    pop2xI32(&r0, &r1);
+    masm.xor32(r1, r0);
+    freeI32(r1);
+    pushI32(r0);
 }
 
 void
 BaseCompiler::emitXorI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.xor64(Imm64(c), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64(&r0, &r1);
-        masm.xor64(r1, r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    RegI64 r0, r1;
+    pop2xI64(&r0, &r1);
+    masm.xor64(r1, r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitShlI32()
 {
     int32_t c;
     if (popConstI32(c)) {
         RegI32 r = popI32();
@@ -4534,28 +4465,22 @@ BaseCompiler::emitShlI32()
         freeI32(r1);
         pushI32(r0);
     }
 }
 
 void
 BaseCompiler::emitShlI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.lshift64(Imm32(c & 63), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64ForShiftOrRotate(&r0, &r1);
-        masm.lshift64(lowPart(r1), r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI64 r0, r1;
+    pop2xI64ForShiftOrRotate(&r0, &r1);
+    masm.lshift64(lowPart(r1), r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitShrI32()
 {
     int32_t c;
     if (popConstI32(c)) {
         RegI32 r = popI32();
@@ -4569,28 +4494,22 @@ BaseCompiler::emitShrI32()
         freeI32(r1);
         pushI32(r0);
     }
 }
 
 void
 BaseCompiler::emitShrI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.rshift64Arithmetic(Imm32(c & 63), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64ForShiftOrRotate(&r0, &r1);
-        masm.rshift64Arithmetic(lowPart(r1), r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI64 r0, r1;
+    pop2xI64ForShiftOrRotate(&r0, &r1);
+    masm.rshift64Arithmetic(lowPart(r1), r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitShrU32()
 {
     int32_t c;
     if (popConstI32(c)) {
         RegI32 r = popI32();
@@ -4604,96 +4523,66 @@ BaseCompiler::emitShrU32()
         freeI32(r1);
         pushI32(r0);
     }
 }
 
 void
 BaseCompiler::emitShrU64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.rshift64(Imm32(c & 63), r);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64ForShiftOrRotate(&r0, &r1);
-        masm.rshift64(lowPart(r1), r0);
-        freeI64(r1);
-        pushI64(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI64 r0, r1;
+    pop2xI64ForShiftOrRotate(&r0, &r1);
+    masm.rshift64(lowPart(r1), r0);
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitRotrI32()
 {
-    int32_t c;
-    if (popConstI32(c)) {
-        RegI32 r = popI32();
-        masm.rotateRight(Imm32(c & 31), r, r);
-        pushI32(r);
-    } else {
-        RegI32 r0, r1;
-        pop2xI32ForShiftOrRotate(&r0, &r1);
-        masm.rotateRight(r1, r0, r0);
-        freeI32(r1);
-        pushI32(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI32 r0, r1;
+    pop2xI32ForShiftOrRotate(&r0, &r1);
+    masm.rotateRight(r1, r0, r0);
+    freeI32(r1);
+    pushI32(r0);
 }
 
 void
 BaseCompiler::emitRotrI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.rotateRight64(Imm32(c & 63), r, r, InvalidReg);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64ForShiftOrRotate(&r0, &r1);
-        masm.rotateRight64(lowPart(r1), r0, r0, maybeHighPart(r1));
-        freeI64(r1);
-        pushI64(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI64 r0, r1;
+    pop2xI64ForShiftOrRotate(&r0, &r1);
+    masm.rotateRight64(lowPart(r1), r0, r0, maybeHighPart(r1));
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitRotlI32()
 {
-    int32_t c;
-    if (popConstI32(c)) {
-        RegI32 r = popI32();
-        masm.rotateLeft(Imm32(c & 31), r, r);
-        pushI32(r);
-    } else {
-        RegI32 r0, r1;
-        pop2xI32ForShiftOrRotate(&r0, &r1);
-        masm.rotateLeft(r1, r0, r0);
-        freeI32(r1);
-        pushI32(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI32 r0, r1;
+    pop2xI32ForShiftOrRotate(&r0, &r1);
+    masm.rotateLeft(r1, r0, r0);
+    freeI32(r1);
+    pushI32(r0);
 }
 
 void
 BaseCompiler::emitRotlI64()
 {
-    int64_t c;
-    if (popConstI64(c)) {
-        RegI64 r = popI64();
-        masm.rotateLeft64(Imm32(c & 63), r, r, InvalidReg);
-        pushI64(r);
-    } else {
-        RegI64 r0, r1;
-        pop2xI64ForShiftOrRotate(&r0, &r1);
-        masm.rotateLeft64(lowPart(r1), r0, r0, maybeHighPart(r1));
-        freeI64(r1);
-        pushI64(r0);
-    }
+    // TODO / OPTIMIZE: Constant rhs (Bug 1316803)
+    RegI64 r0, r1;
+    pop2xI64ForShiftOrRotate(&r0, &r1);
+    masm.rotateLeft64(lowPart(r1), r0, r0, maybeHighPart(r1));
+    freeI64(r1);
+    pushI64(r0);
 }
 
 void
 BaseCompiler::emitEqzI32()
 {
     if (sniffConditionalControlEqz(ValType::I32))
         return;