Bug 1090957 - IonMonkey: MIPS64: Implement atomics in MacroAssembler. r=lth

---
 js/src/jit/mips64/MacroAssembler-mips64.cpp |  99 +++++++++
 js/src/jit/mips64/MacroAssembler-mips64.h   | 303 +++++++++++++++++++---------
 2 files changed, 302 insertions(+), 100 deletions(-)
This commit is contained in:
Heiher 2015-11-08 11:37:41 +08:00
Родитель 75053668d4
Коммит 3d7202f2e8
2 изменённых файлов: 302 добавлений и 100 удалений

Просмотреть файл

@ -2529,6 +2529,105 @@ MacroAssemblerMIPS64Compat::handleFailureWithHandlerTail(void* handler)
jump(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 CodeOffsetLabel
MacroAssemblerMIPS64Compat::toggledJump(Label* label) MacroAssemblerMIPS64Compat::toggledJump(Label* label)
{ {

Просмотреть файл

@ -772,219 +772,322 @@ class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64
// The following functions are exposed for use in platform-shared code. // The following functions are exposed for use in platform-shared code.
template<typename T> template<typename T>
void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register output) void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); compareExchange(1, true, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register output) void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); compareExchange(1, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register output) void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); compareExchange(2, true, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register output) void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); compareExchange(2, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void compareExchange32(const T& mem, Register oldval, Register newval, Register output) void compareExchange32(const T& mem, Register oldval, Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); compareExchange(4, false, mem, oldval, newval, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void atomicExchange8SignExtend(const T& mem, Register value, Register output) void atomicExchange8SignExtend(const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); atomicExchange(1, true, mem, value, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void atomicExchange8ZeroExtend(const T& mem, Register value, Register output) void atomicExchange8ZeroExtend(const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); atomicExchange(1, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void atomicExchange16SignExtend(const T& mem, Register value, Register output) void atomicExchange16SignExtend(const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); atomicExchange(2, true, mem, value, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void atomicExchange16ZeroExtend(const T& mem, Register value, Register output) void atomicExchange16ZeroExtend(const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); atomicExchange(2, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T> template<typename T>
void atomicExchange32(const T& mem, Register value, Register output) void atomicExchange32(const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp, Register output)
{ {
MOZ_CRASH("NYI"); atomicExchange(4, false, mem, value, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAdd8SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAdd8SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, true, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAdd8ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAdd8ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAdd16SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAdd16SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, true, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAdd16ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAdd16ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAdd32(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAdd32(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(4, false, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicAdd8(const T& value, const S& mem) { void atomicAdd8(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(1, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicAdd16(const T& value, const S& mem) { void atomicAdd16(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(2, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicAdd32(const T& value, const S& mem) { void atomicAdd32(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(4, AtomicFetchAddOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchSub8SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchSub8SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, true, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchSub8ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchSub8ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchSub16SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchSub16SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, true, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchSub16ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchSub16ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchSub32(const S& value, const T& mem, Register temp, Register output) { void atomicFetchSub32(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(4, false, AtomicFetchSubOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template <typename T, typename S> void atomicSub8(const T& value, const S& mem) { template <typename T, typename S>
MOZ_CRASH("NYI"); 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 atomicSub16(const T& value, const S& mem) { template <typename T, typename S>
MOZ_CRASH("NYI"); 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 atomicSub32(const T& value, const S& mem) { template <typename T, typename S>
MOZ_CRASH("NYI"); 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> template<typename T, typename S>
void atomicFetchAnd8SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAnd8SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, true, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAnd8ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAnd8ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAnd16SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAnd16SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, true, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAnd16ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAnd16ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchAnd32(const S& value, const T& mem, Register temp, Register output) { void atomicFetchAnd32(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(4, false, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicAnd8(const T& value, const S& mem) { void atomicAnd8(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(1, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicAnd16(const T& value, const S& mem) { void atomicAnd16(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(2, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicAnd32(const T& value, const S& mem) { void atomicAnd32(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(4, AtomicFetchAndOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchOr8SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchOr8SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, true, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchOr8ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchOr8ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchOr16SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchOr16SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, true, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchOr16ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchOr16ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchOr32(const S& value, const T& mem, Register temp, Register output) { void atomicFetchOr32(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(4, false, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicOr8(const T& value, const S& mem) { void atomicOr8(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(1, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicOr16(const T& value, const S& mem) { void atomicOr16(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(2, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicOr32(const T& value, const S& mem) { void atomicOr32(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(4, AtomicFetchOrOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchXor8SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchXor8SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, true, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchXor8ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchXor8ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(1, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchXor16SignExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchXor16SignExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, true, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchXor16ZeroExtend(const S& value, const T& mem, Register temp, Register output) { void atomicFetchXor16ZeroExtend(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(2, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template<typename T, typename S> template<typename T, typename S>
void atomicFetchXor32(const S& value, const T& mem, Register temp, Register output) { void atomicFetchXor32(const S& value, const T& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp, Register output)
{
atomicFetchOp(4, false, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp, output);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicXor8(const T& value, const S& mem) { void atomicXor8(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(1, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicXor16(const T& value, const S& mem) { void atomicXor16(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(2, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
template <typename T, typename S> template <typename T, typename S>
void atomicXor32(const T& value, const S& mem) { void atomicXor32(const T& value, const S& mem, Register flagTemp,
MOZ_CRASH("NYI"); Register valueTemp, Register offsetTemp, Register maskTemp)
{
atomicEffectOp(4, AtomicFetchXorOp, value, mem, flagTemp, valueTemp, offsetTemp, maskTemp);
} }
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(Register src, Register dest);
void add32(Imm32 imm, Register dest); void add32(Imm32 imm, Register dest);
void add32(Imm32 imm, const Address& dest); void add32(Imm32 imm, const Address& dest);