xref: /aosp_15_r20/external/angle/third_party/spirv-tools/src/source/val/validate_annotation.cpp (revision 8975f5c5ed3d1c378011245431ada316dfb6f244) 
1 // Copyright (c) 2018 Google LLC.
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 #include "source/opcode.h"
16 #include "source/spirv_target_env.h"
17 #include "source/val/instruction.h"
18 #include "source/val/validate.h"
19 #include "source/val/validation_state.h"
20 
21 namespace spvtools {
22 namespace val {
23 namespace {
24 
25 // Returns true if the decoration takes ID parameters.
26 // TODO(dneto): This can be generated from the grammar.
DecorationTakesIdParameters(spv::Decoration type)27 bool DecorationTakesIdParameters(spv::Decoration type) {
28   switch (type) {
29     case spv::Decoration::UniformId:
30     case spv::Decoration::AlignmentId:
31     case spv::Decoration::MaxByteOffsetId:
32     case spv::Decoration::HlslCounterBufferGOOGLE:
33       return true;
34     default:
35       break;
36   }
37   return false;
38 }
39 
IsMemberDecorationOnly(spv::Decoration dec)40 bool IsMemberDecorationOnly(spv::Decoration dec) {
41   switch (dec) {
42     case spv::Decoration::RowMajor:
43     case spv::Decoration::ColMajor:
44     case spv::Decoration::MatrixStride:
45       // SPIR-V spec bug? Offset is generated on variables when dealing with
46       // transform feedback.
47       // case spv::Decoration::Offset:
48       return true;
49     default:
50       break;
51   }
52   return false;
53 }
54 
IsNotMemberDecoration(spv::Decoration dec)55 bool IsNotMemberDecoration(spv::Decoration dec) {
56   switch (dec) {
57     case spv::Decoration::SpecId:
58     case spv::Decoration::Block:
59     case spv::Decoration::BufferBlock:
60     case spv::Decoration::ArrayStride:
61     case spv::Decoration::GLSLShared:
62     case spv::Decoration::GLSLPacked:
63     case spv::Decoration::CPacked:
64     // TODO: https://github.com/KhronosGroup/glslang/issues/703:
65     // glslang applies Restrict to structure members.
66     // case spv::Decoration::Restrict:
67     case spv::Decoration::Aliased:
68     case spv::Decoration::Constant:
69     case spv::Decoration::Uniform:
70     case spv::Decoration::UniformId:
71     case spv::Decoration::SaturatedConversion:
72     case spv::Decoration::Index:
73     case spv::Decoration::Binding:
74     case spv::Decoration::DescriptorSet:
75     case spv::Decoration::FuncParamAttr:
76     case spv::Decoration::FPRoundingMode:
77     case spv::Decoration::FPFastMathMode:
78     case spv::Decoration::LinkageAttributes:
79     case spv::Decoration::NoContraction:
80     case spv::Decoration::InputAttachmentIndex:
81     case spv::Decoration::Alignment:
82     case spv::Decoration::MaxByteOffset:
83     case spv::Decoration::AlignmentId:
84     case spv::Decoration::MaxByteOffsetId:
85     case spv::Decoration::NoSignedWrap:
86     case spv::Decoration::NoUnsignedWrap:
87     case spv::Decoration::NonUniform:
88     case spv::Decoration::RestrictPointer:
89     case spv::Decoration::AliasedPointer:
90     case spv::Decoration::CounterBuffer:
91       return true;
92     default:
93       break;
94   }
95   return false;
96 }
97 
ValidateDecorationTarget(ValidationState_t & _,spv::Decoration dec,const Instruction * inst,const Instruction * target)98 spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
99                                       const Instruction* inst,
100                                       const Instruction* target) {
101   auto fail = [&_, dec, inst, target](uint32_t vuid) -> DiagnosticStream {
102     DiagnosticStream ds = std::move(
103         _.diag(SPV_ERROR_INVALID_ID, inst)
104         << _.VkErrorID(vuid) << _.SpvDecorationString(dec)
105         << " decoration on target <id> " << _.getIdName(target->id()) << " ");
106     return ds;
107   };
108   switch (dec) {
109     case spv::Decoration::SpecId:
110       if (!spvOpcodeIsScalarSpecConstant(target->opcode())) {
111         return fail(0) << "must be a scalar specialization constant";
112       }
113       break;
114     case spv::Decoration::Block:
115     case spv::Decoration::BufferBlock:
116     case spv::Decoration::GLSLShared:
117     case spv::Decoration::GLSLPacked:
118     case spv::Decoration::CPacked:
119       if (target->opcode() != spv::Op::OpTypeStruct) {
120         return fail(0) << "must be a structure type";
121       }
122       break;
123     case spv::Decoration::ArrayStride:
124       if (target->opcode() != spv::Op::OpTypeArray &&
125           target->opcode() != spv::Op::OpTypeRuntimeArray &&
126           target->opcode() != spv::Op::OpTypePointer &&
127           target->opcode() != spv::Op::OpTypeUntypedPointerKHR) {
128         return fail(0) << "must be an array or pointer type";
129       }
130       break;
131     case spv::Decoration::BuiltIn:
132       if (target->opcode() != spv::Op::OpVariable &&
133           target->opcode() != spv::Op::OpUntypedVariableKHR &&
134           !spvOpcodeIsConstant(target->opcode())) {
135         return _.diag(SPV_ERROR_INVALID_DATA, inst)
136                << "BuiltIns can only target variables, structure members or "
137                   "constants";
138       }
139       if (_.HasCapability(spv::Capability::Shader) &&
140           inst->GetOperandAs<spv::BuiltIn>(2) == spv::BuiltIn::WorkgroupSize) {
141         if (!spvOpcodeIsConstant(target->opcode())) {
142           return fail(0) << "must be a constant for WorkgroupSize";
143         }
144       } else if (target->opcode() != spv::Op::OpVariable &&
145                  target->opcode() != spv::Op::OpUntypedVariableKHR) {
146         return fail(0) << "must be a variable";
147       }
148       break;
149     case spv::Decoration::NoPerspective:
150     case spv::Decoration::Flat:
151     case spv::Decoration::Patch:
152     case spv::Decoration::Centroid:
153     case spv::Decoration::Sample:
154     case spv::Decoration::Restrict:
155     case spv::Decoration::Aliased:
156     case spv::Decoration::Volatile:
157     case spv::Decoration::Coherent:
158     case spv::Decoration::NonWritable:
159     case spv::Decoration::NonReadable:
160     case spv::Decoration::XfbBuffer:
161     case spv::Decoration::XfbStride:
162     case spv::Decoration::Component:
163     case spv::Decoration::Stream:
164     case spv::Decoration::RestrictPointer:
165     case spv::Decoration::AliasedPointer:
166       if (target->opcode() != spv::Op::OpVariable &&
167           target->opcode() != spv::Op::OpUntypedVariableKHR &&
168           target->opcode() != spv::Op::OpFunctionParameter &&
169           target->opcode() != spv::Op::OpRawAccessChainNV) {
170         return fail(0) << "must be a memory object declaration";
171       }
172       if (!_.IsPointerType(target->type_id())) {
173         return fail(0) << "must be a pointer type";
174       }
175       break;
176     case spv::Decoration::Invariant:
177     case spv::Decoration::Constant:
178     case spv::Decoration::Location:
179     case spv::Decoration::Index:
180     case spv::Decoration::Binding:
181     case spv::Decoration::DescriptorSet:
182     case spv::Decoration::InputAttachmentIndex:
183       if (target->opcode() != spv::Op::OpVariable &&
184           target->opcode() != spv::Op::OpUntypedVariableKHR) {
185         return fail(0) << "must be a variable";
186       }
187       break;
188     default:
189       break;
190   }
191 
192   if (spvIsVulkanEnv(_.context()->target_env)) {
193     // The following were all checked as pointer types above.
194     spv::StorageClass sc = spv::StorageClass::Uniform;
195     const auto type = _.FindDef(target->type_id());
196     if (type && type->operands().size() > 2) {
197       sc = type->GetOperandAs<spv::StorageClass>(1);
198     }
199     switch (dec) {
200       case spv::Decoration::Location:
201       case spv::Decoration::Component:
202         // Location is used for input, output, tile image, and ray tracing
203         // stages.
204         if (sc != spv::StorageClass::Input && sc != spv::StorageClass::Output &&
205             sc != spv::StorageClass::RayPayloadKHR &&
206             sc != spv::StorageClass::IncomingRayPayloadKHR &&
207             sc != spv::StorageClass::HitAttributeKHR &&
208             sc != spv::StorageClass::CallableDataKHR &&
209             sc != spv::StorageClass::IncomingCallableDataKHR &&
210             sc != spv::StorageClass::ShaderRecordBufferKHR &&
211             sc != spv::StorageClass::HitObjectAttributeNV &&
212             sc != spv::StorageClass::TileImageEXT) {
213           return _.diag(SPV_ERROR_INVALID_ID, target)
214                  << _.VkErrorID(6672) << _.SpvDecorationString(dec)
215                  << " decoration must not be applied to this storage class";
216         }
217         break;
218       case spv::Decoration::Index:
219         // Langauge from SPIR-V definition of Index
220         if (sc != spv::StorageClass::Output) {
221           return fail(0) << "must be in the Output storage class";
222         }
223         break;
224       case spv::Decoration::Binding:
225       case spv::Decoration::DescriptorSet:
226         if (sc != spv::StorageClass::StorageBuffer &&
227             sc != spv::StorageClass::Uniform &&
228             sc != spv::StorageClass::UniformConstant) {
229           return fail(6491) << "must be in the StorageBuffer, Uniform, or "
230                                "UniformConstant storage class";
231         }
232         break;
233       case spv::Decoration::InputAttachmentIndex:
234         if (sc != spv::StorageClass::UniformConstant) {
235           return fail(6678) << "must be in the UniformConstant storage class";
236         }
237         break;
238       case spv::Decoration::Flat:
239       case spv::Decoration::NoPerspective:
240       case spv::Decoration::Centroid:
241       case spv::Decoration::Sample:
242         if (sc != spv::StorageClass::Input && sc != spv::StorageClass::Output) {
243           return fail(4670) << "storage class must be Input or Output";
244         }
245         break;
246       case spv::Decoration::PerVertexKHR:
247         if (sc != spv::StorageClass::Input) {
248           return fail(6777) << "storage class must be Input";
249         }
250         break;
251       default:
252         break;
253     }
254   }
255   return SPV_SUCCESS;
256 }
257 
ValidateDecorate(ValidationState_t & _,const Instruction * inst)258 spv_result_t ValidateDecorate(ValidationState_t& _, const Instruction* inst) {
259   const auto decoration = inst->GetOperandAs<spv::Decoration>(1);
260   const auto target_id = inst->GetOperandAs<uint32_t>(0);
261   const auto target = _.FindDef(target_id);
262   if (!target) {
263     return _.diag(SPV_ERROR_INVALID_ID, inst) << "target is not defined";
264   }
265 
266   if (spvIsVulkanEnv(_.context()->target_env)) {
267     if ((decoration == spv::Decoration::GLSLShared) ||
268         (decoration == spv::Decoration::GLSLPacked)) {
269       return _.diag(SPV_ERROR_INVALID_ID, inst)
270              << _.VkErrorID(4669) << "OpDecorate decoration '"
271              << _.SpvDecorationString(decoration)
272              << "' is not valid for the Vulkan execution environment.";
273     }
274   }
275 
276   if (decoration == spv::Decoration::FPFastMathMode) {
277     if (_.HasDecoration(target_id, spv::Decoration::NoContraction)) {
278       return _.diag(SPV_ERROR_INVALID_ID, inst)
279              << "FPFastMathMode and NoContraction cannot decorate the same "
280                 "target";
281     }
282     auto mask = inst->GetOperandAs<spv::FPFastMathModeMask>(2);
283     if ((mask & spv::FPFastMathModeMask::AllowTransform) !=
284             spv::FPFastMathModeMask::MaskNone &&
285         ((mask & (spv::FPFastMathModeMask::AllowContract |
286                   spv::FPFastMathModeMask::AllowReassoc)) !=
287          (spv::FPFastMathModeMask::AllowContract |
288           spv::FPFastMathModeMask::AllowReassoc))) {
289       return _.diag(SPV_ERROR_INVALID_DATA, inst)
290              << "AllowReassoc and AllowContract must be specified when "
291                 "AllowTransform is specified";
292     }
293   }
294 
295   // This is checked from both sides since we register decorations as we go.
296   if (decoration == spv::Decoration::NoContraction) {
297     if (_.HasDecoration(target_id, spv::Decoration::FPFastMathMode)) {
298       return _.diag(SPV_ERROR_INVALID_ID, inst)
299              << "FPFastMathMode and NoContraction cannot decorate the same "
300                 "target";
301     }
302   }
303 
304   if (DecorationTakesIdParameters(decoration)) {
305     return _.diag(SPV_ERROR_INVALID_ID, inst)
306            << "Decorations taking ID parameters may not be used with "
307               "OpDecorateId";
308   }
309 
310   if (target->opcode() != spv::Op::OpDecorationGroup) {
311     if (IsMemberDecorationOnly(decoration)) {
312       return _.diag(SPV_ERROR_INVALID_ID, inst)
313              << _.SpvDecorationString(decoration)
314              << " can only be applied to structure members";
315     }
316 
317     if (auto error = ValidateDecorationTarget(_, decoration, inst, target)) {
318       return error;
319     }
320   }
321 
322   // TODO: Add validations for all decorations.
323   return SPV_SUCCESS;
324 }
325 
ValidateDecorateId(ValidationState_t & _,const Instruction * inst)326 spv_result_t ValidateDecorateId(ValidationState_t& _, const Instruction* inst) {
327   const auto decoration = inst->GetOperandAs<spv::Decoration>(1);
328   if (!DecorationTakesIdParameters(decoration)) {
329     return _.diag(SPV_ERROR_INVALID_ID, inst)
330            << "Decorations that don't take ID parameters may not be used with "
331               "OpDecorateId";
332   }
333 
334   // No member decorations take id parameters, so we don't bother checking if
335   // we are using a member only decoration here.
336 
337   // TODO: Add validations for these decorations.
338   // UniformId is covered elsewhere.
339   return SPV_SUCCESS;
340 }
341 
ValidateMemberDecorate(ValidationState_t & _,const Instruction * inst)342 spv_result_t ValidateMemberDecorate(ValidationState_t& _,
343                                     const Instruction* inst) {
344   const auto struct_type_id = inst->GetOperandAs<uint32_t>(0);
345   const auto struct_type = _.FindDef(struct_type_id);
346   if (!struct_type || spv::Op::OpTypeStruct != struct_type->opcode()) {
347     return _.diag(SPV_ERROR_INVALID_ID, inst)
348            << "OpMemberDecorate Structure type <id> "
349            << _.getIdName(struct_type_id) << " is not a struct type.";
350   }
351   const auto member = inst->GetOperandAs<uint32_t>(1);
352   const auto member_count =
353       static_cast<uint32_t>(struct_type->words().size() - 2);
354   if (member_count <= member) {
355     return _.diag(SPV_ERROR_INVALID_ID, inst)
356            << "Index " << member
357            << " provided in OpMemberDecorate for struct <id> "
358            << _.getIdName(struct_type_id)
359            << " is out of bounds. The structure has " << member_count
360            << " members. Largest valid index is " << member_count - 1 << ".";
361   }
362 
363   const auto decoration = inst->GetOperandAs<spv::Decoration>(2);
364   if (IsNotMemberDecoration(decoration)) {
365     return _.diag(SPV_ERROR_INVALID_ID, inst)
366            << _.SpvDecorationString(decoration)
367            << " cannot be applied to structure members";
368   }
369 
370   return SPV_SUCCESS;
371 }
372 
ValidateDecorationGroup(ValidationState_t & _,const Instruction * inst)373 spv_result_t ValidateDecorationGroup(ValidationState_t& _,
374                                      const Instruction* inst) {
375   const auto decoration_group_id = inst->GetOperandAs<uint32_t>(0);
376   const auto decoration_group = _.FindDef(decoration_group_id);
377   for (auto pair : decoration_group->uses()) {
378     auto use = pair.first;
379     if (use->opcode() != spv::Op::OpDecorate &&
380         use->opcode() != spv::Op::OpGroupDecorate &&
381         use->opcode() != spv::Op::OpGroupMemberDecorate &&
382         use->opcode() != spv::Op::OpName &&
383         use->opcode() != spv::Op::OpDecorateId && !use->IsNonSemantic()) {
384       return _.diag(SPV_ERROR_INVALID_ID, inst)
385              << "Result id of OpDecorationGroup can only "
386              << "be targeted by OpName, OpGroupDecorate, "
387              << "OpDecorate, OpDecorateId, and OpGroupMemberDecorate";
388     }
389   }
390   return SPV_SUCCESS;
391 }
392 
ValidateGroupDecorate(ValidationState_t & _,const Instruction * inst)393 spv_result_t ValidateGroupDecorate(ValidationState_t& _,
394                                    const Instruction* inst) {
395   const auto decoration_group_id = inst->GetOperandAs<uint32_t>(0);
396   auto decoration_group = _.FindDef(decoration_group_id);
397   if (!decoration_group ||
398       spv::Op::OpDecorationGroup != decoration_group->opcode()) {
399     return _.diag(SPV_ERROR_INVALID_ID, inst)
400            << "OpGroupDecorate Decoration group <id> "
401            << _.getIdName(decoration_group_id) << " is not a decoration group.";
402   }
403   for (unsigned i = 1; i < inst->operands().size(); ++i) {
404     auto target_id = inst->GetOperandAs<uint32_t>(i);
405     auto target = _.FindDef(target_id);
406     if (!target || target->opcode() == spv::Op::OpDecorationGroup) {
407       return _.diag(SPV_ERROR_INVALID_ID, inst)
408              << "OpGroupDecorate may not target OpDecorationGroup <id> "
409              << _.getIdName(target_id);
410     }
411   }
412   return SPV_SUCCESS;
413 }
414 
ValidateGroupMemberDecorate(ValidationState_t & _,const Instruction * inst)415 spv_result_t ValidateGroupMemberDecorate(ValidationState_t& _,
416                                          const Instruction* inst) {
417   const auto decoration_group_id = inst->GetOperandAs<uint32_t>(0);
418   const auto decoration_group = _.FindDef(decoration_group_id);
419   if (!decoration_group ||
420       spv::Op::OpDecorationGroup != decoration_group->opcode()) {
421     return _.diag(SPV_ERROR_INVALID_ID, inst)
422            << "OpGroupMemberDecorate Decoration group <id> "
423            << _.getIdName(decoration_group_id) << " is not a decoration group.";
424   }
425   // Grammar checks ensures that the number of arguments to this instruction
426   // is an odd number: 1 decoration group + (id,literal) pairs.
427   for (size_t i = 1; i + 1 < inst->operands().size(); i += 2) {
428     const uint32_t struct_id = inst->GetOperandAs<uint32_t>(i);
429     const uint32_t index = inst->GetOperandAs<uint32_t>(i + 1);
430     auto struct_instr = _.FindDef(struct_id);
431     if (!struct_instr || spv::Op::OpTypeStruct != struct_instr->opcode()) {
432       return _.diag(SPV_ERROR_INVALID_ID, inst)
433              << "OpGroupMemberDecorate Structure type <id> "
434              << _.getIdName(struct_id) << " is not a struct type.";
435     }
436     const uint32_t num_struct_members =
437         static_cast<uint32_t>(struct_instr->words().size() - 2);
438     if (index >= num_struct_members) {
439       return _.diag(SPV_ERROR_INVALID_ID, inst)
440              << "Index " << index
441              << " provided in OpGroupMemberDecorate for struct <id> "
442              << _.getIdName(struct_id)
443              << " is out of bounds. The structure has " << num_struct_members
444              << " members. Largest valid index is " << num_struct_members - 1
445              << ".";
446     }
447   }
448   return SPV_SUCCESS;
449 }
450 
451 // Registers necessary decoration(s) for the appropriate IDs based on the
452 // instruction.
RegisterDecorations(ValidationState_t & _,const Instruction * inst)453 spv_result_t RegisterDecorations(ValidationState_t& _,
454                                  const Instruction* inst) {
455   switch (inst->opcode()) {
456     case spv::Op::OpDecorate:
457     case spv::Op::OpDecorateId: {
458       const uint32_t target_id = inst->word(1);
459       const spv::Decoration dec_type =
460           static_cast<spv::Decoration>(inst->word(2));
461       std::vector<uint32_t> dec_params;
462       if (inst->words().size() > 3) {
463         dec_params.insert(dec_params.end(), inst->words().begin() + 3,
464                           inst->words().end());
465       }
466       _.RegisterDecorationForId(target_id, Decoration(dec_type, dec_params));
467       break;
468     }
469     case spv::Op::OpMemberDecorate: {
470       const uint32_t struct_id = inst->word(1);
471       const uint32_t index = inst->word(2);
472       const spv::Decoration dec_type =
473           static_cast<spv::Decoration>(inst->word(3));
474       std::vector<uint32_t> dec_params;
475       if (inst->words().size() > 4) {
476         dec_params.insert(dec_params.end(), inst->words().begin() + 4,
477                           inst->words().end());
478       }
479       _.RegisterDecorationForId(struct_id,
480                                 Decoration(dec_type, dec_params, index));
481       break;
482     }
483     case spv::Op::OpDecorationGroup: {
484       // We don't need to do anything right now. Assigning decorations to groups
485       // will be taken care of via OpGroupDecorate.
486       break;
487     }
488     case spv::Op::OpGroupDecorate: {
489       // Word 1 is the group <id>. All subsequent words are target <id>s that
490       // are going to be decorated with the decorations.
491       const uint32_t decoration_group_id = inst->word(1);
492       std::set<Decoration>& group_decorations =
493           _.id_decorations(decoration_group_id);
494       for (size_t i = 2; i < inst->words().size(); ++i) {
495         const uint32_t target_id = inst->word(i);
496         _.RegisterDecorationsForId(target_id, group_decorations.begin(),
497                                    group_decorations.end());
498       }
499       break;
500     }
501     case spv::Op::OpGroupMemberDecorate: {
502       // Word 1 is the Decoration Group <id> followed by (struct<id>,literal)
503       // pairs. All decorations of the group should be applied to all the struct
504       // members that are specified in the instructions.
505       const uint32_t decoration_group_id = inst->word(1);
506       std::set<Decoration>& group_decorations =
507           _.id_decorations(decoration_group_id);
508       // Grammar checks ensures that the number of arguments to this instruction
509       // is an odd number: 1 decoration group + (id,literal) pairs.
510       for (size_t i = 2; i + 1 < inst->words().size(); i = i + 2) {
511         const uint32_t struct_id = inst->word(i);
512         const uint32_t index = inst->word(i + 1);
513         // ID validation phase ensures this is in fact a struct instruction and
514         // that the index is not out of bound.
515         _.RegisterDecorationsForStructMember(struct_id, index,
516                                              group_decorations.begin(),
517                                              group_decorations.end());
518       }
519       break;
520     }
521     default:
522       break;
523   }
524   return SPV_SUCCESS;
525 }
526 
527 }  // namespace
528 
AnnotationPass(ValidationState_t & _,const Instruction * inst)529 spv_result_t AnnotationPass(ValidationState_t& _, const Instruction* inst) {
530   switch (inst->opcode()) {
531     case spv::Op::OpDecorate:
532       if (auto error = ValidateDecorate(_, inst)) return error;
533       break;
534     case spv::Op::OpDecorateId:
535       if (auto error = ValidateDecorateId(_, inst)) return error;
536       break;
537     // TODO(dneto): spv::Op::OpDecorateStringGOOGLE
538     // See https://github.com/KhronosGroup/SPIRV-Tools/issues/2253
539     case spv::Op::OpMemberDecorate:
540       if (auto error = ValidateMemberDecorate(_, inst)) return error;
541       break;
542     case spv::Op::OpDecorationGroup:
543       if (auto error = ValidateDecorationGroup(_, inst)) return error;
544       break;
545     case spv::Op::OpGroupDecorate:
546       if (auto error = ValidateGroupDecorate(_, inst)) return error;
547       break;
548     case spv::Op::OpGroupMemberDecorate:
549       if (auto error = ValidateGroupMemberDecorate(_, inst)) return error;
550       break;
551     default:
552       break;
553   }
554 
555   // In order to validate decoration rules, we need to know all the decorations
556   // that are applied to any given <id>.
557   RegisterDecorations(_, inst);
558 
559   return SPV_SUCCESS;
560 }
561 
562 }  // namespace val
563 }  // namespace spvtools
564