Backed out 6 changesets (bug 1090957) for build failures. r=backout on a CLOSED TREE
authorSebastian Hengst <archaeopteryx@coole-files.de>
Sat, 07 Nov 2015 14:55:04 +0100
changeset 271675 4aa558b944b502ae40ff6ee5ad0c7aad8c67f817
parent 271674 0b64cc3528d9bc7e7e18e7325621fe7f0e520620
child 271676 92601fd43a7c11a8141c48dc54943b7141817e97
push id29650
push usercbook@mozilla.com
push dateMon, 09 Nov 2015 13:56:12 +0000
treeherdermozilla-central@e1ef2be156de [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1090957
milestone45.0a1
backs out0b64cc3528d9bc7e7e18e7325621fe7f0e520620
f45ccb4ab2cfbef4b11a675cab085ca6df696e99
a3b1e29fa2dbc35752abc50af80005e54eb6d44a
c8324f9509f5ee99af6ffc8a5e08b3892ef96b4c
92f45c98b9309db9f819bc1af2a10a948a0f9420
da2deb62849ed39ee79bb25862c7a50968221828
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 6 changesets (bug 1090957) for build failures. r=backout on a CLOSED TREE Errors e.g. /home/worker/workspace/gecko/js/src/jit/arm/Lowering-arm.cpp:574:86: error: call of overloaded 'LAtomicExchangeTypedArrayElement(const js::jit::LUse&, const js::jit::LAllocation&, const js::jit::LAllocation&, js::jit::LDefinition&)' is ambiguous Backed out changeset 0b64cc3528d9 (bug 1090957) Backed out changeset f45ccb4ab2cf (bug 1090957) Backed out changeset a3b1e29fa2db (bug 1090957) Backed out changeset c8324f9509f5 (bug 1090957) Backed out changeset 92f45c98b930 (bug 1090957) Backed out changeset da2deb62849e (bug 1090957)
js/src/jit/mips-shared/CodeGenerator-mips-shared.cpp
js/src/jit/mips-shared/CodeGenerator-mips-shared.h
js/src/jit/mips-shared/Lowering-mips-shared.cpp
js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
js/src/jit/mips-shared/MacroAssembler-mips-shared.h
js/src/jit/mips32/MacroAssembler-mips32.cpp
js/src/jit/mips32/MacroAssembler-mips32.h
js/src/jit/mips64/MacroAssembler-mips64.cpp
js/src/jit/mips64/MacroAssembler-mips64.h
js/src/jit/shared/LIR-shared.h
--- a/js/src/jit/mips-shared/CodeGenerator-mips-shared.cpp
+++ b/js/src/jit/mips-shared/CodeGenerator-mips-shared.cpp
@@ -1755,142 +1755,23 @@ CodeGeneratorMIPSShared::visitAsmJSStore
 
     memoryBarrier(mir->barrierAfter());
     masm.append(AsmJSHeapAccess(bo.getOffset()));
 }
 
 void
 CodeGeneratorMIPSShared::visitAsmJSCompareExchangeHeap(LAsmJSCompareExchangeHeap* ins)
 {
-    MAsmJSCompareExchangeHeap* mir = ins->mir();
-    Scalar::Type vt = mir->accessType();
-    const LAllocation* ptr = ins->ptr();
-    Register ptrReg = ToRegister(ptr);
-    BaseIndex srcAddr(HeapReg, ptrReg, TimesOne);
-    MOZ_ASSERT(ins->addrTemp()->isBogusTemp());
-
-    Register oldval = ToRegister(ins->oldValue());
-    Register newval = ToRegister(ins->newValue());
-    Register valueTemp = ToRegister(ins->valueTemp());
-    Register offsetTemp = ToRegister(ins->offsetTemp());
-    Register maskTemp = ToRegister(ins->maskTemp());
-
-    uint32_t maybeCmpOffset = 0;
-    if (mir->needsBoundsCheck()) {
-        BufferOffset bo = masm.ma_BoundsCheck(ScratchRegister);
-        maybeCmpOffset = bo.getOffset();
-        masm.ma_b(ptrReg, ScratchRegister, gen->outOfBoundsLabel(), Assembler::AboveOrEqual);
-    }
-    masm.compareExchangeToTypedIntArray(vt == Scalar::Uint32 ? Scalar::Int32 : vt,
-                                        srcAddr, oldval, newval, InvalidReg,
-                                        valueTemp, offsetTemp, maskTemp,
-                                        ToAnyRegister(ins->output()));
-    if (mir->needsBoundsCheck())
-        masm.append(AsmJSHeapAccess(maybeCmpOffset));
-}
-
-void
-CodeGeneratorMIPSShared::visitAsmJSAtomicExchangeHeap(LAsmJSAtomicExchangeHeap* ins)
-{
-    MAsmJSAtomicExchangeHeap* mir = ins->mir();
-    Scalar::Type vt = mir->accessType();
-    Register ptrReg = ToRegister(ins->ptr());
-    Register value = ToRegister(ins->value());
-    BaseIndex srcAddr(HeapReg, ptrReg, TimesOne);
-    MOZ_ASSERT(ins->addrTemp()->isBogusTemp());
-
-    Register valueTemp = ToRegister(ins->valueTemp());
-    Register offsetTemp = ToRegister(ins->offsetTemp());
-    Register maskTemp = ToRegister(ins->maskTemp());
-
-    uint32_t maybeCmpOffset = 0;
-    if (mir->needsBoundsCheck()) {
-        BufferOffset bo = masm.ma_BoundsCheck(ScratchRegister);
-        maybeCmpOffset = bo.getOffset();
-        masm.ma_b(ptrReg, ScratchRegister, gen->outOfBoundsLabel(), Assembler::AboveOrEqual);
-    }
-    masm.atomicExchangeToTypedIntArray(vt == Scalar::Uint32 ? Scalar::Int32 : vt,
-                                       srcAddr, value, InvalidReg, valueTemp,
-                                       offsetTemp, maskTemp, ToAnyRegister(ins->output()));
-    if (mir->needsBoundsCheck())
-        masm.append(AsmJSHeapAccess(maybeCmpOffset));
+    MOZ_CRASH("NYI");
 }
 
 void
 CodeGeneratorMIPSShared::visitAsmJSAtomicBinopHeap(LAsmJSAtomicBinopHeap* ins)
 {
-    MOZ_ASSERT(ins->mir()->hasUses());
-    MOZ_ASSERT(ins->addrTemp()->isBogusTemp());
-
-    MAsmJSAtomicBinopHeap* mir = ins->mir();
-    Scalar::Type vt = mir->accessType();
-    Register ptrReg = ToRegister(ins->ptr());
-    Register flagTemp = ToRegister(ins->flagTemp());
-    Register valueTemp = ToRegister(ins->valueTemp());
-    Register offsetTemp = ToRegister(ins->offsetTemp());
-    Register maskTemp = ToRegister(ins->maskTemp());
-    const LAllocation* value = ins->value();
-    AtomicOp op = mir->operation();
-
-    BaseIndex srcAddr(HeapReg, ptrReg, TimesOne);
-
-    uint32_t maybeCmpOffset = 0;
-    if (mir->needsBoundsCheck()) {
-        BufferOffset bo = masm.ma_BoundsCheck(ScratchRegister);
-        maybeCmpOffset = bo.getOffset();
-        masm.ma_b(ptrReg, ScratchRegister, gen->outOfBoundsLabel(), Assembler::AboveOrEqual);
-    }
-    if (value->isConstant())
-        atomicBinopToTypedIntArray(op, vt == Scalar::Uint32 ? Scalar::Int32 : vt,
-                                   Imm32(ToInt32(value)), srcAddr, flagTemp, InvalidReg,
-                                   valueTemp, offsetTemp, maskTemp,
-                                   ToAnyRegister(ins->output()));
-    else
-        atomicBinopToTypedIntArray(op, vt == Scalar::Uint32 ? Scalar::Int32 : vt,
-                                   ToRegister(value), srcAddr, flagTemp, InvalidReg,
-                                   valueTemp, offsetTemp, maskTemp,
-                                   ToAnyRegister(ins->output()));
-    if (mir->needsBoundsCheck())
-        masm.append(AsmJSHeapAccess(maybeCmpOffset));
-}
-
-void
-CodeGeneratorMIPSShared::visitAsmJSAtomicBinopHeapForEffect(LAsmJSAtomicBinopHeapForEffect* ins)
-{
-    MOZ_ASSERT(!ins->mir()->hasUses());
-    MOZ_ASSERT(ins->addrTemp()->isBogusTemp());
-
-    MAsmJSAtomicBinopHeap* mir = ins->mir();
-    Scalar::Type vt = mir->accessType();
-    Register ptrReg = ToRegister(ins->ptr());
-    Register flagTemp = ToRegister(ins->flagTemp());
-    Register valueTemp = ToRegister(ins->valueTemp());
-    Register offsetTemp = ToRegister(ins->offsetTemp());
-    Register maskTemp = ToRegister(ins->maskTemp());
-    const LAllocation* value = ins->value();
-    AtomicOp op = mir->operation();
-
-    BaseIndex srcAddr(HeapReg, ptrReg, TimesOne);
-
-    uint32_t maybeCmpOffset = 0;
-    if (mir->needsBoundsCheck()) {
-        BufferOffset bo = masm.ma_BoundsCheck(ScratchRegister);
-        maybeCmpOffset = bo.getOffset();
-        masm.ma_b(ptrReg, ScratchRegister, gen->outOfBoundsLabel(), Assembler::AboveOrEqual);
-    }
-
-    if (value->isConstant())
-        atomicBinopToTypedIntArray(op, vt, Imm32(ToInt32(value)), srcAddr, flagTemp,
-                                   valueTemp, offsetTemp, maskTemp);
-    else
-        atomicBinopToTypedIntArray(op, vt, ToRegister(value), srcAddr, flagTemp,
-                                   valueTemp, offsetTemp, maskTemp);
-
-    if (mir->needsBoundsCheck())
-        masm.append(AsmJSHeapAccess(maybeCmpOffset));
+    MOZ_CRASH("NYI");
 }
 
 void
 CodeGeneratorMIPSShared::visitAsmJSPassStackArg(LAsmJSPassStackArg* ins)
 {
     const MAsmJSPassStackArg* mir = ins->mir();
     if (ins->arg()->isConstant()) {
         masm.storePtr(ImmWord(ToInt32(ins->arg())), Address(StackPointer, mir->spOffset()));
@@ -2025,420 +1906,8 @@ CodeGeneratorMIPSShared::visitNegD(LNegD
 void
 CodeGeneratorMIPSShared::visitNegF(LNegF* ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     FloatRegister output = ToFloatRegister(ins->output());
 
     masm.as_negs(output, input);
 }
-
-template<typename S, typename T>
-void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const S& value, const T& mem, Register flagTemp,
-                                                    Register outTemp, Register valueTemp,
-                                                    Register offsetTemp, Register maskTemp,
-                                                    AnyRegister output)
-{
-    MOZ_ASSERT(flagTemp != InvalidReg);
-    MOZ_ASSERT_IF(arrayType == Scalar::Uint32, outTemp != InvalidReg);
-
-    // Uint8Clamped is explicitly not supported here
-    switch (arrayType) {
-      case Scalar::Int8:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicFetchAdd8SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicFetchSub8SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicFetchAnd8SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicFetchOr8SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicFetchXor8SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Uint8:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicFetchAdd8ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicFetchSub8ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicFetchAnd8ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicFetchOr8ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicFetchXor8ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Int16:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicFetchAdd16SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicFetchSub16SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicFetchAnd16SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicFetchOr16SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicFetchXor16SignExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Uint16:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicFetchAdd16ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicFetchSub16ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicFetchAnd16ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicFetchOr16ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicFetchXor16ZeroExtend(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Int32:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicFetchAdd32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicFetchSub32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicFetchAnd32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicFetchOr32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicFetchXor32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output.gpr());
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Uint32:
-        // At the moment, the code in MCallOptimize.cpp requires the output
-        // type to be double for uint32 arrays.  See bug 1077305.
-        MOZ_ASSERT(output.isFloat());
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicFetchAdd32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, outTemp);
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicFetchSub32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, outTemp);
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicFetchAnd32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, outTemp);
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicFetchOr32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, outTemp);
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicFetchXor32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, outTemp);
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        masm.convertUInt32ToDouble(outTemp, output.fpu());
-        break;
-      default:
-        MOZ_CRASH("Invalid typed array type");
-    }
-}
-
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Imm32& value, const Address& mem,
-                                                    Register flagTemp, Register outTemp,
-                                                    Register valueTemp, Register offsetTemp,
-                                                    Register maskTemp, AnyRegister output);
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Imm32& value, const BaseIndex& mem,
-                                                    Register flagTemp, Register outTemp,
-                                                    Register valueTemp, Register offsetTemp,
-                                                    Register maskTemp, AnyRegister output);
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Register& value, const Address& mem,
-                                                    Register flagTemp, Register outTemp,
-                                                    Register valueTemp, Register offsetTemp,
-                                                    Register maskTemp, AnyRegister output);
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Register& value, const BaseIndex& mem,
-                                                    Register flagTemp, Register outTemp,
-                                                    Register valueTemp, Register offsetTemp,
-                                                    Register maskTemp, AnyRegister output);
-
-// Binary operation for effect, result discarded.
-template<typename S, typename T>
-void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType, const S& value,
-                                                    const T& mem, Register flagTemp, Register valueTemp,
-                                                    Register offsetTemp, Register maskTemp)
-{
-    MOZ_ASSERT(flagTemp != InvalidReg);
-
-    // Uint8Clamped is explicitly not supported here
-    switch (arrayType) {
-      case Scalar::Int8:
-      case Scalar::Uint8:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicAdd8(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicSub8(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicAnd8(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicOr8(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicXor8(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Int16:
-      case Scalar::Uint16:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicAdd16(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicSub16(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicAnd16(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicOr16(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicXor16(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      case Scalar::Int32:
-      case Scalar::Uint32:
-        switch (op) {
-          case AtomicFetchAddOp:
-            masm.atomicAdd32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchSubOp:
-            masm.atomicSub32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchAndOp:
-            masm.atomicAnd32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchOrOp:
-            masm.atomicOr32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          case AtomicFetchXorOp:
-            masm.atomicXor32(value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
-            break;
-          default:
-            MOZ_CRASH("Invalid typed array atomic operation");
-        }
-        break;
-      default:
-        MOZ_CRASH("Invalid typed array type");
-    }
-}
-
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Imm32& value, const Address& mem,
-                                                    Register flagTemp, Register valueTemp,
-                                                    Register offsetTemp, Register maskTemp);
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Imm32& value, const BaseIndex& mem,
-                                                    Register flagTemp, Register valueTemp,
-                                                    Register offsetTemp, Register maskTemp);
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Register& value, const Address& mem,
-                                                    Register flagTemp, Register valueTemp,
-                                                    Register offsetTemp, Register maskTemp);
-template void
-CodeGeneratorMIPSShared::atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType,
-                                                    const Register& value, const BaseIndex& mem,
-                                                    Register flagTemp, Register valueTemp,
-                                                    Register offsetTemp, Register maskTemp);
-
-
-template <typename T>
-static inline void
-AtomicBinopToTypedArray(CodeGeneratorMIPSShared* cg, AtomicOp op,
-                        Scalar::Type arrayType, const LAllocation* value, const T& mem,
-                        Register flagTemp, Register outTemp, Register valueTemp,
-                        Register offsetTemp, Register maskTemp, AnyRegister output)
-{
-    if (value->isConstant())
-        cg->atomicBinopToTypedIntArray(op, arrayType, Imm32(ToInt32(value)), mem, flagTemp, outTemp,
-                                       valueTemp, offsetTemp, maskTemp, output);
-    else
-        cg->atomicBinopToTypedIntArray(op, arrayType, ToRegister(value), mem, flagTemp, outTemp,
-                                       valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-CodeGeneratorMIPSShared::visitAtomicTypedArrayElementBinop(LAtomicTypedArrayElementBinop* lir)
-{
-    MOZ_ASSERT(lir->mir()->hasUses());
-
-    AnyRegister output = ToAnyRegister(lir->output());
-    Register elements = ToRegister(lir->elements());
-    Register flagTemp = ToRegister(lir->temp1());
-    Register outTemp = lir->temp2()->isBogusTemp() ? InvalidReg : ToRegister(lir->temp2());
-    Register valueTemp = ToRegister(lir->valueTemp());
-    Register offsetTemp = ToRegister(lir->offsetTemp());
-    Register maskTemp = ToRegister(lir->maskTemp());
-    const LAllocation* value = lir->value();
-
-    Scalar::Type arrayType = lir->mir()->arrayType();
-    int width = Scalar::byteSize(arrayType);
-
-    if (lir->index()->isConstant()) {
-        Address mem(elements, ToInt32(lir->index()) * width);
-        AtomicBinopToTypedArray(this, lir->mir()->operation(), arrayType, value, mem, flagTemp, outTemp,
-                                valueTemp, offsetTemp, maskTemp, output);
-    } else {
-        BaseIndex mem(elements, ToRegister(lir->index()), ScaleFromElemWidth(width));
-        AtomicBinopToTypedArray(this, lir->mir()->operation(), arrayType, value, mem, flagTemp, outTemp,
-                                valueTemp, offsetTemp, maskTemp, output);
-    }
-}
-
-template <typename T>
-static inline void
-AtomicBinopToTypedArray(CodeGeneratorMIPSShared* cg, AtomicOp op, Scalar::Type arrayType,
-                        const LAllocation* value, const T& mem, Register flagTemp,
-                        Register valueTemp, Register offsetTemp, Register maskTemp)
-{
-    if (value->isConstant())
-        cg->atomicBinopToTypedIntArray(op, arrayType, Imm32(ToInt32(value)), mem,
-                                       flagTemp, valueTemp, offsetTemp, maskTemp);
-    else
-        cg->atomicBinopToTypedIntArray(op, arrayType, ToRegister(value), mem,
-                                       flagTemp, valueTemp, offsetTemp, maskTemp);
-}
-
-void
-CodeGeneratorMIPSShared::visitAtomicTypedArrayElementBinopForEffect(LAtomicTypedArrayElementBinopForEffect* lir)
-{
-    MOZ_ASSERT(!lir->mir()->hasUses());
-
-    Register elements = ToRegister(lir->elements());
-    Register flagTemp = ToRegister(lir->flagTemp());
-    Register valueTemp = ToRegister(lir->valueTemp());
-    Register offsetTemp = ToRegister(lir->offsetTemp());
-    Register maskTemp = ToRegister(lir->maskTemp());
-    const LAllocation* value = lir->value();
-    Scalar::Type arrayType = lir->mir()->arrayType();
-    int width = Scalar::byteSize(arrayType);
-
-    if (lir->index()->isConstant()) {
-        Address mem(elements, ToInt32(lir->index()) * width);
-        AtomicBinopToTypedArray(this, lir->mir()->operation(), arrayType, value, mem,
-                                flagTemp, valueTemp, offsetTemp, maskTemp);
-    } else {
-        BaseIndex mem(elements, ToRegister(lir->index()), ScaleFromElemWidth(width));
-        AtomicBinopToTypedArray(this, lir->mir()->operation(), arrayType, value, mem,
-                                flagTemp, valueTemp, offsetTemp, maskTemp);
-    }
-}
-
-void
-CodeGeneratorMIPSShared::visitCompareExchangeTypedArrayElement(LCompareExchangeTypedArrayElement* lir)
-{
-    Register elements = ToRegister(lir->elements());
-    AnyRegister output = ToAnyRegister(lir->output());
-    Register temp = lir->temp()->isBogusTemp() ? InvalidReg : ToRegister(lir->temp());
-
-    Register oldval = ToRegister(lir->oldval());
-    Register newval = ToRegister(lir->newval());
-    Register valueTemp = ToRegister(lir->valueTemp());
-    Register offsetTemp = ToRegister(lir->offsetTemp());
-    Register maskTemp = ToRegister(lir->maskTemp());
-
-    Scalar::Type arrayType = lir->mir()->arrayType();
-    int width = Scalar::byteSize(arrayType);
-
-    if (lir->index()->isConstant()) {
-        Address dest(elements, ToInt32(lir->index()) * width);
-        masm.compareExchangeToTypedIntArray(arrayType, dest, oldval, newval, temp,
-                                            valueTemp, offsetTemp, maskTemp, output);
-    } else {
-        BaseIndex dest(elements, ToRegister(lir->index()), ScaleFromElemWidth(width));
-        masm.compareExchangeToTypedIntArray(arrayType, dest, oldval, newval, temp,
-                                            valueTemp, offsetTemp, maskTemp, output);
-    }
-}
-
-void
-CodeGeneratorMIPSShared::visitAtomicExchangeTypedArrayElement(LAtomicExchangeTypedArrayElement* lir)
-{
-    Register elements = ToRegister(lir->elements());
-    AnyRegister output = ToAnyRegister(lir->output());
-    Register temp = lir->temp()->isBogusTemp() ? InvalidReg : ToRegister(lir->temp());
-
-    Register value = ToRegister(lir->value());
-    Register valueTemp = ToRegister(lir->valueTemp());
-    Register offsetTemp = ToRegister(lir->offsetTemp());
-    Register maskTemp = ToRegister(lir->maskTemp());
-
-    Scalar::Type arrayType = lir->mir()->arrayType();
-    int width = Scalar::byteSize(arrayType);
-
-    if (lir->index()->isConstant()) {
-        Address dest(elements, ToInt32(lir->index()) * width);
-        masm.atomicExchangeToTypedIntArray(arrayType, dest, value, temp,
-                                           valueTemp, offsetTemp, maskTemp, output);
-    } else {
-        BaseIndex dest(elements, ToRegister(lir->index()), ScaleFromElemWidth(width));
-        masm.atomicExchangeToTypedIntArray(arrayType, dest, value, temp,
-                                           valueTemp, offsetTemp, maskTemp, output);
-    }
-}
--- a/js/src/jit/mips-shared/CodeGenerator-mips-shared.h
+++ b/js/src/jit/mips-shared/CodeGenerator-mips-shared.h
@@ -195,47 +195,28 @@ class CodeGeneratorMIPSShared : public C
     void visitNegD(LNegD* lir);
     void visitNegF(LNegF* lir);
     void visitLoadTypedArrayElementStatic(LLoadTypedArrayElementStatic* ins);
     void visitStoreTypedArrayElementStatic(LStoreTypedArrayElementStatic* ins);
     void visitAsmJSCall(LAsmJSCall* ins);
     void visitAsmJSLoadHeap(LAsmJSLoadHeap* ins);
     void visitAsmJSStoreHeap(LAsmJSStoreHeap* ins);
     void visitAsmJSCompareExchangeHeap(LAsmJSCompareExchangeHeap* ins);
-    void visitAsmJSAtomicExchangeHeap(LAsmJSAtomicExchangeHeap* ins);
     void visitAsmJSAtomicBinopHeap(LAsmJSAtomicBinopHeap* ins);
-    void visitAsmJSAtomicBinopHeapForEffect(LAsmJSAtomicBinopHeapForEffect* ins);
     void visitAsmJSLoadGlobalVar(LAsmJSLoadGlobalVar* ins);
     void visitAsmJSStoreGlobalVar(LAsmJSStoreGlobalVar* ins);
     void visitAsmJSLoadFuncPtr(LAsmJSLoadFuncPtr* ins);
     void visitAsmJSLoadFFIFunc(LAsmJSLoadFFIFunc* ins);
 
     void visitAsmJSPassStackArg(LAsmJSPassStackArg* ins);
 
     void visitMemoryBarrier(LMemoryBarrier* ins);
-    void visitAtomicTypedArrayElementBinop(LAtomicTypedArrayElementBinop* lir);
-    void visitAtomicTypedArrayElementBinopForEffect(LAtomicTypedArrayElementBinopForEffect* lir);
-    void visitCompareExchangeTypedArrayElement(LCompareExchangeTypedArrayElement* lir);
-    void visitAtomicExchangeTypedArrayElement(LAtomicExchangeTypedArrayElement* lir);
 
     void generateInvalidateEpilogue();
 
-    // Generating a result.
-    template<typename S, typename T>
-    void atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType, const S& value,
-                                    const T& mem, Register flagTemp, Register outTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp,
-                                    AnyRegister output);
-
-    // Generating no result.
-    template<typename S, typename T>
-    void atomicBinopToTypedIntArray(AtomicOp op, Scalar::Type arrayType, const S& value,
-                                    const T& mem, Register flagTemp, Register valueTemp,
-                                    Register offsetTemp, Register maskTemp);
-
   protected:
     void visitEffectiveAddress(LEffectiveAddress* ins);
     void visitUDivOrMod(LUDivOrMod* ins);
 
   public:
     // Unimplemented SIMD instructions
     void visitSimdSplatX4(LSimdSplatX4* lir) { MOZ_CRASH("NYI"); }
     void visitInt32x4(LInt32x4* ins) { MOZ_CRASH("NYI"); }
--- a/js/src/jit/mips-shared/Lowering-mips-shared.cpp
+++ b/js/src/jit/mips-shared/Lowering-mips-shared.cpp
@@ -374,176 +374,40 @@ void
 LIRGeneratorMIPSShared::visitSimdValueX4(MSimdValueX4* ins)
 {
     MOZ_CRASH("NYI");
 }
 
 void
 LIRGeneratorMIPSShared::visitCompareExchangeTypedArrayElement(MCompareExchangeTypedArrayElement* ins)
 {
-    MOZ_ASSERT(ins->arrayType() != Scalar::Float32);
-    MOZ_ASSERT(ins->arrayType() != Scalar::Float64);
-
-    MOZ_ASSERT(ins->elements()->type() == MIRType_Elements);
-    MOZ_ASSERT(ins->index()->type() == MIRType_Int32);
-
-    const LUse elements = useRegister(ins->elements());
-    const LAllocation index = useRegisterOrConstant(ins->index());
-
-    // If the target is a floating register then we need a temp at the
-    // CodeGenerator level for creating the result.
-
-    const LAllocation newval = useRegister(ins->newval());
-    const LAllocation oldval = useRegister(ins->oldval());
-    LDefinition uint32Temp = LDefinition::BogusTemp();
-    if (ins->arrayType() == Scalar::Uint32 && IsFloatingPointType(ins->type()))
-        uint32Temp = temp();
-
-    LCompareExchangeTypedArrayElement* lir =
-        new(alloc()) LCompareExchangeTypedArrayElement(elements, index, oldval, newval, uint32Temp,
-                                                       /* valueTemp= */ temp(), /* offsetTemp= */ temp(),
-                                                       /* maskTemp= */ temp());
-
-    define(lir, ins);
+    MOZ_CRASH("NYI");
 }
 
 void
 LIRGeneratorMIPSShared::visitAtomicExchangeTypedArrayElement(MAtomicExchangeTypedArrayElement* ins)
 {
-    MOZ_ASSERT(ins->arrayType() <= Scalar::Uint32);
-
-    MOZ_ASSERT(ins->elements()->type() == MIRType_Elements);
-    MOZ_ASSERT(ins->index()->type() == MIRType_Int32);
-
-    const LUse elements = useRegister(ins->elements());
-    const LAllocation index = useRegisterOrConstant(ins->index());
-
-    // If the target is a floating register then we need a temp at the
-    // CodeGenerator level for creating the result.
-
-    const LAllocation value = useRegister(ins->value());
-    LDefinition uint32Temp = LDefinition::BogusTemp();
-    if (ins->arrayType() == Scalar::Uint32) {
-        MOZ_ASSERT(ins->type() == MIRType_Double);
-        uint32Temp = temp();
-    }
-
-    LAtomicExchangeTypedArrayElement* lir =
-        new(alloc()) LAtomicExchangeTypedArrayElement(elements, index, value, uint32Temp,
-                                                      /* valueTemp= */ temp(), /* offsetTemp= */ temp(),
-                                                      /* maskTemp= */ temp());
-
-    define(lir, ins);
+    MOZ_CRASH("NYI");
 }
 
 void
 LIRGeneratorMIPSShared::visitAsmJSCompareExchangeHeap(MAsmJSCompareExchangeHeap* ins)
 {
-    MOZ_ASSERT(ins->accessType() < Scalar::Float32);
-
-    MDefinition* ptr = ins->ptr();
-    MOZ_ASSERT(ptr->type() == MIRType_Int32);
-
-    LAsmJSCompareExchangeHeap* lir =
-        new(alloc()) LAsmJSCompareExchangeHeap(useRegister(ptr),
-                                               useRegister(ins->oldValue()),
-                                               useRegister(ins->newValue()),
-                                               /* valueTemp= */ temp(),
-                                               /* offsetTemp= */ temp(),
-                                               /* maskTemp= */ temp());
-
-    define(lir, ins);
+    MOZ_CRASH("NYI");
 }
 
 void
 LIRGeneratorMIPSShared::visitAsmJSAtomicExchangeHeap(MAsmJSAtomicExchangeHeap* ins)
 {
-    MOZ_ASSERT(ins->ptr()->type() == MIRType_Int32);
-
-    const LAllocation ptr = useRegister(ins->ptr());
-    const LAllocation value = useRegister(ins->value());
-
-    // The output may not be used but will be clobbered regardless,
-    // so ignore the case where we're not using the value and just
-    // use the output register as a temp.
-
-    LAsmJSAtomicExchangeHeap* lir =
-        new(alloc()) LAsmJSAtomicExchangeHeap(ptr, value,
-                                              /* valueTemp= */ temp(),
-                                              /* offsetTemp= */ temp(),
-                                              /* maskTemp= */ temp());
-    define(lir, ins);
+    MOZ_CRASH("NYI");
 }
 
 void
 LIRGeneratorMIPSShared::visitAsmJSAtomicBinopHeap(MAsmJSAtomicBinopHeap* ins)
 {
-    MOZ_ASSERT(ins->accessType() < Scalar::Float32);
-
-    MDefinition* ptr = ins->ptr();
-    MOZ_ASSERT(ptr->type() == MIRType_Int32);
-
-    if (!ins->hasUses()) {
-        LAsmJSAtomicBinopHeapForEffect* lir =
-            new(alloc()) LAsmJSAtomicBinopHeapForEffect(useRegister(ptr),
-                                                        useRegister(ins->value()),
-                                                        /* flagTemp= */ temp(),
-                                                        /* valueTemp= */ temp(),
-                                                        /* offsetTemp= */ temp(),
-                                                        /* maskTemp= */ temp());
-        add(lir, ins);
-        return;
-    }
-
-    LAsmJSAtomicBinopHeap* lir =
-        new(alloc()) LAsmJSAtomicBinopHeap(useRegister(ptr),
-                                           useRegister(ins->value()),
-                                           /* temp= */ LDefinition::BogusTemp(),
-                                           /* flagTemp= */ temp(),
-                                           /* valueTemp= */ temp(),
-                                           /* offsetTemp= */ temp(),
-                                           /* maskTemp= */ temp());
-
-    define(lir, ins);
+    MOZ_CRASH("NYI");
 }
 
 void
 LIRGeneratorMIPSShared::visitAtomicTypedArrayElementBinop(MAtomicTypedArrayElementBinop* ins)
 {
-    MOZ_ASSERT(ins->arrayType() != Scalar::Uint8Clamped);
-    MOZ_ASSERT(ins->arrayType() != Scalar::Float32);
-    MOZ_ASSERT(ins->arrayType() != Scalar::Float64);
-
-    MOZ_ASSERT(ins->elements()->type() == MIRType_Elements);
-    MOZ_ASSERT(ins->index()->type() == MIRType_Int32);
-
-    const LUse elements = useRegister(ins->elements());
-    const LAllocation index = useRegisterOrConstant(ins->index());
-    const LAllocation value = useRegister(ins->value());
-
-    if (!ins->hasUses()) {
-        LAtomicTypedArrayElementBinopForEffect* lir =
-            new(alloc()) LAtomicTypedArrayElementBinopForEffect(elements, index, value,
-                                                                /* flagTemp= */ temp(),
-                                                                /* valueTemp= */ temp(),
-                                                                /* offsetTemp= */ temp(),
-                                                                /* maskTemp= */ temp());
-        add(lir, ins);
-        return;
-    }
-
-    // For a Uint32Array with a known double result we need a temp for
-    // the intermediate output.
-
-    LDefinition flagTemp = temp();
-    LDefinition outTemp = LDefinition::BogusTemp();
-
-    if (ins->arrayType() == Scalar::Uint32 && IsFloatingPointType(ins->type()))
-        outTemp = temp();
-
-    // On mips, map flagTemp to temp1 and outTemp to temp2, at least for now.
-
-    LAtomicTypedArrayElementBinop* lir =
-        new(alloc()) LAtomicTypedArrayElementBinop(elements, index, value, flagTemp, outTemp,
-                                                   /* valueTemp= */ temp(), /* offsetTemp= */ temp(),
-                                                   /* maskTemp= */ temp());
-    define(lir, ins);
+    MOZ_CRASH("NYI");
 }
--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
@@ -784,280 +784,16 @@ MacroAssemblerMIPSShared::asMasm()
 }
 
 const MacroAssembler&
 MacroAssemblerMIPSShared::asMasm() const
 {
     return *static_cast<const MacroAssembler*>(this);
 }
 
-void
-MacroAssemblerMIPSShared::atomicEffectOpMIPSr2(int nbytes, AtomicOp op,
-                                               const Register& value, const Register& addr,
-                                               Register flagTemp, Register valueTemp,
-                                               Register offsetTemp, Register maskTemp)
-{
-    atomicFetchOpMIPSr2(nbytes, false, op, value, addr, flagTemp,
-                        valueTemp, offsetTemp, maskTemp, InvalidReg);
-}
-
-void
-MacroAssemblerMIPSShared::atomicFetchOpMIPSr2(int nbytes, bool signExtend, AtomicOp op, const Register& value,
-                                              const Register& addr, Register flagTemp, Register valueTemp,
-                                              Register offsetTemp, Register maskTemp, Register output)
-{
-    Label again;
-
-    as_andi(offsetTemp, addr, 3);
-    asMasm().subPtr(offsetTemp, addr);
-    as_sll(offsetTemp, offsetTemp, 3);
-    ma_li(maskTemp, Imm32(UINT32_MAX >> ((4 - nbytes) * 8)));
-    as_sllv(maskTemp, maskTemp, offsetTemp);
-
-    bind(&again);
-
-    as_sync(16);
-
-    as_ll(flagTemp, addr, 0);
-
-    as_sllv(valueTemp, value, offsetTemp);
-    if (output != InvalidReg) {
-        as_and(output, flagTemp, maskTemp);
-        as_srlv(output, output, offsetTemp);
-        if (signExtend) {
-            switch (nbytes) {
-            case 1:
-                as_seb(output, output);
-                break;
-            case 2:
-                as_seh(output, output);
-                break;
-            case 4:
-                break;
-            default:
-                MOZ_CRASH("NYI");
-            }
-        }
-    }
-
-    switch (op) {
-    case AtomicFetchAddOp:
-        as_addu(valueTemp, flagTemp, valueTemp);
-        break;
-    case AtomicFetchSubOp:
-        as_subu(valueTemp, flagTemp, valueTemp);
-        break;
-    case AtomicFetchAndOp:
-        as_and(valueTemp, flagTemp, valueTemp);
-        break;
-    case AtomicFetchOrOp:
-        as_or(valueTemp, flagTemp, valueTemp);
-        break;
-    case AtomicFetchXorOp:
-        as_xor(valueTemp, flagTemp, valueTemp);
-        break;
-    default:
-        MOZ_CRASH("NYI");
-    }
-
-    as_and(valueTemp, valueTemp, maskTemp);
-    as_or(flagTemp, flagTemp, maskTemp);
-    as_xor(flagTemp, flagTemp, maskTemp);
-    as_or(flagTemp, flagTemp, valueTemp);
-
-    as_sc(flagTemp, addr, 0);
-
-    ma_b(flagTemp, flagTemp, &again, Zero, ShortJump);
-
-    as_sync(0);
-}
-
-void
-MacroAssemblerMIPSShared::atomicEffectOp(int nbytes, AtomicOp op, const Imm32& value,
-                                         const Address& address, Register flagTemp,
-                                         Register valueTemp, Register offsetTemp, Register maskTemp)
-{
-    ma_li(SecondScratchReg, value);
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicEffectOpMIPSr2(nbytes, op, SecondScratchReg, ScratchRegister,
-                         flagTemp, valueTemp, offsetTemp, maskTemp);
-}
-
-void
-MacroAssemblerMIPSShared::atomicEffectOp(int nbytes, AtomicOp op, const Imm32& value,
-                                         const BaseIndex& address, Register flagTemp,
-                                         Register valueTemp, Register offsetTemp, Register maskTemp)
-{
-    ma_li(SecondScratchReg, value);
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicEffectOpMIPSr2(nbytes, op, SecondScratchReg, ScratchRegister,
-                         flagTemp, valueTemp, offsetTemp, maskTemp);
-}
-
-void
-MacroAssemblerMIPSShared::atomicEffectOp(int nbytes, AtomicOp op, const Register& value,
-                                         const Address& address, Register flagTemp,
-                                         Register valueTemp, Register offsetTemp, Register maskTemp)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicEffectOpMIPSr2(nbytes, op, value, ScratchRegister,
-                         flagTemp, valueTemp, offsetTemp, maskTemp);
-}
-
-void
-MacroAssemblerMIPSShared::atomicEffectOp(int nbytes, AtomicOp op, const Register& value,
-                                         const BaseIndex& address, Register flagTemp,
-                                         Register valueTemp, Register offsetTemp, Register maskTemp)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicEffectOpMIPSr2(nbytes, op, value, ScratchRegister,
-                         flagTemp, valueTemp, offsetTemp, maskTemp);
-}
-
-void
-MacroAssemblerMIPSShared::atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Imm32& value,
-                                        const Address& address, Register flagTemp, Register valueTemp,
-                                        Register offsetTemp, Register maskTemp, Register output)
-{
-    ma_li(SecondScratchReg, value);
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicFetchOpMIPSr2(nbytes, signExtend, op, SecondScratchReg, ScratchRegister,
-                        flagTemp, valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Imm32& value,
-                                        const BaseIndex& address, Register flagTemp, Register valueTemp,
-                                        Register offsetTemp, Register maskTemp, Register output)
-{
-    ma_li(SecondScratchReg, value);
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicFetchOpMIPSr2(nbytes, signExtend, op, SecondScratchReg, ScratchRegister,
-                        flagTemp, valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Register& value,
-                                        const Address& address, Register flagTemp, Register valueTemp,
-                                        Register offsetTemp, Register maskTemp, Register output)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicFetchOpMIPSr2(nbytes, signExtend, op, value, ScratchRegister,
-                        flagTemp, valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Register& value,
-                                        const BaseIndex& address, Register flagTemp, Register valueTemp,
-                                        Register offsetTemp, Register maskTemp, Register output)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    atomicFetchOpMIPSr2(nbytes, signExtend, op, value, ScratchRegister,
-                        flagTemp, valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::compareExchangeMIPSr2(int nbytes, bool signExtend, const Register& addr,
-                                                Register oldval, Register newval, Register flagTemp,
-                                                Register valueTemp, Register offsetTemp, Register maskTemp,
-                                                Register output)
-{
-    Label again, end;
-
-    as_andi(offsetTemp, addr, 3);
-    asMasm().subPtr(offsetTemp, addr);
-    as_sll(offsetTemp, offsetTemp, 3);
-    ma_li(maskTemp, Imm32(UINT32_MAX >> ((4 - nbytes) * 8)));
-    as_sllv(maskTemp, maskTemp, offsetTemp);
-
-    bind(&again);
-
-    as_sync(16);
-
-    as_ll(flagTemp, addr, 0);
-
-    as_and(output, flagTemp, maskTemp);
-    // If oldval is valid register, do compareExchange
-    if (InvalidReg != oldval) {
-        as_sllv(valueTemp, oldval, offsetTemp);
-        as_and(valueTemp, valueTemp, maskTemp);
-        ma_b(output, valueTemp, &end, NotEqual, ShortJump);
-    }
-
-    as_sllv(valueTemp, newval, offsetTemp);
-    as_and(valueTemp, valueTemp, maskTemp);
-    as_or(flagTemp, flagTemp, maskTemp);
-    as_xor(flagTemp, flagTemp, maskTemp);
-    as_or(flagTemp, flagTemp, valueTemp);
-
-    as_sc(flagTemp, addr, 0);
-
-    ma_b(flagTemp, flagTemp, &again, Zero, ShortJump);
-
-    as_sync(0);
-
-    bind(&end);
-
-    as_srlv(output, output, offsetTemp);
-    if (signExtend) {
-        switch (nbytes) {
-        case 1:
-            as_seb(output, output);
-            break;
-        case 2:
-            as_seh(output, output);
-            break;
-        case 4:
-            break;
-        default:
-            MOZ_CRASH("NYI");
-        }
-    }
-}
-
-void
-MacroAssemblerMIPSShared::compareExchange(int nbytes, bool signExtend, const Address& address,
-                                          Register oldval, Register newval, Register valueTemp,
-                                          Register offsetTemp, Register maskTemp, Register output)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    compareExchangeMIPSr2(nbytes, signExtend, ScratchRegister, oldval, newval, SecondScratchReg,
-                          valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::compareExchange(int nbytes, bool signExtend, const BaseIndex& address,
-                                          Register oldval, Register newval, Register valueTemp,
-                                          Register offsetTemp, Register maskTemp, Register output)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    compareExchangeMIPSr2(nbytes, signExtend, ScratchRegister, oldval, newval, SecondScratchReg,
-                          valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::atomicExchange(int nbytes, bool signExtend, const Address& address,
-                                         Register value, Register valueTemp, Register offsetTemp,
-                                         Register maskTemp, Register output)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    compareExchangeMIPSr2(nbytes, signExtend, ScratchRegister, InvalidReg, value, SecondScratchReg,
-                          valueTemp, offsetTemp, maskTemp, output);
-}
-
-void
-MacroAssemblerMIPSShared::atomicExchange(int nbytes, bool signExtend, const BaseIndex& address,
-                                         Register value, Register valueTemp, Register offsetTemp,
-                                         Register maskTemp, Register output)
-{
-    asMasm().computeEffectiveAddress(address, ScratchRegister);
-    compareExchangeMIPSr2(nbytes, signExtend, ScratchRegister, InvalidReg, value, SecondScratchReg,
-                          valueTemp, offsetTemp, maskTemp, output);
-}
-
 //{{{ check_macroassembler_style
 // ===============================================================
 // Stack manipulation functions.
 
 void
 MacroAssembler::Push(Register reg)
 {
     ma_push(reg);
--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared.h
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared.h
@@ -172,61 +172,14 @@ class MacroAssemblerMIPSShared : public 
     }
 
     void moveToFloat32(Register src, FloatRegister dest) {
         as_mtc1(src, dest);
     }
     void moveFromFloat32(FloatRegister src, Register dest) {
         as_mfc1(dest, src);
     }
-
-  private:
-    void atomicEffectOpMIPSr2(int nbytes, AtomicOp op, const Register& value, const Register& addr,
-                              Register flagTemp, Register valueTemp, Register offsetTemp, Register maskTemp);
-    void atomicFetchOpMIPSr2(int nbytes, bool signExtend, AtomicOp op, const Register& value, const Register& addr,
-                             Register flagTemp, Register valueTemp, Register offsetTemp, Register maskTemp,
-                             Register output);
-    void compareExchangeMIPSr2(int nbytes, bool signExtend, const Register& addr, Register oldval,
-                               Register newval, Register flagTemp, Register valueTemp, Register offsetTemp,
-                               Register maskTemp, Register output);
-
-  protected:
-    void atomicEffectOp(int nbytes, AtomicOp op, const Imm32& value, const Address& address,
-                        Register flagTemp, Register valueTemp, Register offsetTemp, Register maskTemp);
-    void atomicEffectOp(int nbytes, AtomicOp op, const Imm32& value, const BaseIndex& address,
-                        Register flagTemp, Register valueTemp, Register offsetTemp, Register maskTemp);
-    void atomicEffectOp(int nbytes, AtomicOp op, const Register& value, const Address& address,
-                        Register flagTemp, Register valueTemp, Register offsetTemp, Register maskTemp);
-    void atomicEffectOp(int nbytes, AtomicOp op, const Register& value, const BaseIndex& address,
-                        Register flagTemp, Register valueTemp, Register offsetTemp, Register maskTemp);
-
-    void atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Imm32& value,
-                       const Address& address, Register flagTemp, Register valueTemp,
-                       Register offsetTemp, Register maskTemp, Register output);
-    void atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Imm32& value,
-                       const BaseIndex& address, Register flagTemp, Register valueTemp,
-                       Register offsetTemp, Register maskTemp, Register output);
-    void atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Register& value,
-                       const Address& address, Register flagTemp, Register valueTemp,
-                       Register offsetTemp, Register maskTemp, Register output);
-    void atomicFetchOp(int nbytes, bool signExtend, AtomicOp op, const Register& value,
-                       const BaseIndex& address, Register flagTemp, Register valueTemp,
-                       Register offsetTemp, Register maskTemp, Register output);
-
-    void compareExchange(int nbytes, bool signExtend, const Address& address, Register oldval,
-                         Register newval, Register valueTemp, Register offsetTemp, Register maskTemp,
-                         Register output);
-    void compareExchange(int nbytes, bool signExtend, const BaseIndex& address, Register oldval,
-                         Register newval, Register valueTemp, Register offsetTemp, Register maskTemp,
-                         Register output);
-
-    void atomicExchange(int nbytes, bool signExtend, const Address& address, Register value,
-                        Register valueTemp, Register offsetTemp, Register maskTemp,
-                        Register output);
-    void atomicExchange(int nbytes, bool signExtend, const BaseIndex& address, Register value,
-                        Register valueTemp, Register offsetTemp, Register maskTemp,
-                        Register output);
 };
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_mips_shared_MacroAssembler_mips_shared_h */
--- a/js/src/jit/mips32/MacroAssembler-mips32.cpp
+++ b/js/src/jit/mips32/MacroAssembler-mips32.cpp
@@ -2421,115 +2421,16 @@ MacroAssemblerMIPSCompat::handleFailureW
     // the bailout tail stub.
     bind(&bailout);
     loadPtr(Address(sp, offsetof(ResumeFromException, bailoutInfo)), a2);
     ma_li(ReturnReg, Imm32(BAILOUT_RETURN_OK));
     loadPtr(Address(sp, offsetof(ResumeFromException, target)), a1);
     jump(a1);
 }
 
-template<typename T>
-void
-MacroAssemblerMIPSCompat::compareExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem,
-                                                         Register oldval, Register newval,
-                                                         Register temp, Register valueTemp,
-                                                         Register offsetTemp, Register maskTemp,
-                                                         AnyRegister output)
-{
-    switch (arrayType) {
-      case Scalar::Int8:
-        compareExchange8SignExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8:
-        compareExchange8ZeroExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8Clamped:
-        compareExchange8ZeroExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int16:
-        compareExchange16SignExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint16:
-        compareExchange16ZeroExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int32:
-        compareExchange32(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint32:
-        // At the moment, the code in MCallOptimize.cpp requires the output
-        // type to be double for uint32 arrays.  See bug 1077305.
-        MOZ_ASSERT(output.isFloat());
-        compareExchange32(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, temp);
-        convertUInt32ToDouble(temp, output.fpu());
-        break;
-      default:
-        MOZ_CRASH("Invalid typed array type");
-    }
-}
-
-template void
-MacroAssemblerMIPSCompat::compareExchangeToTypedIntArray(Scalar::Type arrayType, const Address& mem,
-                                                         Register oldval, Register newval, Register temp,
-                                                         Register valueTemp, Register offsetTemp, Register maskTemp,
-                                                         AnyRegister output);
-template void
-MacroAssemblerMIPSCompat::compareExchangeToTypedIntArray(Scalar::Type arrayType, const BaseIndex& mem,
-                                                         Register oldval, Register newval, Register temp,
-                                                         Register valueTemp, Register offsetTemp, Register maskTemp,
-                                                         AnyRegister output);
-
-template<typename T>
-void
-MacroAssemblerMIPSCompat::atomicExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem,
-                                                        Register value, Register temp, Register valueTemp,
-                                                        Register offsetTemp, Register maskTemp,
-                                                        AnyRegister output)
-{
-    switch (arrayType) {
-      case Scalar::Int8:
-        atomicExchange8SignExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8:
-        atomicExchange8ZeroExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8Clamped:
-        atomicExchange8ZeroExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int16:
-        atomicExchange16SignExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint16:
-        atomicExchange16ZeroExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int32:
-        atomicExchange32(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint32:
-        // At the moment, the code in MCallOptimize.cpp requires the output
-        // type to be double for uint32 arrays.  See bug 1077305.
-        MOZ_ASSERT(output.isFloat());
-        atomicExchange32(mem, value, valueTemp, offsetTemp, maskTemp, temp);
-        convertUInt32ToDouble(temp, output.fpu());
-        break;
-      default:
-        MOZ_CRASH("Invalid typed array type");
-    }
-}
-
-template void
-MacroAssemblerMIPSCompat::atomicExchangeToTypedIntArray(Scalar::Type arrayType, const Address& mem,
-                                                        Register value, Register temp, Register valueTemp,
-                                                        Register offsetTemp, Register maskTemp,
-                                                        AnyRegister output);
-template void
-MacroAssemblerMIPSCompat::atomicExchangeToTypedIntArray(Scalar::Type arrayType, const BaseIndex& mem,
-                                                        Register value, Register temp, Register valueTemp,
-                                                        Register offsetTemp, Register maskTemp,
-                                                        AnyRegister output);
-
 CodeOffsetLabel
 MacroAssemblerMIPSCompat::toggledJump(Label* label)
 {
     CodeOffsetLabel ret(nextOffset().getOffset());
     ma_b(label);
     return ret;
 }
 
--- a/js/src/jit/mips32/MacroAssembler-mips32.h
+++ b/js/src/jit/mips32/MacroAssembler-mips32.h
@@ -750,332 +750,229 @@ class MacroAssemblerMIPSCompat : public 
 
     /////////////////////////////////////////////////////////////////
     // Common interface.
     /////////////////////////////////////////////////////////////////
   public:
     // The following functions are exposed for use in platform-shared code.
 
     template<typename T>
-    void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                    Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(1, true, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                    Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(1, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                     Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(2, true, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                     Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(2, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange32(const T& mem, Register oldval, Register newval, Register valueTemp,
-                           Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange32(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(4, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
 
     template<typename T>
-    void atomicExchange8SignExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange8SignExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(1, true, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange8ZeroExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange8ZeroExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(1, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange16SignExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange16SignExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(2, true, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange16ZeroExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange16ZeroExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(2, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange32(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange32(const T& mem, Register value, Register output)
     {
-        atomicExchange(4, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchAdd8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAdd8(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAdd8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAdd16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAdd16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAdd32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAdd32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchSub8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
-    template <typename T, typename S>
-    void atomicSub8(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    template <typename T, typename S> void atomicSub8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
-    template <typename T, typename S>
-    void atomicSub16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    template <typename T, typename S> void atomicSub16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
-    template <typename T, typename S>
-    void atomicSub32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    template <typename T, typename S> void atomicSub32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchAnd8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAnd8(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAnd8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAnd16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAnd16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAnd32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAnd32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchOr8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                  Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                  Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr32(const S& value, const T& mem, Register flagTemp,
-                         Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicOr8(const T& value, const S& mem, Register flagTemp,
-                   Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicOr8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicOr16(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicOr16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicOr32(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicOr32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchXor8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicXor8(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicXor8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicXor16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicXor16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicXor32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicXor32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
-    template<typename T>
-    void compareExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem, Register oldval, Register newval,
-                                        Register temp, Register valueTemp, Register offsetTemp, Register maskTemp,
-                                        AnyRegister output);
-
-    template<typename T>
-    void atomicExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem, Register value,
-                                       Register temp, Register valueTemp, Register offsetTemp, Register maskTemp,
-                                       AnyRegister output);
-
     void add32(Register src, Register dest);
     void add32(Imm32 imm, Register dest);
     void add32(Imm32 imm, const Address& dest);
     void add64(Imm32 imm, Register64 dest) {
         as_addiu(dest.low, dest.low, imm.value);
         as_sltiu(ScratchRegister, dest.low, imm.value);
         as_addu(dest.high, dest.high, ScratchRegister);
     }
--- a/js/src/jit/mips64/MacroAssembler-mips64.cpp
+++ b/js/src/jit/mips64/MacroAssembler-mips64.cpp
@@ -2524,115 +2524,16 @@ MacroAssemblerMIPS64Compat::handleFailur
     // the bailout tail stub.
     bind(&bailout);
     loadPtr(Address(sp, offsetof(ResumeFromException, bailoutInfo)), a2);
     ma_li(ReturnReg, Imm32(BAILOUT_RETURN_OK));
     loadPtr(Address(sp, offsetof(ResumeFromException, target)), a1);
     jump(a1);
 }
 
-template<typename T>
-void
-MacroAssemblerMIPS64Compat::compareExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem,
-                                                           Register oldval, Register newval,
-                                                           Register temp, Register valueTemp,
-                                                           Register offsetTemp, Register maskTemp,
-                                                           AnyRegister output)
-{
-    switch (arrayType) {
-      case Scalar::Int8:
-        compareExchange8SignExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8:
-        compareExchange8ZeroExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8Clamped:
-        compareExchange8ZeroExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int16:
-        compareExchange16SignExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint16:
-        compareExchange16ZeroExtend(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int32:
-        compareExchange32(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint32:
-        // At the moment, the code in MCallOptimize.cpp requires the output
-        // type to be double for uint32 arrays.  See bug 1077305.
-        MOZ_ASSERT(output.isFloat());
-        compareExchange32(mem, oldval, newval, valueTemp, offsetTemp, maskTemp, temp);
-        convertUInt32ToDouble(temp, output.fpu());
-        break;
-      default:
-        MOZ_CRASH("Invalid typed array type");
-    }
-}
-
-template void
-MacroAssemblerMIPS64Compat::compareExchangeToTypedIntArray(Scalar::Type arrayType, const Address& mem,
-                                                           Register oldval, Register newval, Register temp,
-                                                           Register valueTemp, Register offsetTemp, Register maskTemp,
-                                                           AnyRegister output);
-template void
-MacroAssemblerMIPS64Compat::compareExchangeToTypedIntArray(Scalar::Type arrayType, const BaseIndex& mem,
-                                                           Register oldval, Register newval, Register temp,
-                                                           Register valueTemp, Register offsetTemp, Register maskTemp,
-                                                           AnyRegister output);
-
-template<typename T>
-void
-MacroAssemblerMIPS64Compat::atomicExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem,
-                                                          Register value, Register temp, Register valueTemp,
-                                                          Register offsetTemp, Register maskTemp,
-                                                          AnyRegister output)
-{
-    switch (arrayType) {
-      case Scalar::Int8:
-        atomicExchange8SignExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8:
-        atomicExchange8ZeroExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint8Clamped:
-        atomicExchange8ZeroExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int16:
-        atomicExchange16SignExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint16:
-        atomicExchange16ZeroExtend(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Int32:
-        atomicExchange32(mem, value, valueTemp, offsetTemp, maskTemp, output.gpr());
-        break;
-      case Scalar::Uint32:
-        // At the moment, the code in MCallOptimize.cpp requires the output
-        // type to be double for uint32 arrays.  See bug 1077305.
-        MOZ_ASSERT(output.isFloat());
-        atomicExchange32(mem, value, valueTemp, offsetTemp, maskTemp, temp);
-        convertUInt32ToDouble(temp, output.fpu());
-        break;
-      default:
-        MOZ_CRASH("Invalid typed array type");
-    }
-}
-
-template void
-MacroAssemblerMIPS64Compat::atomicExchangeToTypedIntArray(Scalar::Type arrayType, const Address& mem,
-                                                          Register value, Register temp, Register valueTemp,
-                                                          Register offsetTemp, Register maskTemp,
-                                                          AnyRegister output);
-template void
-MacroAssemblerMIPS64Compat::atomicExchangeToTypedIntArray(Scalar::Type arrayType, const BaseIndex& mem,
-                                                          Register value, Register temp, Register valueTemp,
-                                                          Register offsetTemp, Register maskTemp,
-                                                          AnyRegister output);
-
 CodeOffsetLabel
 MacroAssemblerMIPS64Compat::toggledJump(Label* label)
 {
     CodeOffsetLabel ret(nextOffset().getOffset());
     ma_b(label);
     return ret;
 }
 
--- a/js/src/jit/mips64/MacroAssembler-mips64.h
+++ b/js/src/jit/mips64/MacroAssembler-mips64.h
@@ -767,332 +767,229 @@ class MacroAssemblerMIPS64Compat : publi
 
     /////////////////////////////////////////////////////////////////
     // Common interface.
     /////////////////////////////////////////////////////////////////
   public:
     // The following functions are exposed for use in platform-shared code.
 
     template<typename T>
-    void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                    Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(1, true, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                    Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(1, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                     Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(2, true, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
-                                     Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(2, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void compareExchange32(const T& mem, Register oldval, Register newval, Register valueTemp,
-                           Register offsetTemp, Register maskTemp, Register output)
+    void compareExchange32(const T& mem, Register oldval, Register newval, Register output)
     {
-        compareExchange(4, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
 
     template<typename T>
-    void atomicExchange8SignExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange8SignExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(1, true, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange8ZeroExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange8ZeroExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(1, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange16SignExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange16SignExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(2, true, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange16ZeroExtend(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange16ZeroExtend(const T& mem, Register value, Register output)
     {
-        atomicExchange(2, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
     template<typename T>
-    void atomicExchange32(const T& mem, Register value, Register valueTemp,
-                          Register offsetTemp, Register maskTemp, Register output)
+    void atomicExchange32(const T& mem, Register value, Register output)
     {
-        atomicExchange(4, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchAdd8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAdd32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAdd32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAdd8(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAdd8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAdd16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAdd16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAdd32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAdd32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchSub8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchSub32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchSub32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
-    template <typename T, typename S>
-    void atomicSub8(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    template <typename T, typename S> void atomicSub8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
-    template <typename T, typename S>
-    void atomicSub16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    template <typename T, typename S> void atomicSub16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
-    template <typename T, typename S>
-    void atomicSub32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    template <typename T, typename S> void atomicSub32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchAnd8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchAnd32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchAnd32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAnd8(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAnd8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAnd16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAnd16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicAnd32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicAnd32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchOr8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                  Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                  Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchOr32(const S& value, const T& mem, Register flagTemp,
-                         Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchOr32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicOr8(const T& value, const S& mem, Register flagTemp,
-                   Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicOr8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicOr16(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicOr16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicOr32(const T& value, const S& mem, Register flagTemp,
-                    Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicOr32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
     template<typename T, typename S>
-    void atomicFetchXor8SignExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, true, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor8SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor8ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                   Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(1, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor8ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor16SignExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, true, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor16SignExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor16ZeroExtend(const S& value, const T& mem, Register flagTemp,
-                                    Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(2, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor16ZeroExtend(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template<typename T, typename S>
-    void atomicFetchXor32(const S& value, const T& mem, Register flagTemp,
-                          Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
-    {
-        atomicFetchOp(4, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
+    void atomicFetchXor32(const S& value, const T& mem, Register temp, Register output) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicXor8(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(1, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicXor8(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicXor16(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(2, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicXor16(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
     template <typename T, typename S>
-    void atomicXor32(const T& value, const S& mem, Register flagTemp,
-                     Register valueTemp, Register offsetTemp, Register maskTemp)
-    {
-        atomicEffectOp(4, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
+    void atomicXor32(const T& value, const S& mem) {
+        MOZ_CRASH("NYI");
     }
 
-    template<typename T>
-    void compareExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem, Register oldval, Register newval,
-                                        Register temp, Register valueTemp, Register offsetTemp, Register maskTemp,
-                                        AnyRegister output);
-
-    template<typename T>
-    void atomicExchangeToTypedIntArray(Scalar::Type arrayType, const T& mem, Register value,
-                                       Register temp, Register valueTemp, Register offsetTemp, Register maskTemp,
-                                       AnyRegister output);
-
     void add32(Register src, Register dest);
     void add32(Imm32 imm, Register dest);
     void add32(Imm32 imm, const Address& dest);
     void add64(Imm32 imm, Register64 dest) {
         ma_daddu(dest.reg, imm);
     }
     void sub32(Imm32 imm, Register dest);
     void sub32(Register src, Register dest);
--- a/js/src/jit/shared/LIR-shared.h
+++ b/js/src/jit/shared/LIR-shared.h
@@ -5173,47 +5173,31 @@ class LAtomicIsLockFree : public LInstru
     explicit LAtomicIsLockFree(const LAllocation& value) {
         setOperand(0, value);
     }
     const LAllocation* value() {
         return getOperand(0);
     }
 };
 
-class LCompareExchangeTypedArrayElement : public LInstructionHelper<1, 4, 4>
+class LCompareExchangeTypedArrayElement : public LInstructionHelper<1, 4, 1>
 {
   public:
     LIR_HEADER(CompareExchangeTypedArrayElement)
 
     LCompareExchangeTypedArrayElement(const LAllocation& elements, const LAllocation& index,
                                       const LAllocation& oldval, const LAllocation& newval,
                                       const LDefinition& temp)
     {
         setOperand(0, elements);
         setOperand(1, index);
         setOperand(2, oldval);
         setOperand(3, newval);
         setTemp(0, temp);
     }
-    LCompareExchangeTypedArrayElement(const LAllocation& elements, const LAllocation& index,
-                                      const LAllocation& oldval, const LAllocation& newval,
-                                      const LDefinition& temp,
-                                      const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                                      const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                                      const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, elements);
-        setOperand(1, index);
-        setOperand(2, oldval);
-        setOperand(3, newval);
-        setTemp(0, temp);
-        setTemp(1, valueTemp);
-        setTemp(2, offsetTemp);
-        setTemp(3, maskTemp);
-    }
 
     const LAllocation* elements() {
         return getOperand(0);
     }
     const LAllocation* index() {
         return getOperand(1);
     }
     const LAllocation* oldval() {
@@ -5221,122 +5205,70 @@ class LCompareExchangeTypedArrayElement 
     }
     const LAllocation* newval() {
         return getOperand(3);
     }
     const LDefinition* temp() {
         return getTemp(0);
     }
 
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(1);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(3);
-    }
-
     const MCompareExchangeTypedArrayElement* mir() const {
         return mir_->toCompareExchangeTypedArrayElement();
     }
 };
 
-class LAtomicExchangeTypedArrayElement : public LInstructionHelper<1, 3, 4>
+class LAtomicExchangeTypedArrayElement : public LInstructionHelper<1, 3, 1>
 {
   public:
     LIR_HEADER(AtomicExchangeTypedArrayElement)
 
     LAtomicExchangeTypedArrayElement(const LAllocation& elements, const LAllocation& index,
                                      const LAllocation& value, const LDefinition& temp)
     {
         setOperand(0, elements);
         setOperand(1, index);
         setOperand(2, value);
         setTemp(0, temp);
     }
-    LAtomicExchangeTypedArrayElement(const LAllocation& elements, const LAllocation& index,
-                                     const LAllocation& value, const LDefinition& temp,
-                                     const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                                     const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                                     const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, elements);
-        setOperand(1, index);
-        setOperand(2, value);
-        setTemp(0, temp);
-        setTemp(1, valueTemp);
-        setTemp(2, offsetTemp);
-        setTemp(3, maskTemp);
-    }
 
     const LAllocation* elements() {
         return getOperand(0);
     }
     const LAllocation* index() {
         return getOperand(1);
     }
     const LAllocation* value() {
         return getOperand(2);
     }
     const LDefinition* temp() {
         return getTemp(0);
     }
 
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(1);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(3);
-    }
-
     const MAtomicExchangeTypedArrayElement* mir() const {
         return mir_->toAtomicExchangeTypedArrayElement();
     }
 };
 
-class LAtomicTypedArrayElementBinop : public LInstructionHelper<1, 3, 5>
+class LAtomicTypedArrayElementBinop : public LInstructionHelper<1, 3, 2>
 {
   public:
     LIR_HEADER(AtomicTypedArrayElementBinop)
 
     static const int32_t valueOp = 2;
 
     LAtomicTypedArrayElementBinop(const LAllocation& elements, const LAllocation& index,
                                   const LAllocation& value, const LDefinition& temp1,
                                   const LDefinition& temp2)
     {
         setOperand(0, elements);
         setOperand(1, index);
         setOperand(2, value);
         setTemp(0, temp1);
         setTemp(1, temp2);
     }
-    LAtomicTypedArrayElementBinop(const LAllocation& elements, const LAllocation& index,
-                                  const LAllocation& value, const LDefinition& temp1,
-                                  const LDefinition& temp2,
-                                  const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                                  const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                                  const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, elements);
-        setOperand(1, index);
-        setOperand(2, value);
-        setTemp(0, temp1);
-        setTemp(1, temp2);
-        setTemp(2, valueTemp);
-        setTemp(3, offsetTemp);
-        setTemp(4, maskTemp);
-    }
 
     const LAllocation* elements() {
         return getOperand(0);
     }
     const LAllocation* index() {
         return getOperand(1);
     }
     const LAllocation* value() {
@@ -5345,87 +5277,51 @@ class LAtomicTypedArrayElementBinop : pu
     }
     const LDefinition* temp1() {
         return getTemp(0);
     }
     const LDefinition* temp2() {
         return getTemp(1);
     }
 
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(3);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(4);
-    }
-
     const MAtomicTypedArrayElementBinop* mir() const {
         return mir_->toAtomicTypedArrayElementBinop();
     }
 };
 
 // Atomic binary operation where the result is discarded.
-class LAtomicTypedArrayElementBinopForEffect : public LInstructionHelper<0, 3, 4>
+class LAtomicTypedArrayElementBinopForEffect : public LInstructionHelper<0, 3, 1>
 {
   public:
     LIR_HEADER(AtomicTypedArrayElementBinopForEffect)
 
     LAtomicTypedArrayElementBinopForEffect(const LAllocation& elements, const LAllocation& index,
                                            const LAllocation& value,
                                            const LDefinition& flagTemp = LDefinition::BogusTemp())
     {
         setOperand(0, elements);
         setOperand(1, index);
         setOperand(2, value);
         setTemp(0, flagTemp);
     }
-    LAtomicTypedArrayElementBinopForEffect(const LAllocation& elements, const LAllocation& index,
-                                           const LAllocation& value,
-                                           const LDefinition& flagTemp = LDefinition::BogusTemp(),
-                                           const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                                           const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                                           const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, elements);
-        setOperand(1, index);
-        setOperand(2, value);
-        setTemp(0, flagTemp);
-        setTemp(1, valueTemp);
-        setTemp(2, offsetTemp);
-        setTemp(3, maskTemp);
-    }
 
     const LAllocation* elements() {
         return getOperand(0);
     }
     const LAllocation* index() {
         return getOperand(1);
     }
     const LAllocation* value() {
         return getOperand(2);
     }
 
     // Temp that may be used on LL/SC platforms for the flag result of the store.
     const LDefinition* flagTemp() {
         return getTemp(0);
     }
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(1);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(3);
-    }
 
     const MAtomicTypedArrayElementBinop* mir() const {
         return mir_->toAtomicTypedArrayElementBinop();
     }
 };
 
 class LEffectiveAddress : public LInstructionHelper<1, 2, 0>
 {
@@ -6652,43 +6548,29 @@ class LAsmJSStoreHeap : public LInstruct
     const LAllocation* ptr() {
         return getOperand(0);
     }
     const LAllocation* value() {
         return getOperand(1);
     }
 };
 
-class LAsmJSCompareExchangeHeap : public LInstructionHelper<1, 3, 4>
+class LAsmJSCompareExchangeHeap : public LInstructionHelper<1, 3, 1>
 {
   public:
     LIR_HEADER(AsmJSCompareExchangeHeap);
 
     LAsmJSCompareExchangeHeap(const LAllocation& ptr, const LAllocation& oldValue,
                               const LAllocation& newValue)
     {
         setOperand(0, ptr);
         setOperand(1, oldValue);
         setOperand(2, newValue);
         setTemp(0, LDefinition::BogusTemp());
     }
-    LAsmJSCompareExchangeHeap(const LAllocation& ptr, const LAllocation& oldValue,
-                              const LAllocation& newValue,
-                              const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                              const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                              const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, ptr);
-        setOperand(1, oldValue);
-        setOperand(2, newValue);
-        setTemp(0, LDefinition::BogusTemp());
-        setTemp(1, valueTemp);
-        setTemp(2, offsetTemp);
-        setTemp(3, maskTemp);
-    }
 
     const LAllocation* ptr() {
         return getOperand(0);
     }
     const LAllocation* oldValue() {
         return getOperand(1);
     }
     const LAllocation* newValue() {
@@ -6697,119 +6579,69 @@ class LAsmJSCompareExchangeHeap : public
     const LDefinition* addrTemp() {
         return getTemp(0);
     }
 
     void setAddrTemp(const LDefinition& addrTemp) {
         setTemp(0, addrTemp);
     }
 
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(1);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(3);
-    }
-
     MAsmJSCompareExchangeHeap* mir() const {
         return mir_->toAsmJSCompareExchangeHeap();
     }
 };
 
-class LAsmJSAtomicExchangeHeap : public LInstructionHelper<1, 2, 4>
+class LAsmJSAtomicExchangeHeap : public LInstructionHelper<1, 2, 1>
 {
   public:
     LIR_HEADER(AsmJSAtomicExchangeHeap);
 
     LAsmJSAtomicExchangeHeap(const LAllocation& ptr, const LAllocation& value)
     {
         setOperand(0, ptr);
         setOperand(1, value);
         setTemp(0, LDefinition::BogusTemp());
     }
-    LAsmJSAtomicExchangeHeap(const LAllocation& ptr, const LAllocation& value,
-                             const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                             const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                             const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, ptr);
-        setOperand(1, value);
-        setTemp(0, LDefinition::BogusTemp());
-        setTemp(1, valueTemp);
-        setTemp(2, offsetTemp);
-        setTemp(3, maskTemp);
-    }
 
     const LAllocation* ptr() {
         return getOperand(0);
     }
     const LAllocation* value() {
         return getOperand(1);
     }
     const LDefinition* addrTemp() {
         return getTemp(0);
     }
 
     void setAddrTemp(const LDefinition& addrTemp) {
         setTemp(0, addrTemp);
     }
 
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(1);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(3);
-    }
-
     MAsmJSAtomicExchangeHeap* mir() const {
         return mir_->toAsmJSAtomicExchangeHeap();
     }
 };
 
-class LAsmJSAtomicBinopHeap : public LInstructionHelper<1, 2, 6>
+class LAsmJSAtomicBinopHeap : public LInstructionHelper<1, 2, 3>
 {
   public:
     LIR_HEADER(AsmJSAtomicBinopHeap);
 
     static const int32_t valueOp = 1;
 
     LAsmJSAtomicBinopHeap(const LAllocation& ptr, const LAllocation& value,
                           const LDefinition& temp,
                           const LDefinition& flagTemp = LDefinition::BogusTemp())
     {
         setOperand(0, ptr);
         setOperand(1, value);
         setTemp(0, temp);
         setTemp(1, LDefinition::BogusTemp());
         setTemp(2, flagTemp);
     }
-    LAsmJSAtomicBinopHeap(const LAllocation& ptr, const LAllocation& value,
-                          const LDefinition& temp,
-                          const LDefinition& flagTemp = LDefinition::BogusTemp(),
-                          const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                          const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                          const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, ptr);
-        setOperand(1, value);
-        setTemp(0, temp);
-        setTemp(1, LDefinition::BogusTemp());
-        setTemp(2, flagTemp);
-        setTemp(3, valueTemp);
-        setTemp(4, offsetTemp);
-        setTemp(5, maskTemp);
-    }
     const LAllocation* ptr() {
         return getOperand(0);
     }
     const LAllocation* value() {
         MOZ_ASSERT(valueOp == 1);
         return getOperand(1);
     }
     const LDefinition* temp() {
@@ -6823,59 +6655,35 @@ class LAsmJSAtomicBinopHeap : public LIn
     void setAddrTemp(const LDefinition& addrTemp) {
         setTemp(1, addrTemp);
     }
 
     // Temp that may be used on LL/SC platforms for the flag result of the store.
     const LDefinition* flagTemp() {
         return getTemp(2);
     }
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(3);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(4);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(5);
-    }
 
     MAsmJSAtomicBinopHeap* mir() const {
         return mir_->toAsmJSAtomicBinopHeap();
     }
 };
 
 // Atomic binary operation where the result is discarded.
-class LAsmJSAtomicBinopHeapForEffect : public LInstructionHelper<0, 2, 5>
+class LAsmJSAtomicBinopHeapForEffect : public LInstructionHelper<0, 2, 2>
 {
   public:
     LIR_HEADER(AsmJSAtomicBinopHeapForEffect);
     LAsmJSAtomicBinopHeapForEffect(const LAllocation& ptr, const LAllocation& value,
                                    const LDefinition& flagTemp = LDefinition::BogusTemp())
     {
         setOperand(0, ptr);
         setOperand(1, value);
         setTemp(0, LDefinition::BogusTemp());
         setTemp(1, flagTemp);
     }
-    LAsmJSAtomicBinopHeapForEffect(const LAllocation& ptr, const LAllocation& value,
-                                   const LDefinition& flagTemp = LDefinition::BogusTemp(),
-                                   const LDefinition& valueTemp = LDefinition::BogusTemp(),
-                                   const LDefinition& offsetTemp = LDefinition::BogusTemp(),
-                                   const LDefinition& maskTemp = LDefinition::BogusTemp())
-    {
-        setOperand(0, ptr);
-        setOperand(1, value);
-        setTemp(0, LDefinition::BogusTemp());
-        setTemp(1, flagTemp);
-        setTemp(2, valueTemp);
-        setTemp(3, offsetTemp);
-        setTemp(4, maskTemp);
-    }
     const LAllocation* ptr() {
         return getOperand(0);
     }
     const LAllocation* value() {
         return getOperand(1);
     }
 
     // Temp that may be used on some platforms to hold a computed address.
@@ -6885,26 +6693,16 @@ class LAsmJSAtomicBinopHeapForEffect : p
     void setAddrTemp(const LDefinition& addrTemp) {
         setTemp(0, addrTemp);
     }
 
     // Temp that may be used on LL/SC platforms for the flag result of the store.
     const LDefinition* flagTemp() {
         return getTemp(1);
     }
-    // Temp that may be used on LL/SC platforms for extract/insert bits of word.
-    const LDefinition* valueTemp() {
-        return getTemp(2);
-    }
-    const LDefinition* offsetTemp() {
-        return getTemp(3);
-    }
-    const LDefinition* maskTemp() {
-        return getTemp(4);
-    }
 
     MAsmJSAtomicBinopHeap* mir() const {
         return mir_->toAsmJSAtomicBinopHeap();
     }
 };
 
 class LAsmJSLoadGlobalVar : public LInstructionHelper<1, 0, 0>
 {