1 // Copyright (c) 2017 Google Inc.
2 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights
3 // reserved.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16
17 // Validates correctness of atomic SPIR-V instructions.
18
19 #include "source/opcode.h"
20 #include "source/spirv_target_env.h"
21 #include "source/util/bitutils.h"
22 #include "source/val/instruction.h"
23 #include "source/val/validate.h"
24 #include "source/val/validate_memory_semantics.h"
25 #include "source/val/validate_scopes.h"
26 #include "source/val/validation_state.h"
27
28 namespace {
29
IsStorageClassAllowedByUniversalRules(spv::StorageClass storage_class)30 bool IsStorageClassAllowedByUniversalRules(spv::StorageClass storage_class) {
31 switch (storage_class) {
32 case spv::StorageClass::Uniform:
33 case spv::StorageClass::StorageBuffer:
34 case spv::StorageClass::Workgroup:
35 case spv::StorageClass::CrossWorkgroup:
36 case spv::StorageClass::Generic:
37 case spv::StorageClass::AtomicCounter:
38 case spv::StorageClass::Image:
39 case spv::StorageClass::Function:
40 case spv::StorageClass::PhysicalStorageBuffer:
41 case spv::StorageClass::TaskPayloadWorkgroupEXT:
42 return true;
43 break;
44 default:
45 return false;
46 }
47 }
48
HasReturnType(spv::Op opcode)49 bool HasReturnType(spv::Op opcode) {
50 switch (opcode) {
51 case spv::Op::OpAtomicStore:
52 case spv::Op::OpAtomicFlagClear:
53 return false;
54 break;
55 default:
56 return true;
57 }
58 }
59
HasOnlyFloatReturnType(spv::Op opcode)60 bool HasOnlyFloatReturnType(spv::Op opcode) {
61 switch (opcode) {
62 case spv::Op::OpAtomicFAddEXT:
63 case spv::Op::OpAtomicFMinEXT:
64 case spv::Op::OpAtomicFMaxEXT:
65 return true;
66 break;
67 default:
68 return false;
69 }
70 }
71
HasOnlyIntReturnType(spv::Op opcode)72 bool HasOnlyIntReturnType(spv::Op opcode) {
73 switch (opcode) {
74 case spv::Op::OpAtomicCompareExchange:
75 case spv::Op::OpAtomicCompareExchangeWeak:
76 case spv::Op::OpAtomicIIncrement:
77 case spv::Op::OpAtomicIDecrement:
78 case spv::Op::OpAtomicIAdd:
79 case spv::Op::OpAtomicISub:
80 case spv::Op::OpAtomicSMin:
81 case spv::Op::OpAtomicUMin:
82 case spv::Op::OpAtomicSMax:
83 case spv::Op::OpAtomicUMax:
84 case spv::Op::OpAtomicAnd:
85 case spv::Op::OpAtomicOr:
86 case spv::Op::OpAtomicXor:
87 return true;
88 break;
89 default:
90 return false;
91 }
92 }
93
HasIntOrFloatReturnType(spv::Op opcode)94 bool HasIntOrFloatReturnType(spv::Op opcode) {
95 switch (opcode) {
96 case spv::Op::OpAtomicLoad:
97 case spv::Op::OpAtomicExchange:
98 return true;
99 break;
100 default:
101 return false;
102 }
103 }
104
HasOnlyBoolReturnType(spv::Op opcode)105 bool HasOnlyBoolReturnType(spv::Op opcode) {
106 switch (opcode) {
107 case spv::Op::OpAtomicFlagTestAndSet:
108 return true;
109 break;
110 default:
111 return false;
112 }
113 }
114
115 } // namespace
116
117 namespace spvtools {
118 namespace val {
119
120 // Validates correctness of atomic instructions.
AtomicsPass(ValidationState_t & _,const Instruction * inst)121 spv_result_t AtomicsPass(ValidationState_t& _, const Instruction* inst) {
122 const spv::Op opcode = inst->opcode();
123 switch (opcode) {
124 case spv::Op::OpAtomicLoad:
125 case spv::Op::OpAtomicStore:
126 case spv::Op::OpAtomicExchange:
127 case spv::Op::OpAtomicFAddEXT:
128 case spv::Op::OpAtomicCompareExchange:
129 case spv::Op::OpAtomicCompareExchangeWeak:
130 case spv::Op::OpAtomicIIncrement:
131 case spv::Op::OpAtomicIDecrement:
132 case spv::Op::OpAtomicIAdd:
133 case spv::Op::OpAtomicISub:
134 case spv::Op::OpAtomicSMin:
135 case spv::Op::OpAtomicUMin:
136 case spv::Op::OpAtomicFMinEXT:
137 case spv::Op::OpAtomicSMax:
138 case spv::Op::OpAtomicUMax:
139 case spv::Op::OpAtomicFMaxEXT:
140 case spv::Op::OpAtomicAnd:
141 case spv::Op::OpAtomicOr:
142 case spv::Op::OpAtomicXor:
143 case spv::Op::OpAtomicFlagTestAndSet:
144 case spv::Op::OpAtomicFlagClear: {
145 const uint32_t result_type = inst->type_id();
146
147 // Validate return type first so can just check if pointer type is same
148 // (if applicable)
149 if (HasReturnType(opcode)) {
150 if (HasOnlyFloatReturnType(opcode) &&
151 (!(_.HasCapability(spv::Capability::AtomicFloat16VectorNV) &&
152 _.IsFloat16Vector2Or4Type(result_type)) &&
153 !_.IsFloatScalarType(result_type))) {
154 return _.diag(SPV_ERROR_INVALID_DATA, inst)
155 << spvOpcodeString(opcode)
156 << ": expected Result Type to be float scalar type";
157 } else if (HasOnlyIntReturnType(opcode) &&
158 !_.IsIntScalarType(result_type)) {
159 return _.diag(SPV_ERROR_INVALID_DATA, inst)
160 << spvOpcodeString(opcode)
161 << ": expected Result Type to be integer scalar type";
162 } else if (HasIntOrFloatReturnType(opcode) &&
163 !_.IsFloatScalarType(result_type) &&
164 !(opcode == spv::Op::OpAtomicExchange &&
165 _.HasCapability(spv::Capability::AtomicFloat16VectorNV) &&
166 _.IsFloat16Vector2Or4Type(result_type)) &&
167 !_.IsIntScalarType(result_type)) {
168 return _.diag(SPV_ERROR_INVALID_DATA, inst)
169 << spvOpcodeString(opcode)
170 << ": expected Result Type to be integer or float scalar type";
171 } else if (HasOnlyBoolReturnType(opcode) &&
172 !_.IsBoolScalarType(result_type)) {
173 return _.diag(SPV_ERROR_INVALID_DATA, inst)
174 << spvOpcodeString(opcode)
175 << ": expected Result Type to be bool scalar type";
176 }
177 }
178
179 uint32_t operand_index = HasReturnType(opcode) ? 2 : 0;
180 const uint32_t pointer_type = _.GetOperandTypeId(inst, operand_index++);
181 uint32_t data_type = 0;
182 spv::StorageClass storage_class;
183 if (!_.GetPointerTypeInfo(pointer_type, &data_type, &storage_class)) {
184 return _.diag(SPV_ERROR_INVALID_DATA, inst)
185 << spvOpcodeString(opcode)
186 << ": expected Pointer to be of type OpTypePointer";
187 }
188
189 // Can't use result_type because OpAtomicStore doesn't have a result
190 if (_.IsIntScalarType(data_type) && _.GetBitWidth(data_type) == 64 &&
191 !_.HasCapability(spv::Capability::Int64Atomics)) {
192 return _.diag(SPV_ERROR_INVALID_DATA, inst)
193 << spvOpcodeString(opcode)
194 << ": 64-bit atomics require the Int64Atomics capability";
195 }
196
197 // Validate storage class against universal rules
198 if (!IsStorageClassAllowedByUniversalRules(storage_class)) {
199 return _.diag(SPV_ERROR_INVALID_DATA, inst)
200 << spvOpcodeString(opcode)
201 << ": storage class forbidden by universal validation rules.";
202 }
203
204 // Then Shader rules
205 if (_.HasCapability(spv::Capability::Shader)) {
206 // Vulkan environment rule
207 if (spvIsVulkanEnv(_.context()->target_env)) {
208 if ((storage_class != spv::StorageClass::Uniform) &&
209 (storage_class != spv::StorageClass::StorageBuffer) &&
210 (storage_class != spv::StorageClass::Workgroup) &&
211 (storage_class != spv::StorageClass::Image) &&
212 (storage_class != spv::StorageClass::PhysicalStorageBuffer) &&
213 (storage_class != spv::StorageClass::TaskPayloadWorkgroupEXT)) {
214 return _.diag(SPV_ERROR_INVALID_DATA, inst)
215 << _.VkErrorID(4686) << spvOpcodeString(opcode)
216 << ": Vulkan spec only allows storage classes for atomic to "
217 "be: Uniform, Workgroup, Image, StorageBuffer, "
218 "PhysicalStorageBuffer or TaskPayloadWorkgroupEXT.";
219 }
220 } else if (storage_class == spv::StorageClass::Function) {
221 return _.diag(SPV_ERROR_INVALID_DATA, inst)
222 << spvOpcodeString(opcode)
223 << ": Function storage class forbidden when the Shader "
224 "capability is declared.";
225 }
226
227 if (opcode == spv::Op::OpAtomicFAddEXT) {
228 // result type being float checked already
229 if (_.GetBitWidth(result_type) == 16) {
230 if (_.IsFloat16Vector2Or4Type(result_type)) {
231 if (!_.HasCapability(spv::Capability::AtomicFloat16VectorNV))
232 return _.diag(SPV_ERROR_INVALID_DATA, inst)
233 << spvOpcodeString(opcode)
234 << ": float vector atomics require the "
235 "AtomicFloat16VectorNV capability";
236 } else {
237 if (!_.HasCapability(spv::Capability::AtomicFloat16AddEXT)) {
238 return _.diag(SPV_ERROR_INVALID_DATA, inst)
239 << spvOpcodeString(opcode)
240 << ": float add atomics require the AtomicFloat32AddEXT "
241 "capability";
242 }
243 }
244 }
245 if ((_.GetBitWidth(result_type) == 32) &&
246 (!_.HasCapability(spv::Capability::AtomicFloat32AddEXT))) {
247 return _.diag(SPV_ERROR_INVALID_DATA, inst)
248 << spvOpcodeString(opcode)
249 << ": float add atomics require the AtomicFloat32AddEXT "
250 "capability";
251 }
252 if ((_.GetBitWidth(result_type) == 64) &&
253 (!_.HasCapability(spv::Capability::AtomicFloat64AddEXT))) {
254 return _.diag(SPV_ERROR_INVALID_DATA, inst)
255 << spvOpcodeString(opcode)
256 << ": float add atomics require the AtomicFloat64AddEXT "
257 "capability";
258 }
259 } else if (opcode == spv::Op::OpAtomicFMinEXT ||
260 opcode == spv::Op::OpAtomicFMaxEXT) {
261 if (_.GetBitWidth(result_type) == 16) {
262 if (_.IsFloat16Vector2Or4Type(result_type)) {
263 if (!_.HasCapability(spv::Capability::AtomicFloat16VectorNV))
264 return _.diag(SPV_ERROR_INVALID_DATA, inst)
265 << spvOpcodeString(opcode)
266 << ": float vector atomics require the "
267 "AtomicFloat16VectorNV capability";
268 } else {
269 if (!_.HasCapability(spv::Capability::AtomicFloat16MinMaxEXT)) {
270 return _.diag(SPV_ERROR_INVALID_DATA, inst)
271 << spvOpcodeString(opcode)
272 << ": float min/max atomics require the "
273 "AtomicFloat16MinMaxEXT capability";
274 }
275 }
276 }
277 if ((_.GetBitWidth(result_type) == 32) &&
278 (!_.HasCapability(spv::Capability::AtomicFloat32MinMaxEXT))) {
279 return _.diag(SPV_ERROR_INVALID_DATA, inst)
280 << spvOpcodeString(opcode)
281 << ": float min/max atomics require the "
282 "AtomicFloat32MinMaxEXT capability";
283 }
284 if ((_.GetBitWidth(result_type) == 64) &&
285 (!_.HasCapability(spv::Capability::AtomicFloat64MinMaxEXT))) {
286 return _.diag(SPV_ERROR_INVALID_DATA, inst)
287 << spvOpcodeString(opcode)
288 << ": float min/max atomics require the "
289 "AtomicFloat64MinMaxEXT capability";
290 }
291 }
292 }
293
294 // And finally OpenCL environment rules
295 if (spvIsOpenCLEnv(_.context()->target_env)) {
296 if ((storage_class != spv::StorageClass::Function) &&
297 (storage_class != spv::StorageClass::Workgroup) &&
298 (storage_class != spv::StorageClass::CrossWorkgroup) &&
299 (storage_class != spv::StorageClass::Generic)) {
300 return _.diag(SPV_ERROR_INVALID_DATA, inst)
301 << spvOpcodeString(opcode)
302 << ": storage class must be Function, Workgroup, "
303 "CrossWorkGroup or Generic in the OpenCL environment.";
304 }
305
306 if (_.context()->target_env == SPV_ENV_OPENCL_1_2) {
307 if (storage_class == spv::StorageClass::Generic) {
308 return _.diag(SPV_ERROR_INVALID_DATA, inst)
309 << "Storage class cannot be Generic in OpenCL 1.2 "
310 "environment";
311 }
312 }
313 }
314
315 // If result and pointer type are different, need to do special check here
316 if (opcode == spv::Op::OpAtomicFlagTestAndSet ||
317 opcode == spv::Op::OpAtomicFlagClear) {
318 if (!_.IsIntScalarType(data_type) || _.GetBitWidth(data_type) != 32) {
319 return _.diag(SPV_ERROR_INVALID_DATA, inst)
320 << spvOpcodeString(opcode)
321 << ": expected Pointer to point to a value of 32-bit integer "
322 "type";
323 }
324 } else if (opcode == spv::Op::OpAtomicStore) {
325 if (!_.IsFloatScalarType(data_type) && !_.IsIntScalarType(data_type)) {
326 return _.diag(SPV_ERROR_INVALID_DATA, inst)
327 << spvOpcodeString(opcode)
328 << ": expected Pointer to be a pointer to integer or float "
329 << "scalar type";
330 }
331 } else if (data_type != result_type) {
332 return _.diag(SPV_ERROR_INVALID_DATA, inst)
333 << spvOpcodeString(opcode)
334 << ": expected Pointer to point to a value of type Result "
335 "Type";
336 }
337
338 auto memory_scope = inst->GetOperandAs<const uint32_t>(operand_index++);
339 if (auto error = ValidateMemoryScope(_, inst, memory_scope)) {
340 return error;
341 }
342
343 const auto equal_semantics_index = operand_index++;
344 if (auto error = ValidateMemorySemantics(_, inst, equal_semantics_index,
345 memory_scope))
346 return error;
347
348 if (opcode == spv::Op::OpAtomicCompareExchange ||
349 opcode == spv::Op::OpAtomicCompareExchangeWeak) {
350 const auto unequal_semantics_index = operand_index++;
351 if (auto error = ValidateMemorySemantics(
352 _, inst, unequal_semantics_index, memory_scope))
353 return error;
354
355 // Volatile bits must match for equal and unequal semantics. Previous
356 // checks guarantee they are 32-bit constants, but we need to recheck
357 // whether they are evaluatable constants.
358 bool is_int32 = false;
359 bool is_equal_const = false;
360 bool is_unequal_const = false;
361 uint32_t equal_value = 0;
362 uint32_t unequal_value = 0;
363 std::tie(is_int32, is_equal_const, equal_value) = _.EvalInt32IfConst(
364 inst->GetOperandAs<uint32_t>(equal_semantics_index));
365 std::tie(is_int32, is_unequal_const, unequal_value) =
366 _.EvalInt32IfConst(
367 inst->GetOperandAs<uint32_t>(unequal_semantics_index));
368 if (is_equal_const && is_unequal_const &&
369 ((equal_value & uint32_t(spv::MemorySemanticsMask::Volatile)) ^
370 (unequal_value & uint32_t(spv::MemorySemanticsMask::Volatile)))) {
371 return _.diag(SPV_ERROR_INVALID_ID, inst)
372 << "Volatile mask setting must match for Equal and Unequal "
373 "memory semantics";
374 }
375 }
376
377 if (opcode == spv::Op::OpAtomicStore) {
378 const uint32_t value_type = _.GetOperandTypeId(inst, 3);
379 if (value_type != data_type) {
380 return _.diag(SPV_ERROR_INVALID_DATA, inst)
381 << spvOpcodeString(opcode)
382 << ": expected Value type and the type pointed to by "
383 "Pointer to be the same";
384 }
385 } else if (opcode != spv::Op::OpAtomicLoad &&
386 opcode != spv::Op::OpAtomicIIncrement &&
387 opcode != spv::Op::OpAtomicIDecrement &&
388 opcode != spv::Op::OpAtomicFlagTestAndSet &&
389 opcode != spv::Op::OpAtomicFlagClear) {
390 const uint32_t value_type = _.GetOperandTypeId(inst, operand_index++);
391 if (value_type != result_type) {
392 return _.diag(SPV_ERROR_INVALID_DATA, inst)
393 << spvOpcodeString(opcode)
394 << ": expected Value to be of type Result Type";
395 }
396 }
397
398 if (opcode == spv::Op::OpAtomicCompareExchange ||
399 opcode == spv::Op::OpAtomicCompareExchangeWeak) {
400 const uint32_t comparator_type =
401 _.GetOperandTypeId(inst, operand_index++);
402 if (comparator_type != result_type) {
403 return _.diag(SPV_ERROR_INVALID_DATA, inst)
404 << spvOpcodeString(opcode)
405 << ": expected Comparator to be of type Result Type";
406 }
407 }
408
409 break;
410 }
411
412 default:
413 break;
414 }
415
416 return SPV_SUCCESS;
417 }
418
419 } // namespace val
420 } // namespace spvtools
421