Add support for OpAtomicISub, OpAtomicIIncrement, OpAtomicIDecrement

src/Pipeline/SpirvShader.cpp

@@ -679,6 +679,7 @@ namespace sw
 			case spv::OpFwidthFine:
 			case spv::OpAtomicLoad:
 			case spv::OpAtomicIAdd:
+			case spv::OpAtomicISub:
 			case spv::OpAtomicSMin:
 			case spv::OpAtomicSMax:
 			case spv::OpAtomicUMin:
@@ -686,6 +687,8 @@ namespace sw
 			case spv::OpAtomicAnd:
 			case spv::OpAtomicOr:
 			case spv::OpAtomicXor:
+			case spv::OpAtomicIIncrement:
+			case spv::OpAtomicIDecrement:
 			case spv::OpAtomicExchange:
 			case spv::OpAtomicCompareExchange:
 			case spv::OpPhi:
@@ -2017,6 +2020,7 @@ namespace sw
 			return EmitStore(insn, state);
 
 		case spv::OpAtomicIAdd:
+		case spv::OpAtomicISub:
 		case spv::OpAtomicSMin:
 		case spv::OpAtomicSMax:
 		case spv::OpAtomicUMin:
@@ -2024,6 +2028,8 @@ namespace sw
 		case spv::OpAtomicAnd:
 		case spv::OpAtomicOr:
 		case spv::OpAtomicXor:
+		case spv::OpAtomicIIncrement:
+		case spv::OpAtomicIDecrement:
 		case spv::OpAtomicExchange:
 			return EmitAtomicOp(insn, state);
 
@@ -4759,7 +4765,8 @@ namespace sw
 		Object::ID semanticsId = insn.word(5);
 		auto memorySemantics = static_cast<spv::MemorySemanticsMask>(getObject(semanticsId).constantValue[0]);
 		auto memoryOrder = MemoryOrder(memorySemantics);
-		auto value = GenericValue(this, state->routine, insn.word(6));
+		// Where no value is provided (increment/decrement) use an implicit value of 1.
+		auto value = (insn.wordCount() == 7) ? GenericValue(this, state->routine, insn.word(6)).UInt(0) : RValue<SIMD::UInt>(1);
 		auto &dst = state->routine->createIntermediate(resultId, resultType.sizeInComponents);
 		auto ptr = state->routine->getPointer(insn.word(3));
 
@@ -4769,13 +4776,18 @@ namespace sw
 			If(Extract(state->activeLaneMask(), j) != 0)
 			{
 				auto offset = Extract(ptr.offset, j);
-				auto laneValue = Extract(value.UInt(0), j);
+				auto laneValue = Extract(value, j);
 				UInt v;
 				switch (insn.opcode())
 				{
 				case spv::OpAtomicIAdd:
+				case spv::OpAtomicIIncrement:
 					v = AddAtomic(Pointer<UInt>(&ptr.base[offset]), laneValue, memoryOrder);
 					break;
+				case spv::OpAtomicISub:
+				case spv::OpAtomicIDecrement:
+					v = SubAtomic(Pointer<UInt>(&ptr.base[offset]), laneValue, memoryOrder);
+					break;
 				case spv::OpAtomicAnd:
 					v = AndAtomic(Pointer<UInt>(&ptr.base[offset]), laneValue, memoryOrder);
 					break;

src/Reactor/LLVMReactor.cpp

@@ -1294,6 +1294,12 @@ namespace rr
 		return V(::builder->CreateAtomicRMW(llvm::AtomicRMWInst::Add, V(ptr), V(value), atomicOrdering(true, memoryOrder)));
 	}
 
+	Value *Nucleus::createAtomicSub(Value *ptr, Value *value, std::memory_order memoryOrder)
+	{
+		RR_DEBUG_INFO_UPDATE_LOC();
+		return V(::builder->CreateAtomicRMW(llvm::AtomicRMWInst::Sub, V(ptr), V(value), atomicOrdering(true, memoryOrder)));
+	}
+
 	Value *Nucleus::createAtomicAnd(Value *ptr, Value *value, std::memory_order memoryOrder)
 	{
 		RR_DEBUG_INFO_UPDATE_LOC();

src/Reactor/Nucleus.hpp

@@ -102,6 +102,7 @@ namespace rr
 
 		// Atomic instructions
 		static Value *createAtomicAdd(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
+		static Value *createAtomicSub(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
 		static Value *createAtomicAnd(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
 		static Value *createAtomicOr(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
 		static Value *createAtomicXor(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);

src/Reactor/Reactor.cpp

@@ -2512,6 +2512,11 @@ namespace rr
 		return RValue<UInt>(Nucleus::createAtomicAdd(x.value, y.value, memoryOrder));
 	}
 
+	RValue<UInt> SubAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+	{
+		return RValue<UInt>(Nucleus::createAtomicSub(x.value, y.value, memoryOrder));
+	}
+
 	RValue<UInt> AndAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
 	{
 		return RValue<UInt>(Nucleus::createAtomicAnd(x.value, y.value, memoryOrder));

src/Reactor/Reactor.hpp

@@ -1269,6 +1269,7 @@ namespace rr
 	RValue<UInt> Clamp(RValue<UInt> x, RValue<UInt> min, RValue<UInt> max);
 
 	RValue<UInt> AddAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);
+	RValue<UInt> SubAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);
 	RValue<UInt> AndAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);
 	RValue<UInt> OrAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);
 	RValue<UInt> XorAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);

src/Reactor/SubzeroReactor.cpp

@@ -1039,6 +1039,12 @@ namespace rr
 		return nullptr;
 	}
 
+	Value *Nucleus::createAtomicSub(Value *ptr, Value *value, std::memory_order memoryOrder)
+	{
+		UNIMPLEMENTED("createAtomicSub");
+		return nullptr;
+	}
+
 	Value *Nucleus::createAtomicAnd(Value *ptr, Value *value, std::memory_order memoryOrder)
 	{
 		UNIMPLEMENTED("createAtomicAnd");