1//===- GroupOps.cpp - MLIR SPIR-V Group 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 group operations in the SPIR-V dialect.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
14#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
15
16#include "SPIRVOpUtils.h"
17#include "SPIRVParsingUtils.h"
18
19using namespace mlir::spirv::AttrNames;
20
21namespace mlir::spirv {
22
23template <typename OpTy>
24static LogicalResult verifyGroupNonUniformArithmeticOp(Operation *groupOp) {
25 GroupOperation operation = cast<OpTy>(groupOp).getGroupOperation();
26 if (operation == GroupOperation::ClusteredReduce &&
27 groupOp->getNumOperands() == 1)
28 return groupOp->emitOpError(message: "cluster size operand must be provided for "
29 "'ClusteredReduce' group operation");
30 return success();
31}
32
33//===----------------------------------------------------------------------===//
34// spirv.GroupBroadcast
35//===----------------------------------------------------------------------===//
36
37LogicalResult GroupBroadcastOp::verify() {
38 if (auto localIdTy = dyn_cast<VectorType>(Val: getLocalid().getType()))
39 if (localIdTy.getNumElements() != 2 && localIdTy.getNumElements() != 3)
40 return emitOpError(message: "localid is a vector and can be with only "
41 " 2 or 3 components, actual number is ")
42 << localIdTy.getNumElements();
43
44 return success();
45}
46
47//===----------------------------------------------------------------------===//
48// spirv.GroupNonUniformBroadcast
49//===----------------------------------------------------------------------===//
50
51LogicalResult GroupNonUniformBroadcastOp::verify() {
52 // SPIR-V spec: "Before version 1.5, Id must come from a
53 // constant instruction.
54 auto targetEnv = spirv::getDefaultTargetEnv(context: getContext());
55 if (auto spirvModule = (*this)->getParentOfType<spirv::ModuleOp>())
56 targetEnv = spirv::lookupTargetEnvOrDefault(op: spirvModule);
57
58 if (targetEnv.getVersion() < spirv::Version::V_1_5) {
59 auto *idOp = getId().getDefiningOp();
60 if (!idOp || !isa<spirv::ConstantOp, // for normal constant
61 spirv::ReferenceOfOp>(Val: idOp)) // for spec constant
62 return emitOpError(message: "id must be the result of a constant op");
63 }
64
65 return success();
66}
67
68//===----------------------------------------------------------------------===//
69// spirv.GroupNonUniformShuffle*
70//===----------------------------------------------------------------------===//
71
72template <typename OpTy>
73static LogicalResult verifyGroupNonUniformShuffleOp(OpTy op) {
74 if (op.getOperands().back().getType().isSignedInteger())
75 return op.emitOpError("second operand must be a singless/unsigned integer");
76
77 return success();
78}
79
80LogicalResult GroupNonUniformShuffleOp::verify() {
81 return verifyGroupNonUniformShuffleOp(op: *this);
82}
83LogicalResult GroupNonUniformShuffleDownOp::verify() {
84 return verifyGroupNonUniformShuffleOp(op: *this);
85}
86LogicalResult GroupNonUniformShuffleUpOp::verify() {
87 return verifyGroupNonUniformShuffleOp(op: *this);
88}
89LogicalResult GroupNonUniformShuffleXorOp::verify() {
90 return verifyGroupNonUniformShuffleOp(op: *this);
91}
92
93//===----------------------------------------------------------------------===//
94// spirv.GroupNonUniformFAddOp
95//===----------------------------------------------------------------------===//
96
97LogicalResult GroupNonUniformFAddOp::verify() {
98 return verifyGroupNonUniformArithmeticOp<GroupNonUniformFAddOp>(groupOp: *this);
99}
100
101//===----------------------------------------------------------------------===//
102// spirv.GroupNonUniformFMaxOp
103//===----------------------------------------------------------------------===//
104
105LogicalResult GroupNonUniformFMaxOp::verify() {
106 return verifyGroupNonUniformArithmeticOp<GroupNonUniformFMaxOp>(groupOp: *this);
107}
108
109//===----------------------------------------------------------------------===//
110// spirv.GroupNonUniformFMinOp
111//===----------------------------------------------------------------------===//
112
113LogicalResult GroupNonUniformFMinOp::verify() {
114 return verifyGroupNonUniformArithmeticOp<GroupNonUniformFMinOp>(groupOp: *this);
115}
116
117//===----------------------------------------------------------------------===//
118// spirv.GroupNonUniformFMulOp
119//===----------------------------------------------------------------------===//
120
121LogicalResult GroupNonUniformFMulOp::verify() {
122 return verifyGroupNonUniformArithmeticOp<GroupNonUniformFMulOp>(groupOp: *this);
123}
124
125//===----------------------------------------------------------------------===//
126// spirv.GroupNonUniformIAddOp
127//===----------------------------------------------------------------------===//
128
129LogicalResult GroupNonUniformIAddOp::verify() {
130 return verifyGroupNonUniformArithmeticOp<GroupNonUniformIAddOp>(groupOp: *this);
131}
132
133//===----------------------------------------------------------------------===//
134// spirv.GroupNonUniformIMulOp
135//===----------------------------------------------------------------------===//
136
137LogicalResult GroupNonUniformIMulOp::verify() {
138 return verifyGroupNonUniformArithmeticOp<GroupNonUniformIMulOp>(groupOp: *this);
139}
140
141//===----------------------------------------------------------------------===//
142// spirv.GroupNonUniformSMaxOp
143//===----------------------------------------------------------------------===//
144
145LogicalResult GroupNonUniformSMaxOp::verify() {
146 return verifyGroupNonUniformArithmeticOp<GroupNonUniformSMaxOp>(groupOp: *this);
147}
148
149//===----------------------------------------------------------------------===//
150// spirv.GroupNonUniformSMinOp
151//===----------------------------------------------------------------------===//
152
153LogicalResult GroupNonUniformSMinOp::verify() {
154 return verifyGroupNonUniformArithmeticOp<GroupNonUniformSMinOp>(groupOp: *this);
155}
156
157//===----------------------------------------------------------------------===//
158// spirv.GroupNonUniformUMaxOp
159//===----------------------------------------------------------------------===//
160
161LogicalResult GroupNonUniformUMaxOp::verify() {
162 return verifyGroupNonUniformArithmeticOp<GroupNonUniformUMaxOp>(groupOp: *this);
163}
164
165//===----------------------------------------------------------------------===//
166// spirv.GroupNonUniformUMinOp
167//===----------------------------------------------------------------------===//
168
169LogicalResult GroupNonUniformUMinOp::verify() {
170 return verifyGroupNonUniformArithmeticOp<GroupNonUniformUMinOp>(groupOp: *this);
171}
172
173//===----------------------------------------------------------------------===//
174// spirv.GroupNonUniformBitwiseAnd
175//===----------------------------------------------------------------------===//
176
177LogicalResult GroupNonUniformBitwiseAndOp::verify() {
178 return verifyGroupNonUniformArithmeticOp<GroupNonUniformBitwiseAndOp>(groupOp: *this);
179}
180
181//===----------------------------------------------------------------------===//
182// spirv.GroupNonUniformBitwiseOr
183//===----------------------------------------------------------------------===//
184
185LogicalResult GroupNonUniformBitwiseOrOp::verify() {
186 return verifyGroupNonUniformArithmeticOp<GroupNonUniformBitwiseOrOp>(groupOp: *this);
187}
188
189//===----------------------------------------------------------------------===//
190// spirv.GroupNonUniformBitwiseXor
191//===----------------------------------------------------------------------===//
192
193LogicalResult GroupNonUniformBitwiseXorOp::verify() {
194 return verifyGroupNonUniformArithmeticOp<GroupNonUniformBitwiseXorOp>(groupOp: *this);
195}
196
197//===----------------------------------------------------------------------===//
198// spirv.GroupNonUniformLogicalAnd
199//===----------------------------------------------------------------------===//
200
201LogicalResult GroupNonUniformLogicalAndOp::verify() {
202 return verifyGroupNonUniformArithmeticOp<GroupNonUniformLogicalAndOp>(groupOp: *this);
203}
204
205//===----------------------------------------------------------------------===//
206// spirv.GroupNonUniformLogicalOr
207//===----------------------------------------------------------------------===//
208
209LogicalResult GroupNonUniformLogicalOrOp::verify() {
210 return verifyGroupNonUniformArithmeticOp<GroupNonUniformLogicalOrOp>(groupOp: *this);
211}
212
213//===----------------------------------------------------------------------===//
214// spirv.GroupNonUniformLogicalXor
215//===----------------------------------------------------------------------===//
216
217LogicalResult GroupNonUniformLogicalXorOp::verify() {
218 return verifyGroupNonUniformArithmeticOp<GroupNonUniformLogicalXorOp>(groupOp: *this);
219}
220
221} // namespace mlir::spirv
222