1//===- AtomicOps.cpp - MLIR SPIR-V Atomic Ops ----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Defines the atomic operations in the SPIR-V dialect.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
14
15#include "SPIRVOpUtils.h"
16#include "SPIRVParsingUtils.h"
17
18using namespace mlir::spirv::AttrNames;
19
20namespace mlir::spirv {
21
22template <typename T>
23static StringRef stringifyTypeName();
24
25template <>
26StringRef stringifyTypeName<IntegerType>() {
27 return "integer";
28}
29
30template <>
31StringRef stringifyTypeName<FloatType>() {
32 return "float";
33}
34
35// Verifies an atomic update op.
36template <typename AtomicOpTy, typename ExpectedElementType>
37static LogicalResult verifyAtomicUpdateOp(Operation *op) {
38 auto ptrType = cast<spirv::PointerType>(Val: op->getOperand(idx: 0).getType());
39 auto elementType = ptrType.getPointeeType();
40 if (!isa<ExpectedElementType>(elementType))
41 return op->emitOpError() << "pointer operand must point to an "
42 << stringifyTypeName<ExpectedElementType>()
43 << " value, found " << elementType;
44
45 spirv::MemorySemantics memorySemantics = cast<AtomicOpTy>(op).getSemantics();
46 if (failed(Result: verifyMemorySemantics(op, memorySemantics))) {
47 return failure();
48 }
49 return success();
50}
51
52//===----------------------------------------------------------------------===//
53// spirv.AtomicAndOp
54//===----------------------------------------------------------------------===//
55
56LogicalResult AtomicAndOp::verify() {
57 return verifyAtomicUpdateOp<AtomicAndOp, IntegerType>(op: getOperation());
58}
59
60//===----------------------------------------------------------------------===//
61// spirv.AtomicCompareExchangeOp
62//===----------------------------------------------------------------------===//
63
64LogicalResult AtomicCompareExchangeOp::verify() {
65 if (failed(Result: verifyMemorySemantics(op: getOperation(), memorySemantics: getEqualSemantics())))
66 return failure();
67 return verifyMemorySemantics(op: getOperation(), memorySemantics: getUnequalSemantics());
68}
69
70//===----------------------------------------------------------------------===//
71// spirv.AtomicCompareExchangeWeakOp
72//===----------------------------------------------------------------------===//
73
74LogicalResult AtomicCompareExchangeWeakOp::verify() {
75 if (failed(Result: verifyMemorySemantics(op: getOperation(), memorySemantics: getEqualSemantics())))
76 return failure();
77 return verifyMemorySemantics(op: getOperation(), memorySemantics: getUnequalSemantics());
78}
79
80//===----------------------------------------------------------------------===//
81// spirv.AtomicExchangeOp
82//===----------------------------------------------------------------------===//
83
84LogicalResult AtomicExchangeOp::verify() {
85 return verifyMemorySemantics(op: getOperation(), memorySemantics: getSemantics());
86}
87
88//===----------------------------------------------------------------------===//
89// spirv.AtomicLoadOp
90//===----------------------------------------------------------------------===//
91
92LogicalResult AtomicLoadOp::verify() {
93 return verifyMemorySemantics(op: getOperation(), memorySemantics: getSemantics());
94}
95
96//===----------------------------------------------------------------------===//
97// spirv.AtomicStoreOp
98//===----------------------------------------------------------------------===//
99
100LogicalResult AtomicStoreOp::verify() {
101 return verifyMemorySemantics(op: getOperation(), memorySemantics: getSemantics());
102}
103
104//===----------------------------------------------------------------------===//
105// spirv.AtomicIAddOp
106//===----------------------------------------------------------------------===//
107
108LogicalResult AtomicIAddOp::verify() {
109 return verifyAtomicUpdateOp<AtomicIAddOp, IntegerType>(op: getOperation());
110}
111
112//===----------------------------------------------------------------------===//
113// spirv.EXT.AtomicFAddOp
114//===----------------------------------------------------------------------===//
115
116LogicalResult EXTAtomicFAddOp::verify() {
117 return verifyAtomicUpdateOp<EXTAtomicFAddOp, FloatType>(op: getOperation());
118}
119
120//===----------------------------------------------------------------------===//
121// spirv.AtomicIDecrementOp
122//===----------------------------------------------------------------------===//
123
124LogicalResult AtomicIDecrementOp::verify() {
125 return verifyAtomicUpdateOp<AtomicIDecrementOp, IntegerType>(op: getOperation());
126}
127
128//===----------------------------------------------------------------------===//
129// spirv.AtomicIIncrementOp
130//===----------------------------------------------------------------------===//
131
132LogicalResult AtomicIIncrementOp::verify() {
133 return verifyAtomicUpdateOp<AtomicIIncrementOp, IntegerType>(op: getOperation());
134}
135
136//===----------------------------------------------------------------------===//
137// spirv.AtomicISubOp
138//===----------------------------------------------------------------------===//
139
140LogicalResult AtomicISubOp::verify() {
141 return verifyAtomicUpdateOp<AtomicISubOp, IntegerType>(op: getOperation());
142}
143
144//===----------------------------------------------------------------------===//
145// spirv.AtomicOrOp
146//===----------------------------------------------------------------------===//
147
148LogicalResult AtomicOrOp::verify() {
149 return verifyAtomicUpdateOp<AtomicOrOp, IntegerType>(op: getOperation());
150}
151
152//===----------------------------------------------------------------------===//
153// spirv.AtomicSMaxOp
154//===----------------------------------------------------------------------===//
155
156LogicalResult AtomicSMaxOp::verify() {
157 return verifyAtomicUpdateOp<AtomicSMaxOp, IntegerType>(op: getOperation());
158}
159
160//===----------------------------------------------------------------------===//
161// spirv.AtomicSMinOp
162//===----------------------------------------------------------------------===//
163
164LogicalResult AtomicSMinOp::verify() {
165 return verifyAtomicUpdateOp<AtomicSMinOp, IntegerType>(op: getOperation());
166}
167
168//===----------------------------------------------------------------------===//
169// spirv.AtomicUMaxOp
170//===----------------------------------------------------------------------===//
171
172LogicalResult AtomicUMaxOp::verify() {
173 return verifyAtomicUpdateOp<AtomicUMaxOp, IntegerType>(op: getOperation());
174}
175
176//===----------------------------------------------------------------------===//
177// spirv.AtomicUMinOp
178//===----------------------------------------------------------------------===//
179
180LogicalResult AtomicUMinOp::verify() {
181 return verifyAtomicUpdateOp<AtomicUMinOp, IntegerType>(op: getOperation());
182}
183
184//===----------------------------------------------------------------------===//
185// spirv.AtomicXorOp
186//===----------------------------------------------------------------------===//
187
188LogicalResult AtomicXorOp::verify() {
189 return verifyAtomicUpdateOp<AtomicXorOp, IntegerType>(op: getOperation());
190}
191
192} // namespace mlir::spirv
193