1 // Copyright (c) 2017 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Validates correctness of conversion instructions.
16
17 #include "source/opcode.h"
18 #include "source/spirv_constant.h"
19 #include "source/spirv_target_env.h"
20 #include "source/val/instruction.h"
21 #include "source/val/validate.h"
22 #include "source/val/validation_state.h"
23
24 namespace spvtools {
25 namespace val {
26
27 // Validates correctness of conversion instructions.
ConversionPass(ValidationState_t & _,const Instruction * inst)28 spv_result_t ConversionPass(ValidationState_t& _, const Instruction* inst) {
29 const spv::Op opcode = inst->opcode();
30 const uint32_t result_type = inst->type_id();
31
32 switch (opcode) {
33 case spv::Op::OpConvertFToU: {
34 if (!_.IsUnsignedIntScalarType(result_type) &&
35 !_.IsUnsignedIntVectorType(result_type) &&
36 !_.IsUnsignedIntCooperativeMatrixType(result_type))
37 return _.diag(SPV_ERROR_INVALID_DATA, inst)
38 << "Expected unsigned int scalar or vector type as Result Type: "
39 << spvOpcodeString(opcode);
40
41 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
42 if (!input_type || (!_.IsFloatScalarType(input_type) &&
43 !_.IsFloatVectorType(input_type) &&
44 !_.IsFloatCooperativeMatrixType(input_type)))
45 return _.diag(SPV_ERROR_INVALID_DATA, inst)
46 << "Expected input to be float scalar or vector: "
47 << spvOpcodeString(opcode);
48
49 if (_.IsCooperativeMatrixType(result_type) ||
50 _.IsCooperativeMatrixType(input_type)) {
51 spv_result_t ret =
52 _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true);
53 if (ret != SPV_SUCCESS) return ret;
54 } else {
55 if (_.GetDimension(result_type) != _.GetDimension(input_type))
56 return _.diag(SPV_ERROR_INVALID_DATA, inst)
57 << "Expected input to have the same dimension as Result Type: "
58 << spvOpcodeString(opcode);
59 }
60
61 break;
62 }
63
64 case spv::Op::OpConvertFToS: {
65 if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) &&
66 !_.IsIntCooperativeMatrixType(result_type))
67 return _.diag(SPV_ERROR_INVALID_DATA, inst)
68 << "Expected int scalar or vector type as Result Type: "
69 << spvOpcodeString(opcode);
70
71 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
72 if (!input_type || (!_.IsFloatScalarType(input_type) &&
73 !_.IsFloatVectorType(input_type) &&
74 !_.IsFloatCooperativeMatrixType(input_type)))
75 return _.diag(SPV_ERROR_INVALID_DATA, inst)
76 << "Expected input to be float scalar or vector: "
77 << spvOpcodeString(opcode);
78
79 if (_.IsCooperativeMatrixType(result_type) ||
80 _.IsCooperativeMatrixType(input_type)) {
81 spv_result_t ret =
82 _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true);
83 if (ret != SPV_SUCCESS) return ret;
84 } else {
85 if (_.GetDimension(result_type) != _.GetDimension(input_type))
86 return _.diag(SPV_ERROR_INVALID_DATA, inst)
87 << "Expected input to have the same dimension as Result Type: "
88 << spvOpcodeString(opcode);
89 }
90
91 break;
92 }
93
94 case spv::Op::OpConvertSToF:
95 case spv::Op::OpConvertUToF: {
96 if (!_.IsFloatScalarType(result_type) &&
97 !_.IsFloatVectorType(result_type) &&
98 !_.IsFloatCooperativeMatrixType(result_type))
99 return _.diag(SPV_ERROR_INVALID_DATA, inst)
100 << "Expected float scalar or vector type as Result Type: "
101 << spvOpcodeString(opcode);
102
103 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
104 if (!input_type ||
105 (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) &&
106 !_.IsIntCooperativeMatrixType(input_type)))
107 return _.diag(SPV_ERROR_INVALID_DATA, inst)
108 << "Expected input to be int scalar or vector: "
109 << spvOpcodeString(opcode);
110
111 if (_.IsCooperativeMatrixType(result_type) ||
112 _.IsCooperativeMatrixType(input_type)) {
113 spv_result_t ret =
114 _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true);
115 if (ret != SPV_SUCCESS) return ret;
116 } else {
117 if (_.GetDimension(result_type) != _.GetDimension(input_type))
118 return _.diag(SPV_ERROR_INVALID_DATA, inst)
119 << "Expected input to have the same dimension as Result Type: "
120 << spvOpcodeString(opcode);
121 }
122
123 break;
124 }
125
126 case spv::Op::OpUConvert: {
127 if (!_.IsUnsignedIntScalarType(result_type) &&
128 !_.IsUnsignedIntVectorType(result_type) &&
129 !_.IsUnsignedIntCooperativeMatrixType(result_type))
130 return _.diag(SPV_ERROR_INVALID_DATA, inst)
131 << "Expected unsigned int scalar or vector type as Result Type: "
132 << spvOpcodeString(opcode);
133
134 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
135 if (!input_type ||
136 (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) &&
137 !_.IsIntCooperativeMatrixType(input_type)))
138 return _.diag(SPV_ERROR_INVALID_DATA, inst)
139 << "Expected input to be int scalar or vector: "
140 << spvOpcodeString(opcode);
141
142 if (_.IsCooperativeMatrixType(result_type) ||
143 _.IsCooperativeMatrixType(input_type)) {
144 spv_result_t ret =
145 _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true);
146 if (ret != SPV_SUCCESS) return ret;
147 } else {
148 if (_.GetDimension(result_type) != _.GetDimension(input_type))
149 return _.diag(SPV_ERROR_INVALID_DATA, inst)
150 << "Expected input to have the same dimension as Result Type: "
151 << spvOpcodeString(opcode);
152 }
153
154 if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type))
155 return _.diag(SPV_ERROR_INVALID_DATA, inst)
156 << "Expected input to have different bit width from Result "
157 "Type: "
158 << spvOpcodeString(opcode);
159 break;
160 }
161
162 case spv::Op::OpSConvert: {
163 if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) &&
164 !_.IsIntCooperativeMatrixType(result_type))
165 return _.diag(SPV_ERROR_INVALID_DATA, inst)
166 << "Expected int scalar or vector type as Result Type: "
167 << spvOpcodeString(opcode);
168
169 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
170 if (!input_type ||
171 (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) &&
172 !_.IsIntCooperativeMatrixType(input_type)))
173 return _.diag(SPV_ERROR_INVALID_DATA, inst)
174 << "Expected input to be int scalar or vector: "
175 << spvOpcodeString(opcode);
176
177 if (_.IsCooperativeMatrixType(result_type) ||
178 _.IsCooperativeMatrixType(input_type)) {
179 spv_result_t ret =
180 _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true);
181 if (ret != SPV_SUCCESS) return ret;
182 } else {
183 if (_.GetDimension(result_type) != _.GetDimension(input_type))
184 return _.diag(SPV_ERROR_INVALID_DATA, inst)
185 << "Expected input to have the same dimension as Result Type: "
186 << spvOpcodeString(opcode);
187 }
188
189 if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type))
190 return _.diag(SPV_ERROR_INVALID_DATA, inst)
191 << "Expected input to have different bit width from Result "
192 "Type: "
193 << spvOpcodeString(opcode);
194 break;
195 }
196
197 case spv::Op::OpFConvert: {
198 if (!_.IsFloatScalarType(result_type) &&
199 !_.IsFloatVectorType(result_type) &&
200 !_.IsFloatCooperativeMatrixType(result_type))
201 return _.diag(SPV_ERROR_INVALID_DATA, inst)
202 << "Expected float scalar or vector type as Result Type: "
203 << spvOpcodeString(opcode);
204
205 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
206 if (!input_type || (!_.IsFloatScalarType(input_type) &&
207 !_.IsFloatVectorType(input_type) &&
208 !_.IsFloatCooperativeMatrixType(input_type)))
209 return _.diag(SPV_ERROR_INVALID_DATA, inst)
210 << "Expected input to be float scalar or vector: "
211 << spvOpcodeString(opcode);
212
213 if (_.IsCooperativeMatrixType(result_type) ||
214 _.IsCooperativeMatrixType(input_type)) {
215 spv_result_t ret =
216 _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true);
217 if (ret != SPV_SUCCESS) return ret;
218 } else {
219 if (_.GetDimension(result_type) != _.GetDimension(input_type))
220 return _.diag(SPV_ERROR_INVALID_DATA, inst)
221 << "Expected input to have the same dimension as Result Type: "
222 << spvOpcodeString(opcode);
223 }
224
225 if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type))
226 return _.diag(SPV_ERROR_INVALID_DATA, inst)
227 << "Expected input to have different bit width from Result "
228 "Type: "
229 << spvOpcodeString(opcode);
230 break;
231 }
232
233 case spv::Op::OpQuantizeToF16: {
234 if ((!_.IsFloatScalarType(result_type) &&
235 !_.IsFloatVectorType(result_type)) ||
236 _.GetBitWidth(result_type) != 32)
237 return _.diag(SPV_ERROR_INVALID_DATA, inst)
238 << "Expected 32-bit float scalar or vector type as Result Type: "
239 << spvOpcodeString(opcode);
240
241 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
242 if (input_type != result_type)
243 return _.diag(SPV_ERROR_INVALID_DATA, inst)
244 << "Expected input type to be equal to Result Type: "
245 << spvOpcodeString(opcode);
246 break;
247 }
248
249 case spv::Op::OpConvertPtrToU: {
250 if (!_.IsUnsignedIntScalarType(result_type))
251 return _.diag(SPV_ERROR_INVALID_DATA, inst)
252 << "Expected unsigned int scalar type as Result Type: "
253 << spvOpcodeString(opcode);
254
255 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
256 if (!_.IsPointerType(input_type))
257 return _.diag(SPV_ERROR_INVALID_DATA, inst)
258 << "Expected input to be a pointer: " << spvOpcodeString(opcode);
259
260 if (_.addressing_model() == spv::AddressingModel::Logical)
261 return _.diag(SPV_ERROR_INVALID_DATA, inst)
262 << "Logical addressing not supported: "
263 << spvOpcodeString(opcode);
264
265 if (_.addressing_model() ==
266 spv::AddressingModel::PhysicalStorageBuffer64) {
267 spv::StorageClass input_storage_class;
268 uint32_t input_data_type = 0;
269 _.GetPointerTypeInfo(input_type, &input_data_type,
270 &input_storage_class);
271 if (input_storage_class != spv::StorageClass::PhysicalStorageBuffer)
272 return _.diag(SPV_ERROR_INVALID_DATA, inst)
273 << "Pointer storage class must be PhysicalStorageBuffer: "
274 << spvOpcodeString(opcode);
275
276 if (spvIsVulkanEnv(_.context()->target_env)) {
277 if (_.GetBitWidth(result_type) != 64) {
278 return _.diag(SPV_ERROR_INVALID_DATA, inst)
279 << _.VkErrorID(4710)
280 << "PhysicalStorageBuffer64 addressing mode requires the "
281 "result integer type to have a 64-bit width for Vulkan "
282 "environment.";
283 }
284 }
285 }
286 break;
287 }
288
289 case spv::Op::OpSatConvertSToU:
290 case spv::Op::OpSatConvertUToS: {
291 if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type))
292 return _.diag(SPV_ERROR_INVALID_DATA, inst)
293 << "Expected int scalar or vector type as Result Type: "
294 << spvOpcodeString(opcode);
295
296 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
297 if (!input_type ||
298 (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type)))
299 return _.diag(SPV_ERROR_INVALID_DATA, inst)
300 << "Expected int scalar or vector as input: "
301 << spvOpcodeString(opcode);
302
303 if (_.GetDimension(result_type) != _.GetDimension(input_type))
304 return _.diag(SPV_ERROR_INVALID_DATA, inst)
305 << "Expected input to have the same dimension as Result Type: "
306 << spvOpcodeString(opcode);
307 break;
308 }
309
310 case spv::Op::OpConvertUToPtr: {
311 if (!_.IsPointerType(result_type))
312 return _.diag(SPV_ERROR_INVALID_DATA, inst)
313 << "Expected Result Type to be a pointer: "
314 << spvOpcodeString(opcode);
315
316 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
317 if (!input_type || !_.IsIntScalarType(input_type))
318 return _.diag(SPV_ERROR_INVALID_DATA, inst)
319 << "Expected int scalar as input: " << spvOpcodeString(opcode);
320
321 if (_.addressing_model() == spv::AddressingModel::Logical)
322 return _.diag(SPV_ERROR_INVALID_DATA, inst)
323 << "Logical addressing not supported: "
324 << spvOpcodeString(opcode);
325
326 if (_.addressing_model() ==
327 spv::AddressingModel::PhysicalStorageBuffer64) {
328 spv::StorageClass result_storage_class;
329 uint32_t result_data_type = 0;
330 _.GetPointerTypeInfo(result_type, &result_data_type,
331 &result_storage_class);
332 if (result_storage_class != spv::StorageClass::PhysicalStorageBuffer)
333 return _.diag(SPV_ERROR_INVALID_DATA, inst)
334 << "Pointer storage class must be PhysicalStorageBuffer: "
335 << spvOpcodeString(opcode);
336
337 if (spvIsVulkanEnv(_.context()->target_env)) {
338 if (_.GetBitWidth(input_type) != 64) {
339 return _.diag(SPV_ERROR_INVALID_DATA, inst)
340 << _.VkErrorID(4710)
341 << "PhysicalStorageBuffer64 addressing mode requires the "
342 "input integer to have a 64-bit width for Vulkan "
343 "environment.";
344 }
345 }
346 }
347 break;
348 }
349
350 case spv::Op::OpPtrCastToGeneric: {
351 spv::StorageClass result_storage_class;
352 uint32_t result_data_type = 0;
353 if (!_.GetPointerTypeInfo(result_type, &result_data_type,
354 &result_storage_class))
355 return _.diag(SPV_ERROR_INVALID_DATA, inst)
356 << "Expected Result Type to be a pointer: "
357 << spvOpcodeString(opcode);
358
359 if (result_storage_class != spv::StorageClass::Generic)
360 return _.diag(SPV_ERROR_INVALID_DATA, inst)
361 << "Expected Result Type to have storage class Generic: "
362 << spvOpcodeString(opcode);
363
364 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
365 spv::StorageClass input_storage_class;
366 uint32_t input_data_type = 0;
367 if (!_.GetPointerTypeInfo(input_type, &input_data_type,
368 &input_storage_class))
369 return _.diag(SPV_ERROR_INVALID_DATA, inst)
370 << "Expected input to be a pointer: " << spvOpcodeString(opcode);
371
372 if (input_storage_class != spv::StorageClass::Workgroup &&
373 input_storage_class != spv::StorageClass::CrossWorkgroup &&
374 input_storage_class != spv::StorageClass::Function)
375 return _.diag(SPV_ERROR_INVALID_DATA, inst)
376 << "Expected input to have storage class Workgroup, "
377 << "CrossWorkgroup or Function: " << spvOpcodeString(opcode);
378
379 if (result_data_type != input_data_type)
380 return _.diag(SPV_ERROR_INVALID_DATA, inst)
381 << "Expected input and Result Type to point to the same type: "
382 << spvOpcodeString(opcode);
383 break;
384 }
385
386 case spv::Op::OpGenericCastToPtr: {
387 spv::StorageClass result_storage_class;
388 uint32_t result_data_type = 0;
389 if (!_.GetPointerTypeInfo(result_type, &result_data_type,
390 &result_storage_class))
391 return _.diag(SPV_ERROR_INVALID_DATA, inst)
392 << "Expected Result Type to be a pointer: "
393 << spvOpcodeString(opcode);
394
395 if (result_storage_class != spv::StorageClass::Workgroup &&
396 result_storage_class != spv::StorageClass::CrossWorkgroup &&
397 result_storage_class != spv::StorageClass::Function)
398 return _.diag(SPV_ERROR_INVALID_DATA, inst)
399 << "Expected Result Type to have storage class Workgroup, "
400 << "CrossWorkgroup or Function: " << spvOpcodeString(opcode);
401
402 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
403 spv::StorageClass input_storage_class;
404 uint32_t input_data_type = 0;
405 if (!_.GetPointerTypeInfo(input_type, &input_data_type,
406 &input_storage_class))
407 return _.diag(SPV_ERROR_INVALID_DATA, inst)
408 << "Expected input to be a pointer: " << spvOpcodeString(opcode);
409
410 if (input_storage_class != spv::StorageClass::Generic)
411 return _.diag(SPV_ERROR_INVALID_DATA, inst)
412 << "Expected input to have storage class Generic: "
413 << spvOpcodeString(opcode);
414
415 if (result_data_type != input_data_type)
416 return _.diag(SPV_ERROR_INVALID_DATA, inst)
417 << "Expected input and Result Type to point to the same type: "
418 << spvOpcodeString(opcode);
419 break;
420 }
421
422 case spv::Op::OpGenericCastToPtrExplicit: {
423 spv::StorageClass result_storage_class;
424 uint32_t result_data_type = 0;
425 if (!_.GetPointerTypeInfo(result_type, &result_data_type,
426 &result_storage_class))
427 return _.diag(SPV_ERROR_INVALID_DATA, inst)
428 << "Expected Result Type to be a pointer: "
429 << spvOpcodeString(opcode);
430
431 const auto target_storage_class =
432 inst->GetOperandAs<spv::StorageClass>(3);
433 if (result_storage_class != target_storage_class)
434 return _.diag(SPV_ERROR_INVALID_DATA, inst)
435 << "Expected Result Type to be of target storage class: "
436 << spvOpcodeString(opcode);
437
438 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
439 spv::StorageClass input_storage_class;
440 uint32_t input_data_type = 0;
441 if (!_.GetPointerTypeInfo(input_type, &input_data_type,
442 &input_storage_class))
443 return _.diag(SPV_ERROR_INVALID_DATA, inst)
444 << "Expected input to be a pointer: " << spvOpcodeString(opcode);
445
446 if (input_storage_class != spv::StorageClass::Generic)
447 return _.diag(SPV_ERROR_INVALID_DATA, inst)
448 << "Expected input to have storage class Generic: "
449 << spvOpcodeString(opcode);
450
451 if (result_data_type != input_data_type)
452 return _.diag(SPV_ERROR_INVALID_DATA, inst)
453 << "Expected input and Result Type to point to the same type: "
454 << spvOpcodeString(opcode);
455
456 if (target_storage_class != spv::StorageClass::Workgroup &&
457 target_storage_class != spv::StorageClass::CrossWorkgroup &&
458 target_storage_class != spv::StorageClass::Function)
459 return _.diag(SPV_ERROR_INVALID_DATA, inst)
460 << "Expected target storage class to be Workgroup, "
461 << "CrossWorkgroup or Function: " << spvOpcodeString(opcode);
462 break;
463 }
464
465 case spv::Op::OpBitcast: {
466 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
467 if (!input_type)
468 return _.diag(SPV_ERROR_INVALID_DATA, inst)
469 << "Expected input to have a type: " << spvOpcodeString(opcode);
470
471 const bool result_is_pointer = _.IsPointerType(result_type);
472 const bool result_is_int_scalar = _.IsIntScalarType(result_type);
473 const bool input_is_pointer = _.IsPointerType(input_type);
474 const bool input_is_int_scalar = _.IsIntScalarType(input_type);
475
476 const bool result_is_coopmat = _.IsCooperativeMatrixType(result_type);
477 const bool input_is_coopmat = _.IsCooperativeMatrixType(input_type);
478
479 if (!result_is_pointer && !result_is_int_scalar && !result_is_coopmat &&
480 !_.IsIntVectorType(result_type) &&
481 !_.IsFloatScalarType(result_type) &&
482 !_.IsFloatVectorType(result_type))
483 return _.diag(SPV_ERROR_INVALID_DATA, inst)
484 << "Expected Result Type to be a pointer or int or float vector "
485 << "or scalar type: " << spvOpcodeString(opcode);
486
487 if (!input_is_pointer && !input_is_int_scalar && !input_is_coopmat &&
488 !_.IsIntVectorType(input_type) && !_.IsFloatScalarType(input_type) &&
489 !_.IsFloatVectorType(input_type))
490 return _.diag(SPV_ERROR_INVALID_DATA, inst)
491 << "Expected input to be a pointer or int or float vector "
492 << "or scalar: " << spvOpcodeString(opcode);
493
494 if (result_is_coopmat != input_is_coopmat)
495 return _.diag(SPV_ERROR_INVALID_DATA, inst)
496 << "Cooperative matrix can only be cast to another cooperative "
497 << "matrix: " << spvOpcodeString(opcode);
498
499 if (result_is_coopmat) {
500 spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type,
501 input_type, false);
502 if (ret != SPV_SUCCESS) return ret;
503 }
504
505 if (_.version() >= SPV_SPIRV_VERSION_WORD(1, 5) ||
506 _.HasExtension(kSPV_KHR_physical_storage_buffer)) {
507 const bool result_is_int_vector = _.IsIntVectorType(result_type);
508 const bool result_has_int32 =
509 _.ContainsSizedIntOrFloatType(result_type, spv::Op::OpTypeInt, 32);
510 const bool input_is_int_vector = _.IsIntVectorType(input_type);
511 const bool input_has_int32 =
512 _.ContainsSizedIntOrFloatType(input_type, spv::Op::OpTypeInt, 32);
513 if (result_is_pointer && !input_is_pointer && !input_is_int_scalar &&
514 !(input_is_int_vector && input_has_int32))
515 return _.diag(SPV_ERROR_INVALID_DATA, inst)
516 << "Expected input to be a pointer, int scalar or 32-bit int "
517 "vector if Result Type is pointer: "
518 << spvOpcodeString(opcode);
519
520 if (input_is_pointer && !result_is_pointer && !result_is_int_scalar &&
521 !(result_is_int_vector && result_has_int32))
522 return _.diag(SPV_ERROR_INVALID_DATA, inst)
523 << "Pointer can only be converted to another pointer, int "
524 "scalar or 32-bit int vector: "
525 << spvOpcodeString(opcode);
526 } else {
527 if (result_is_pointer && !input_is_pointer && !input_is_int_scalar)
528 return _.diag(SPV_ERROR_INVALID_DATA, inst)
529 << "Expected input to be a pointer or int scalar if Result "
530 "Type is pointer: "
531 << spvOpcodeString(opcode);
532
533 if (input_is_pointer && !result_is_pointer && !result_is_int_scalar)
534 return _.diag(SPV_ERROR_INVALID_DATA, inst)
535 << "Pointer can only be converted to another pointer or int "
536 "scalar: "
537 << spvOpcodeString(opcode);
538 }
539
540 if (!result_is_pointer && !input_is_pointer) {
541 const uint32_t result_size =
542 _.GetBitWidth(result_type) * _.GetDimension(result_type);
543 const uint32_t input_size =
544 _.GetBitWidth(input_type) * _.GetDimension(input_type);
545 if (result_size != input_size)
546 return _.diag(SPV_ERROR_INVALID_DATA, inst)
547 << "Expected input to have the same total bit width as "
548 << "Result Type: " << spvOpcodeString(opcode);
549 }
550 break;
551 }
552
553 case spv::Op::OpConvertUToAccelerationStructureKHR: {
554 if (!_.IsAccelerationStructureType(result_type)) {
555 return _.diag(SPV_ERROR_INVALID_DATA, inst)
556 << "Expected Result Type to be a Acceleration Structure: "
557 << spvOpcodeString(opcode);
558 }
559
560 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
561 if (!input_type || !_.IsUnsigned64BitHandle(input_type)) {
562 return _.diag(SPV_ERROR_INVALID_DATA, inst)
563 << "Expected 64-bit uint scalar or 2-component 32-bit uint "
564 "vector as input: "
565 << spvOpcodeString(opcode);
566 }
567
568 break;
569 }
570
571 case spv::Op::OpCooperativeMatrixConvertNV:
572 case spv::Op::OpCooperativeMatrixTransposeNV: {
573 if (!_.IsCooperativeMatrixType(result_type)) {
574 return _.diag(SPV_ERROR_INVALID_DATA, inst)
575 << "Expected cooperative matrix Result Type: "
576 << spvOpcodeString(opcode);
577 }
578 const uint32_t input_type = _.GetOperandTypeId(inst, 2);
579 if (!_.IsCooperativeMatrixType(input_type)) {
580 return _.diag(SPV_ERROR_INVALID_DATA, inst)
581 << "Expected cooperative matrix type for Matrix input: "
582 << spvOpcodeString(opcode);
583 }
584
585 bool swap_row_col = (opcode == spv::Op::OpCooperativeMatrixTransposeNV);
586 if (auto error = _.CooperativeMatrixShapesMatch(
587 inst, result_type, input_type, true, swap_row_col))
588 return error;
589
590 if (opcode == spv::Op::OpCooperativeMatrixConvertNV) {
591 if (_.FindDef(result_type)->GetOperandAs<uint32_t>(1) !=
592 _.FindDef(input_type)->GetOperandAs<uint32_t>(1)) {
593 return _.diag(SPV_ERROR_INVALID_DATA, inst)
594 << "Result Type and Matrix component types mismatch: "
595 << spvOpcodeString(opcode);
596 }
597 }
598
599 if (opcode == spv::Op::OpCooperativeMatrixTransposeNV) {
600 if (!_.IsCooperativeMatrixBType(result_type)) {
601 return _.diag(SPV_ERROR_INVALID_DATA, inst)
602 << "Result Type must have UseB: " << spvOpcodeString(opcode);
603 }
604 }
605 break;
606 }
607
608 default:
609 break;
610 }
611
612 if (_.HasCapability(spv::Capability::Shader)) {
613 switch (inst->opcode()) {
614 case spv::Op::OpConvertFToU:
615 case spv::Op::OpConvertFToS:
616 case spv::Op::OpConvertSToF:
617 case spv::Op::OpConvertUToF:
618 case spv::Op::OpBitcast:
619 if (_.ContainsLimitedUseIntOrFloatType(inst->type_id()) ||
620 _.ContainsLimitedUseIntOrFloatType(_.GetOperandTypeId(inst, 2u))) {
621 return _.diag(SPV_ERROR_INVALID_DATA, inst)
622 << "8- or 16-bit types can only be used with width-only "
623 "conversions";
624 }
625 break;
626 default:
627 break;
628 }
629 }
630
631 return SPV_SUCCESS;
632 }
633
634 } // namespace val
635 } // namespace spvtools
636