• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by gen_spirv_builder_and_parser.py using data from spirv.core.grammar.json.
3 //
4 // Copyright 2021 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // spirv_instruction_builder_autogen.h:
9 //   Functions to generate SPIR-V binary for each instruction.
10 
11 #ifndef COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_
12 #define COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_
13 
14 #include <spirv/unified1/spirv.hpp>
15 
16 #include "spirv_types.h"
17 
18 namespace angle
19 {
20 namespace spirv
21 {
22 
23 void WriteSpirvHeader(std::vector<uint32_t> *blob, uint32_t version, uint32_t idCount);
24 void WriteNop(Blob *blob);
25 void WriteUndef(Blob *blob, IdResultType idResultType1, IdResult idResult2);
26 void WriteSourceContinued(Blob *blob, LiteralString continuedSource);
27 void WriteSource(Blob *blob,
28                  spv::SourceLanguage sourceLanguage1,
29                  LiteralInteger version,
30                  const IdRef *file,
31                  const LiteralString *source);
32 void WriteSourceExtension(Blob *blob, LiteralString extension);
33 void WriteName(Blob *blob, IdRef target, LiteralString name);
34 void WriteMemberName(Blob *blob, IdRef type, LiteralInteger member, LiteralString name);
35 void WriteString(Blob *blob, IdResult idResult1, LiteralString string);
36 void WriteLine(Blob *blob, IdRef file, LiteralInteger line, LiteralInteger column);
37 void WriteExtension(Blob *blob, LiteralString name);
38 void WriteExtInstImport(Blob *blob, IdResult idResult1, LiteralString name);
39 void WriteExtInst(Blob *blob,
40                   IdResultType idResultType1,
41                   IdResult idResult2,
42                   IdRef set,
43                   LiteralExtInstInteger instruction,
44                   const IdRefList &operandList);
45 void WriteMemoryModel(Blob *blob,
46                       spv::AddressingModel addressingModel1,
47                       spv::MemoryModel memoryModel2);
48 void WriteEntryPoint(Blob *blob,
49                      spv::ExecutionModel executionModel1,
50                      IdRef entryPoint,
51                      LiteralString name,
52                      const IdRefList &interfaceList);
53 void WriteExecutionMode(Blob *blob,
54                         IdRef entryPoint,
55                         spv::ExecutionMode mode,
56                         const LiteralIntegerList &operandsList);
57 void WriteCapability(Blob *blob, spv::Capability capability);
58 void WriteTypeVoid(Blob *blob, IdResult idResult1);
59 void WriteTypeBool(Blob *blob, IdResult idResult1);
60 void WriteTypeInt(Blob *blob, IdResult idResult1, LiteralInteger width, LiteralInteger signedness);
61 void WriteTypeFloat(Blob *blob, IdResult idResult1, LiteralInteger width);
62 void WriteTypeVector(Blob *blob,
63                      IdResult idResult1,
64                      IdRef componentType,
65                      LiteralInteger componentCount);
66 void WriteTypeMatrix(Blob *blob, IdResult idResult1, IdRef columnType, LiteralInteger columnCount);
67 void WriteTypeImage(Blob *blob,
68                     IdResult idResult1,
69                     IdRef sampledType,
70                     spv::Dim dim3,
71                     LiteralInteger depth,
72                     LiteralInteger arrayed,
73                     LiteralInteger mS,
74                     LiteralInteger sampled,
75                     spv::ImageFormat imageFormat8,
76                     const spv::AccessQualifier *accessQualifier9);
77 void WriteTypeSampler(Blob *blob, IdResult idResult1);
78 void WriteTypeSampledImage(Blob *blob, IdResult idResult1, IdRef imageType);
79 void WriteTypeArray(Blob *blob, IdResult idResult1, IdRef elementType, IdRef length);
80 void WriteTypeRuntimeArray(Blob *blob, IdResult idResult1, IdRef elementType);
81 void WriteTypeStruct(Blob *blob, IdResult idResult1, const IdRefList &memberList);
82 void WriteTypePointer(Blob *blob, IdResult idResult1, spv::StorageClass storageClass2, IdRef type);
83 void WriteTypeFunction(Blob *blob,
84                        IdResult idResult1,
85                        IdRef returnType,
86                        const IdRefList &parameterList);
87 void WriteConstantTrue(Blob *blob, IdResultType idResultType1, IdResult idResult2);
88 void WriteConstantFalse(Blob *blob, IdResultType idResultType1, IdResult idResult2);
89 void WriteConstant(Blob *blob,
90                    IdResultType idResultType1,
91                    IdResult idResult2,
92                    LiteralContextDependentNumber value);
93 void WriteConstantComposite(Blob *blob,
94                             IdResultType idResultType1,
95                             IdResult idResult2,
96                             const IdRefList &constituentsList);
97 void WriteConstantNull(Blob *blob, IdResultType idResultType1, IdResult idResult2);
98 void WriteSpecConstantTrue(Blob *blob, IdResultType idResultType1, IdResult idResult2);
99 void WriteSpecConstantFalse(Blob *blob, IdResultType idResultType1, IdResult idResult2);
100 void WriteSpecConstant(Blob *blob,
101                        IdResultType idResultType1,
102                        IdResult idResult2,
103                        LiteralContextDependentNumber value);
104 void WriteSpecConstantComposite(Blob *blob,
105                                 IdResultType idResultType1,
106                                 IdResult idResult2,
107                                 const IdRefList &constituentsList);
108 void WriteFunction(Blob *blob,
109                    IdResultType idResultType1,
110                    IdResult idResult2,
111                    spv::FunctionControlMask functionControl3,
112                    IdRef functionType);
113 void WriteFunctionParameter(Blob *blob, IdResultType idResultType1, IdResult idResult2);
114 void WriteFunctionEnd(Blob *blob);
115 void WriteFunctionCall(Blob *blob,
116                        IdResultType idResultType1,
117                        IdResult idResult2,
118                        IdRef function,
119                        const IdRefList &argumentList);
120 void WriteVariable(Blob *blob,
121                    IdResultType idResultType1,
122                    IdResult idResult2,
123                    spv::StorageClass storageClass3,
124                    const IdRef *initializer);
125 void WriteImageTexelPointer(Blob *blob,
126                             IdResultType idResultType1,
127                             IdResult idResult2,
128                             IdRef image,
129                             IdRef coordinate,
130                             IdRef sample);
131 void WriteLoad(Blob *blob,
132                IdResultType idResultType1,
133                IdResult idResult2,
134                IdRef pointer,
135                const spv::MemoryAccessMask *memoryAccess4);
136 void WriteStore(Blob *blob,
137                 IdRef pointer,
138                 IdRef object,
139                 const spv::MemoryAccessMask *memoryAccess3);
140 void WriteCopyMemory(Blob *blob,
141                      IdRef target,
142                      IdRef source,
143                      const spv::MemoryAccessMask *memoryAccess3,
144                      const spv::MemoryAccessMask *memoryAccess4);
145 void WriteAccessChain(Blob *blob,
146                       IdResultType idResultType1,
147                       IdResult idResult2,
148                       IdRef base,
149                       const IdRefList &indexesList);
150 void WriteInBoundsAccessChain(Blob *blob,
151                               IdResultType idResultType1,
152                               IdResult idResult2,
153                               IdRef base,
154                               const IdRefList &indexesList);
155 void WriteArrayLength(Blob *blob,
156                       IdResultType idResultType1,
157                       IdResult idResult2,
158                       IdRef structure,
159                       LiteralInteger arraymember);
160 void WriteDecorate(Blob *blob,
161                    IdRef target,
162                    spv::Decoration decoration2,
163                    const LiteralIntegerList &valuesList);
164 void WriteMemberDecorate(Blob *blob,
165                          IdRef structureType,
166                          LiteralInteger member,
167                          spv::Decoration decoration3,
168                          const LiteralIntegerList &valuesList);
169 void WriteDecorationGroup(Blob *blob, IdResult idResult1);
170 void WriteGroupDecorate(Blob *blob, IdRef decorationGroup, const IdRefList &targetsList);
171 void WriteGroupMemberDecorate(Blob *blob,
172                               IdRef decorationGroup,
173                               const PairIdRefLiteralIntegerList &targetsPairList);
174 void WriteVectorExtractDynamic(Blob *blob,
175                                IdResultType idResultType1,
176                                IdResult idResult2,
177                                IdRef vector,
178                                IdRef index);
179 void WriteVectorInsertDynamic(Blob *blob,
180                               IdResultType idResultType1,
181                               IdResult idResult2,
182                               IdRef vector,
183                               IdRef component,
184                               IdRef index);
185 void WriteVectorShuffle(Blob *blob,
186                         IdResultType idResultType1,
187                         IdResult idResult2,
188                         IdRef vector1,
189                         IdRef vector2,
190                         const LiteralIntegerList &componentsList);
191 void WriteCompositeConstruct(Blob *blob,
192                              IdResultType idResultType1,
193                              IdResult idResult2,
194                              const IdRefList &constituentsList);
195 void WriteCompositeExtract(Blob *blob,
196                            IdResultType idResultType1,
197                            IdResult idResult2,
198                            IdRef composite,
199                            const LiteralIntegerList &indexesList);
200 void WriteCompositeInsert(Blob *blob,
201                           IdResultType idResultType1,
202                           IdResult idResult2,
203                           IdRef object,
204                           IdRef composite,
205                           const LiteralIntegerList &indexesList);
206 void WriteCopyObject(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
207 void WriteTranspose(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef matrix);
208 void WriteSampledImage(Blob *blob,
209                        IdResultType idResultType1,
210                        IdResult idResult2,
211                        IdRef image,
212                        IdRef sampler);
213 void WriteImageSampleImplicitLod(Blob *blob,
214                                  IdResultType idResultType1,
215                                  IdResult idResult2,
216                                  IdRef sampledImage,
217                                  IdRef coordinate,
218                                  const spv::ImageOperandsMask *imageOperands5,
219                                  const IdRefList &imageOperandIdsList);
220 void WriteImageSampleExplicitLod(Blob *blob,
221                                  IdResultType idResultType1,
222                                  IdResult idResult2,
223                                  IdRef sampledImage,
224                                  IdRef coordinate,
225                                  spv::ImageOperandsMask imageOperands5,
226                                  const IdRefList &imageOperandIdsList);
227 void WriteImageSampleDrefImplicitLod(Blob *blob,
228                                      IdResultType idResultType1,
229                                      IdResult idResult2,
230                                      IdRef sampledImage,
231                                      IdRef coordinate,
232                                      IdRef dref,
233                                      const spv::ImageOperandsMask *imageOperands6,
234                                      const IdRefList &imageOperandIdsList);
235 void WriteImageSampleDrefExplicitLod(Blob *blob,
236                                      IdResultType idResultType1,
237                                      IdResult idResult2,
238                                      IdRef sampledImage,
239                                      IdRef coordinate,
240                                      IdRef dref,
241                                      spv::ImageOperandsMask imageOperands6,
242                                      const IdRefList &imageOperandIdsList);
243 void WriteImageSampleProjImplicitLod(Blob *blob,
244                                      IdResultType idResultType1,
245                                      IdResult idResult2,
246                                      IdRef sampledImage,
247                                      IdRef coordinate,
248                                      const spv::ImageOperandsMask *imageOperands5,
249                                      const IdRefList &imageOperandIdsList);
250 void WriteImageSampleProjExplicitLod(Blob *blob,
251                                      IdResultType idResultType1,
252                                      IdResult idResult2,
253                                      IdRef sampledImage,
254                                      IdRef coordinate,
255                                      spv::ImageOperandsMask imageOperands5,
256                                      const IdRefList &imageOperandIdsList);
257 void WriteImageSampleProjDrefImplicitLod(Blob *blob,
258                                          IdResultType idResultType1,
259                                          IdResult idResult2,
260                                          IdRef sampledImage,
261                                          IdRef coordinate,
262                                          IdRef dref,
263                                          const spv::ImageOperandsMask *imageOperands6,
264                                          const IdRefList &imageOperandIdsList);
265 void WriteImageSampleProjDrefExplicitLod(Blob *blob,
266                                          IdResultType idResultType1,
267                                          IdResult idResult2,
268                                          IdRef sampledImage,
269                                          IdRef coordinate,
270                                          IdRef dref,
271                                          spv::ImageOperandsMask imageOperands6,
272                                          const IdRefList &imageOperandIdsList);
273 void WriteImageFetch(Blob *blob,
274                      IdResultType idResultType1,
275                      IdResult idResult2,
276                      IdRef image,
277                      IdRef coordinate,
278                      const spv::ImageOperandsMask *imageOperands5,
279                      const IdRefList &imageOperandIdsList);
280 void WriteImageGather(Blob *blob,
281                       IdResultType idResultType1,
282                       IdResult idResult2,
283                       IdRef sampledImage,
284                       IdRef coordinate,
285                       IdRef component,
286                       const spv::ImageOperandsMask *imageOperands6,
287                       const IdRefList &imageOperandIdsList);
288 void WriteImageDrefGather(Blob *blob,
289                           IdResultType idResultType1,
290                           IdResult idResult2,
291                           IdRef sampledImage,
292                           IdRef coordinate,
293                           IdRef dref,
294                           const spv::ImageOperandsMask *imageOperands6,
295                           const IdRefList &imageOperandIdsList);
296 void WriteImageRead(Blob *blob,
297                     IdResultType idResultType1,
298                     IdResult idResult2,
299                     IdRef image,
300                     IdRef coordinate,
301                     const spv::ImageOperandsMask *imageOperands5,
302                     const IdRefList &imageOperandIdsList);
303 void WriteImageWrite(Blob *blob,
304                      IdRef image,
305                      IdRef coordinate,
306                      IdRef texel,
307                      const spv::ImageOperandsMask *imageOperands4,
308                      const IdRefList &imageOperandIdsList);
309 void WriteImage(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef sampledImage);
310 void WriteImageQuerySizeLod(Blob *blob,
311                             IdResultType idResultType1,
312                             IdResult idResult2,
313                             IdRef image,
314                             IdRef levelofDetail);
315 void WriteImageQuerySize(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef image);
316 void WriteImageQueryLod(Blob *blob,
317                         IdResultType idResultType1,
318                         IdResult idResult2,
319                         IdRef sampledImage,
320                         IdRef coordinate);
321 void WriteImageQueryLevels(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef image);
322 void WriteImageQuerySamples(Blob *blob,
323                             IdResultType idResultType1,
324                             IdResult idResult2,
325                             IdRef image);
326 void WriteConvertFToU(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef floatValue);
327 void WriteConvertFToS(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef floatValue);
328 void WriteConvertSToF(Blob *blob,
329                       IdResultType idResultType1,
330                       IdResult idResult2,
331                       IdRef signedValue);
332 void WriteConvertUToF(Blob *blob,
333                       IdResultType idResultType1,
334                       IdResult idResult2,
335                       IdRef unsignedValue);
336 void WriteUConvert(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef unsignedValue);
337 void WriteSConvert(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef signedValue);
338 void WriteFConvert(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef floatValue);
339 void WriteQuantizeToF16(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef value);
340 void WriteBitcast(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
341 void WriteSNegate(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
342 void WriteFNegate(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
343 void WriteIAdd(Blob *blob,
344                IdResultType idResultType1,
345                IdResult idResult2,
346                IdRef operand1,
347                IdRef operand2);
348 void WriteFAdd(Blob *blob,
349                IdResultType idResultType1,
350                IdResult idResult2,
351                IdRef operand1,
352                IdRef operand2);
353 void WriteISub(Blob *blob,
354                IdResultType idResultType1,
355                IdResult idResult2,
356                IdRef operand1,
357                IdRef operand2);
358 void WriteFSub(Blob *blob,
359                IdResultType idResultType1,
360                IdResult idResult2,
361                IdRef operand1,
362                IdRef operand2);
363 void WriteIMul(Blob *blob,
364                IdResultType idResultType1,
365                IdResult idResult2,
366                IdRef operand1,
367                IdRef operand2);
368 void WriteFMul(Blob *blob,
369                IdResultType idResultType1,
370                IdResult idResult2,
371                IdRef operand1,
372                IdRef operand2);
373 void WriteUDiv(Blob *blob,
374                IdResultType idResultType1,
375                IdResult idResult2,
376                IdRef operand1,
377                IdRef operand2);
378 void WriteSDiv(Blob *blob,
379                IdResultType idResultType1,
380                IdResult idResult2,
381                IdRef operand1,
382                IdRef operand2);
383 void WriteFDiv(Blob *blob,
384                IdResultType idResultType1,
385                IdResult idResult2,
386                IdRef operand1,
387                IdRef operand2);
388 void WriteUMod(Blob *blob,
389                IdResultType idResultType1,
390                IdResult idResult2,
391                IdRef operand1,
392                IdRef operand2);
393 void WriteSRem(Blob *blob,
394                IdResultType idResultType1,
395                IdResult idResult2,
396                IdRef operand1,
397                IdRef operand2);
398 void WriteSMod(Blob *blob,
399                IdResultType idResultType1,
400                IdResult idResult2,
401                IdRef operand1,
402                IdRef operand2);
403 void WriteFRem(Blob *blob,
404                IdResultType idResultType1,
405                IdResult idResult2,
406                IdRef operand1,
407                IdRef operand2);
408 void WriteFMod(Blob *blob,
409                IdResultType idResultType1,
410                IdResult idResult2,
411                IdRef operand1,
412                IdRef operand2);
413 void WriteVectorTimesScalar(Blob *blob,
414                             IdResultType idResultType1,
415                             IdResult idResult2,
416                             IdRef vector,
417                             IdRef scalar);
418 void WriteMatrixTimesScalar(Blob *blob,
419                             IdResultType idResultType1,
420                             IdResult idResult2,
421                             IdRef matrix,
422                             IdRef scalar);
423 void WriteVectorTimesMatrix(Blob *blob,
424                             IdResultType idResultType1,
425                             IdResult idResult2,
426                             IdRef vector,
427                             IdRef matrix);
428 void WriteMatrixTimesVector(Blob *blob,
429                             IdResultType idResultType1,
430                             IdResult idResult2,
431                             IdRef matrix,
432                             IdRef vector);
433 void WriteMatrixTimesMatrix(Blob *blob,
434                             IdResultType idResultType1,
435                             IdResult idResult2,
436                             IdRef leftMatrix,
437                             IdRef rightMatrix);
438 void WriteOuterProduct(Blob *blob,
439                        IdResultType idResultType1,
440                        IdResult idResult2,
441                        IdRef vector1,
442                        IdRef vector2);
443 void WriteDot(Blob *blob,
444               IdResultType idResultType1,
445               IdResult idResult2,
446               IdRef vector1,
447               IdRef vector2);
448 void WriteIAddCarry(Blob *blob,
449                     IdResultType idResultType1,
450                     IdResult idResult2,
451                     IdRef operand1,
452                     IdRef operand2);
453 void WriteISubBorrow(Blob *blob,
454                      IdResultType idResultType1,
455                      IdResult idResult2,
456                      IdRef operand1,
457                      IdRef operand2);
458 void WriteUMulExtended(Blob *blob,
459                        IdResultType idResultType1,
460                        IdResult idResult2,
461                        IdRef operand1,
462                        IdRef operand2);
463 void WriteSMulExtended(Blob *blob,
464                        IdResultType idResultType1,
465                        IdResult idResult2,
466                        IdRef operand1,
467                        IdRef operand2);
468 void WriteAny(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef vector);
469 void WriteAll(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef vector);
470 void WriteIsNan(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef x);
471 void WriteIsInf(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef x);
472 void WriteLogicalEqual(Blob *blob,
473                        IdResultType idResultType1,
474                        IdResult idResult2,
475                        IdRef operand1,
476                        IdRef operand2);
477 void WriteLogicalNotEqual(Blob *blob,
478                           IdResultType idResultType1,
479                           IdResult idResult2,
480                           IdRef operand1,
481                           IdRef operand2);
482 void WriteLogicalOr(Blob *blob,
483                     IdResultType idResultType1,
484                     IdResult idResult2,
485                     IdRef operand1,
486                     IdRef operand2);
487 void WriteLogicalAnd(Blob *blob,
488                      IdResultType idResultType1,
489                      IdResult idResult2,
490                      IdRef operand1,
491                      IdRef operand2);
492 void WriteLogicalNot(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
493 void WriteSelect(Blob *blob,
494                  IdResultType idResultType1,
495                  IdResult idResult2,
496                  IdRef condition,
497                  IdRef object1,
498                  IdRef object2);
499 void WriteIEqual(Blob *blob,
500                  IdResultType idResultType1,
501                  IdResult idResult2,
502                  IdRef operand1,
503                  IdRef operand2);
504 void WriteINotEqual(Blob *blob,
505                     IdResultType idResultType1,
506                     IdResult idResult2,
507                     IdRef operand1,
508                     IdRef operand2);
509 void WriteUGreaterThan(Blob *blob,
510                        IdResultType idResultType1,
511                        IdResult idResult2,
512                        IdRef operand1,
513                        IdRef operand2);
514 void WriteSGreaterThan(Blob *blob,
515                        IdResultType idResultType1,
516                        IdResult idResult2,
517                        IdRef operand1,
518                        IdRef operand2);
519 void WriteUGreaterThanEqual(Blob *blob,
520                             IdResultType idResultType1,
521                             IdResult idResult2,
522                             IdRef operand1,
523                             IdRef operand2);
524 void WriteSGreaterThanEqual(Blob *blob,
525                             IdResultType idResultType1,
526                             IdResult idResult2,
527                             IdRef operand1,
528                             IdRef operand2);
529 void WriteULessThan(Blob *blob,
530                     IdResultType idResultType1,
531                     IdResult idResult2,
532                     IdRef operand1,
533                     IdRef operand2);
534 void WriteSLessThan(Blob *blob,
535                     IdResultType idResultType1,
536                     IdResult idResult2,
537                     IdRef operand1,
538                     IdRef operand2);
539 void WriteULessThanEqual(Blob *blob,
540                          IdResultType idResultType1,
541                          IdResult idResult2,
542                          IdRef operand1,
543                          IdRef operand2);
544 void WriteSLessThanEqual(Blob *blob,
545                          IdResultType idResultType1,
546                          IdResult idResult2,
547                          IdRef operand1,
548                          IdRef operand2);
549 void WriteFOrdEqual(Blob *blob,
550                     IdResultType idResultType1,
551                     IdResult idResult2,
552                     IdRef operand1,
553                     IdRef operand2);
554 void WriteFUnordEqual(Blob *blob,
555                       IdResultType idResultType1,
556                       IdResult idResult2,
557                       IdRef operand1,
558                       IdRef operand2);
559 void WriteFOrdNotEqual(Blob *blob,
560                        IdResultType idResultType1,
561                        IdResult idResult2,
562                        IdRef operand1,
563                        IdRef operand2);
564 void WriteFUnordNotEqual(Blob *blob,
565                          IdResultType idResultType1,
566                          IdResult idResult2,
567                          IdRef operand1,
568                          IdRef operand2);
569 void WriteFOrdLessThan(Blob *blob,
570                        IdResultType idResultType1,
571                        IdResult idResult2,
572                        IdRef operand1,
573                        IdRef operand2);
574 void WriteFUnordLessThan(Blob *blob,
575                          IdResultType idResultType1,
576                          IdResult idResult2,
577                          IdRef operand1,
578                          IdRef operand2);
579 void WriteFOrdGreaterThan(Blob *blob,
580                           IdResultType idResultType1,
581                           IdResult idResult2,
582                           IdRef operand1,
583                           IdRef operand2);
584 void WriteFUnordGreaterThan(Blob *blob,
585                             IdResultType idResultType1,
586                             IdResult idResult2,
587                             IdRef operand1,
588                             IdRef operand2);
589 void WriteFOrdLessThanEqual(Blob *blob,
590                             IdResultType idResultType1,
591                             IdResult idResult2,
592                             IdRef operand1,
593                             IdRef operand2);
594 void WriteFUnordLessThanEqual(Blob *blob,
595                               IdResultType idResultType1,
596                               IdResult idResult2,
597                               IdRef operand1,
598                               IdRef operand2);
599 void WriteFOrdGreaterThanEqual(Blob *blob,
600                                IdResultType idResultType1,
601                                IdResult idResult2,
602                                IdRef operand1,
603                                IdRef operand2);
604 void WriteFUnordGreaterThanEqual(Blob *blob,
605                                  IdResultType idResultType1,
606                                  IdResult idResult2,
607                                  IdRef operand1,
608                                  IdRef operand2);
609 void WriteShiftRightLogical(Blob *blob,
610                             IdResultType idResultType1,
611                             IdResult idResult2,
612                             IdRef base,
613                             IdRef shift);
614 void WriteShiftRightArithmetic(Blob *blob,
615                                IdResultType idResultType1,
616                                IdResult idResult2,
617                                IdRef base,
618                                IdRef shift);
619 void WriteShiftLeftLogical(Blob *blob,
620                            IdResultType idResultType1,
621                            IdResult idResult2,
622                            IdRef base,
623                            IdRef shift);
624 void WriteBitwiseOr(Blob *blob,
625                     IdResultType idResultType1,
626                     IdResult idResult2,
627                     IdRef operand1,
628                     IdRef operand2);
629 void WriteBitwiseXor(Blob *blob,
630                      IdResultType idResultType1,
631                      IdResult idResult2,
632                      IdRef operand1,
633                      IdRef operand2);
634 void WriteBitwiseAnd(Blob *blob,
635                      IdResultType idResultType1,
636                      IdResult idResult2,
637                      IdRef operand1,
638                      IdRef operand2);
639 void WriteNot(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
640 void WriteBitFieldInsert(Blob *blob,
641                          IdResultType idResultType1,
642                          IdResult idResult2,
643                          IdRef base,
644                          IdRef insert,
645                          IdRef offset,
646                          IdRef count);
647 void WriteBitFieldSExtract(Blob *blob,
648                            IdResultType idResultType1,
649                            IdResult idResult2,
650                            IdRef base,
651                            IdRef offset,
652                            IdRef count);
653 void WriteBitFieldUExtract(Blob *blob,
654                            IdResultType idResultType1,
655                            IdResult idResult2,
656                            IdRef base,
657                            IdRef offset,
658                            IdRef count);
659 void WriteBitReverse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef base);
660 void WriteBitCount(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef base);
661 void WriteDPdx(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
662 void WriteDPdy(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
663 void WriteFwidth(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
664 void WriteDPdxFine(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
665 void WriteDPdyFine(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
666 void WriteFwidthFine(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
667 void WriteDPdxCoarse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
668 void WriteDPdyCoarse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
669 void WriteFwidthCoarse(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef p);
670 void WriteEmitVertex(Blob *blob);
671 void WriteEndPrimitive(Blob *blob);
672 void WriteEmitStreamVertex(Blob *blob, IdRef stream);
673 void WriteEndStreamPrimitive(Blob *blob, IdRef stream);
674 void WriteControlBarrier(Blob *blob,
675                          IdScope execution,
676                          IdScope memory,
677                          IdMemorySemantics semantics);
678 void WriteMemoryBarrier(Blob *blob, IdScope memory, IdMemorySemantics semantics);
679 void WriteAtomicLoad(Blob *blob,
680                      IdResultType idResultType1,
681                      IdResult idResult2,
682                      IdRef pointer,
683                      IdScope memory,
684                      IdMemorySemantics semantics);
685 void WriteAtomicStore(Blob *blob,
686                       IdRef pointer,
687                       IdScope memory,
688                       IdMemorySemantics semantics,
689                       IdRef value);
690 void WriteAtomicExchange(Blob *blob,
691                          IdResultType idResultType1,
692                          IdResult idResult2,
693                          IdRef pointer,
694                          IdScope memory,
695                          IdMemorySemantics semantics,
696                          IdRef value);
697 void WriteAtomicCompareExchange(Blob *blob,
698                                 IdResultType idResultType1,
699                                 IdResult idResult2,
700                                 IdRef pointer,
701                                 IdScope memory,
702                                 IdMemorySemantics equal,
703                                 IdMemorySemantics unequal,
704                                 IdRef value,
705                                 IdRef comparator);
706 void WriteAtomicIIncrement(Blob *blob,
707                            IdResultType idResultType1,
708                            IdResult idResult2,
709                            IdRef pointer,
710                            IdScope memory,
711                            IdMemorySemantics semantics);
712 void WriteAtomicIDecrement(Blob *blob,
713                            IdResultType idResultType1,
714                            IdResult idResult2,
715                            IdRef pointer,
716                            IdScope memory,
717                            IdMemorySemantics semantics);
718 void WriteAtomicIAdd(Blob *blob,
719                      IdResultType idResultType1,
720                      IdResult idResult2,
721                      IdRef pointer,
722                      IdScope memory,
723                      IdMemorySemantics semantics,
724                      IdRef value);
725 void WriteAtomicISub(Blob *blob,
726                      IdResultType idResultType1,
727                      IdResult idResult2,
728                      IdRef pointer,
729                      IdScope memory,
730                      IdMemorySemantics semantics,
731                      IdRef value);
732 void WriteAtomicSMin(Blob *blob,
733                      IdResultType idResultType1,
734                      IdResult idResult2,
735                      IdRef pointer,
736                      IdScope memory,
737                      IdMemorySemantics semantics,
738                      IdRef value);
739 void WriteAtomicUMin(Blob *blob,
740                      IdResultType idResultType1,
741                      IdResult idResult2,
742                      IdRef pointer,
743                      IdScope memory,
744                      IdMemorySemantics semantics,
745                      IdRef value);
746 void WriteAtomicSMax(Blob *blob,
747                      IdResultType idResultType1,
748                      IdResult idResult2,
749                      IdRef pointer,
750                      IdScope memory,
751                      IdMemorySemantics semantics,
752                      IdRef value);
753 void WriteAtomicUMax(Blob *blob,
754                      IdResultType idResultType1,
755                      IdResult idResult2,
756                      IdRef pointer,
757                      IdScope memory,
758                      IdMemorySemantics semantics,
759                      IdRef value);
760 void WriteAtomicAnd(Blob *blob,
761                     IdResultType idResultType1,
762                     IdResult idResult2,
763                     IdRef pointer,
764                     IdScope memory,
765                     IdMemorySemantics semantics,
766                     IdRef value);
767 void WriteAtomicOr(Blob *blob,
768                    IdResultType idResultType1,
769                    IdResult idResult2,
770                    IdRef pointer,
771                    IdScope memory,
772                    IdMemorySemantics semantics,
773                    IdRef value);
774 void WriteAtomicXor(Blob *blob,
775                     IdResultType idResultType1,
776                     IdResult idResult2,
777                     IdRef pointer,
778                     IdScope memory,
779                     IdMemorySemantics semantics,
780                     IdRef value);
781 void WritePhi(Blob *blob,
782               IdResultType idResultType1,
783               IdResult idResult2,
784               const PairIdRefIdRefList &variableParentPairList);
785 void WriteLoopMerge(Blob *blob,
786                     IdRef mergeBlock,
787                     IdRef continueTarget,
788                     spv::LoopControlMask loopControl3);
789 void WriteSelectionMerge(Blob *blob, IdRef mergeBlock, spv::SelectionControlMask selectionControl2);
790 void WriteLabel(Blob *blob, IdResult idResult1);
791 void WriteBranch(Blob *blob, IdRef targetLabel);
792 void WriteBranchConditional(Blob *blob,
793                             IdRef condition,
794                             IdRef trueLabel,
795                             IdRef falseLabel,
796                             const LiteralIntegerList &branchweightsList);
797 void WriteSwitch(Blob *blob,
798                  IdRef selector,
799                  IdRef default_,
800                  const PairLiteralIntegerIdRefList &targetPairList);
801 void WriteKill(Blob *blob);
802 void WriteReturn(Blob *blob);
803 void WriteReturnValue(Blob *blob, IdRef value);
804 void WriteUnreachable(Blob *blob);
805 void WriteImageSparseSampleImplicitLod(Blob *blob,
806                                        IdResultType idResultType1,
807                                        IdResult idResult2,
808                                        IdRef sampledImage,
809                                        IdRef coordinate,
810                                        const spv::ImageOperandsMask *imageOperands5,
811                                        const IdRefList &imageOperandIdsList);
812 void WriteImageSparseSampleExplicitLod(Blob *blob,
813                                        IdResultType idResultType1,
814                                        IdResult idResult2,
815                                        IdRef sampledImage,
816                                        IdRef coordinate,
817                                        spv::ImageOperandsMask imageOperands5,
818                                        const IdRefList &imageOperandIdsList);
819 void WriteImageSparseSampleDrefImplicitLod(Blob *blob,
820                                            IdResultType idResultType1,
821                                            IdResult idResult2,
822                                            IdRef sampledImage,
823                                            IdRef coordinate,
824                                            IdRef dref,
825                                            const spv::ImageOperandsMask *imageOperands6,
826                                            const IdRefList &imageOperandIdsList);
827 void WriteImageSparseSampleDrefExplicitLod(Blob *blob,
828                                            IdResultType idResultType1,
829                                            IdResult idResult2,
830                                            IdRef sampledImage,
831                                            IdRef coordinate,
832                                            IdRef dref,
833                                            spv::ImageOperandsMask imageOperands6,
834                                            const IdRefList &imageOperandIdsList);
835 void WriteImageSparseSampleProjImplicitLod(Blob *blob,
836                                            IdResultType idResultType1,
837                                            IdResult idResult2,
838                                            IdRef sampledImage,
839                                            IdRef coordinate,
840                                            const spv::ImageOperandsMask *imageOperands5,
841                                            const IdRefList &imageOperandIdsList);
842 void WriteImageSparseSampleProjExplicitLod(Blob *blob,
843                                            IdResultType idResultType1,
844                                            IdResult idResult2,
845                                            IdRef sampledImage,
846                                            IdRef coordinate,
847                                            spv::ImageOperandsMask imageOperands5,
848                                            const IdRefList &imageOperandIdsList);
849 void WriteImageSparseSampleProjDrefImplicitLod(Blob *blob,
850                                                IdResultType idResultType1,
851                                                IdResult idResult2,
852                                                IdRef sampledImage,
853                                                IdRef coordinate,
854                                                IdRef dref,
855                                                const spv::ImageOperandsMask *imageOperands6,
856                                                const IdRefList &imageOperandIdsList);
857 void WriteImageSparseSampleProjDrefExplicitLod(Blob *blob,
858                                                IdResultType idResultType1,
859                                                IdResult idResult2,
860                                                IdRef sampledImage,
861                                                IdRef coordinate,
862                                                IdRef dref,
863                                                spv::ImageOperandsMask imageOperands6,
864                                                const IdRefList &imageOperandIdsList);
865 void WriteImageSparseFetch(Blob *blob,
866                            IdResultType idResultType1,
867                            IdResult idResult2,
868                            IdRef image,
869                            IdRef coordinate,
870                            const spv::ImageOperandsMask *imageOperands5,
871                            const IdRefList &imageOperandIdsList);
872 void WriteImageSparseGather(Blob *blob,
873                             IdResultType idResultType1,
874                             IdResult idResult2,
875                             IdRef sampledImage,
876                             IdRef coordinate,
877                             IdRef component,
878                             const spv::ImageOperandsMask *imageOperands6,
879                             const IdRefList &imageOperandIdsList);
880 void WriteImageSparseDrefGather(Blob *blob,
881                                 IdResultType idResultType1,
882                                 IdResult idResult2,
883                                 IdRef sampledImage,
884                                 IdRef coordinate,
885                                 IdRef dref,
886                                 const spv::ImageOperandsMask *imageOperands6,
887                                 const IdRefList &imageOperandIdsList);
888 void WriteImageSparseTexelsResident(Blob *blob,
889                                     IdResultType idResultType1,
890                                     IdResult idResult2,
891                                     IdRef residentCode);
892 void WriteNoLine(Blob *blob);
893 void WriteImageSparseRead(Blob *blob,
894                           IdResultType idResultType1,
895                           IdResult idResult2,
896                           IdRef image,
897                           IdRef coordinate,
898                           const spv::ImageOperandsMask *imageOperands5,
899                           const IdRefList &imageOperandIdsList);
900 void WriteModuleProcessed(Blob *blob, LiteralString process);
901 void WriteExecutionModeId(Blob *blob,
902                           IdRef entryPoint,
903                           spv::ExecutionMode mode,
904                           const LiteralIntegerList &operandsList);
905 void WriteGroupNonUniformElect(Blob *blob,
906                                IdResultType idResultType1,
907                                IdResult idResult2,
908                                IdScope execution);
909 void WriteGroupNonUniformAll(Blob *blob,
910                              IdResultType idResultType1,
911                              IdResult idResult2,
912                              IdScope execution,
913                              IdRef predicate);
914 void WriteGroupNonUniformAny(Blob *blob,
915                              IdResultType idResultType1,
916                              IdResult idResult2,
917                              IdScope execution,
918                              IdRef predicate);
919 void WriteGroupNonUniformAllEqual(Blob *blob,
920                                   IdResultType idResultType1,
921                                   IdResult idResult2,
922                                   IdScope execution,
923                                   IdRef value);
924 void WriteGroupNonUniformBroadcast(Blob *blob,
925                                    IdResultType idResultType1,
926                                    IdResult idResult2,
927                                    IdScope execution,
928                                    IdRef value,
929                                    IdRef id);
930 void WriteGroupNonUniformBroadcastFirst(Blob *blob,
931                                         IdResultType idResultType1,
932                                         IdResult idResult2,
933                                         IdScope execution,
934                                         IdRef value);
935 void WriteGroupNonUniformBallot(Blob *blob,
936                                 IdResultType idResultType1,
937                                 IdResult idResult2,
938                                 IdScope execution,
939                                 IdRef predicate);
940 void WriteGroupNonUniformInverseBallot(Blob *blob,
941                                        IdResultType idResultType1,
942                                        IdResult idResult2,
943                                        IdScope execution,
944                                        IdRef value);
945 void WriteGroupNonUniformBallotBitExtract(Blob *blob,
946                                           IdResultType idResultType1,
947                                           IdResult idResult2,
948                                           IdScope execution,
949                                           IdRef value,
950                                           IdRef index);
951 void WriteGroupNonUniformBallotBitCount(Blob *blob,
952                                         IdResultType idResultType1,
953                                         IdResult idResult2,
954                                         IdScope execution,
955                                         spv::GroupOperation operation,
956                                         IdRef value);
957 void WriteGroupNonUniformBallotFindLSB(Blob *blob,
958                                        IdResultType idResultType1,
959                                        IdResult idResult2,
960                                        IdScope execution,
961                                        IdRef value);
962 void WriteGroupNonUniformBallotFindMSB(Blob *blob,
963                                        IdResultType idResultType1,
964                                        IdResult idResult2,
965                                        IdScope execution,
966                                        IdRef value);
967 void WriteGroupNonUniformShuffle(Blob *blob,
968                                  IdResultType idResultType1,
969                                  IdResult idResult2,
970                                  IdScope execution,
971                                  IdRef value,
972                                  IdRef id);
973 void WriteGroupNonUniformShuffleXor(Blob *blob,
974                                     IdResultType idResultType1,
975                                     IdResult idResult2,
976                                     IdScope execution,
977                                     IdRef value,
978                                     IdRef mask);
979 void WriteGroupNonUniformShuffleUp(Blob *blob,
980                                    IdResultType idResultType1,
981                                    IdResult idResult2,
982                                    IdScope execution,
983                                    IdRef value,
984                                    IdRef delta);
985 void WriteGroupNonUniformShuffleDown(Blob *blob,
986                                      IdResultType idResultType1,
987                                      IdResult idResult2,
988                                      IdScope execution,
989                                      IdRef value,
990                                      IdRef delta);
991 void WriteGroupNonUniformIAdd(Blob *blob,
992                               IdResultType idResultType1,
993                               IdResult idResult2,
994                               IdScope execution,
995                               spv::GroupOperation operation,
996                               IdRef value,
997                               const IdRef *clusterSize);
998 void WriteGroupNonUniformFAdd(Blob *blob,
999                               IdResultType idResultType1,
1000                               IdResult idResult2,
1001                               IdScope execution,
1002                               spv::GroupOperation operation,
1003                               IdRef value,
1004                               const IdRef *clusterSize);
1005 void WriteGroupNonUniformIMul(Blob *blob,
1006                               IdResultType idResultType1,
1007                               IdResult idResult2,
1008                               IdScope execution,
1009                               spv::GroupOperation operation,
1010                               IdRef value,
1011                               const IdRef *clusterSize);
1012 void WriteGroupNonUniformFMul(Blob *blob,
1013                               IdResultType idResultType1,
1014                               IdResult idResult2,
1015                               IdScope execution,
1016                               spv::GroupOperation operation,
1017                               IdRef value,
1018                               const IdRef *clusterSize);
1019 void WriteGroupNonUniformSMin(Blob *blob,
1020                               IdResultType idResultType1,
1021                               IdResult idResult2,
1022                               IdScope execution,
1023                               spv::GroupOperation operation,
1024                               IdRef value,
1025                               const IdRef *clusterSize);
1026 void WriteGroupNonUniformUMin(Blob *blob,
1027                               IdResultType idResultType1,
1028                               IdResult idResult2,
1029                               IdScope execution,
1030                               spv::GroupOperation operation,
1031                               IdRef value,
1032                               const IdRef *clusterSize);
1033 void WriteGroupNonUniformFMin(Blob *blob,
1034                               IdResultType idResultType1,
1035                               IdResult idResult2,
1036                               IdScope execution,
1037                               spv::GroupOperation operation,
1038                               IdRef value,
1039                               const IdRef *clusterSize);
1040 void WriteGroupNonUniformSMax(Blob *blob,
1041                               IdResultType idResultType1,
1042                               IdResult idResult2,
1043                               IdScope execution,
1044                               spv::GroupOperation operation,
1045                               IdRef value,
1046                               const IdRef *clusterSize);
1047 void WriteGroupNonUniformUMax(Blob *blob,
1048                               IdResultType idResultType1,
1049                               IdResult idResult2,
1050                               IdScope execution,
1051                               spv::GroupOperation operation,
1052                               IdRef value,
1053                               const IdRef *clusterSize);
1054 void WriteGroupNonUniformFMax(Blob *blob,
1055                               IdResultType idResultType1,
1056                               IdResult idResult2,
1057                               IdScope execution,
1058                               spv::GroupOperation operation,
1059                               IdRef value,
1060                               const IdRef *clusterSize);
1061 void WriteGroupNonUniformBitwiseAnd(Blob *blob,
1062                                     IdResultType idResultType1,
1063                                     IdResult idResult2,
1064                                     IdScope execution,
1065                                     spv::GroupOperation operation,
1066                                     IdRef value,
1067                                     const IdRef *clusterSize);
1068 void WriteGroupNonUniformBitwiseOr(Blob *blob,
1069                                    IdResultType idResultType1,
1070                                    IdResult idResult2,
1071                                    IdScope execution,
1072                                    spv::GroupOperation operation,
1073                                    IdRef value,
1074                                    const IdRef *clusterSize);
1075 void WriteGroupNonUniformBitwiseXor(Blob *blob,
1076                                     IdResultType idResultType1,
1077                                     IdResult idResult2,
1078                                     IdScope execution,
1079                                     spv::GroupOperation operation,
1080                                     IdRef value,
1081                                     const IdRef *clusterSize);
1082 void WriteGroupNonUniformLogicalAnd(Blob *blob,
1083                                     IdResultType idResultType1,
1084                                     IdResult idResult2,
1085                                     IdScope execution,
1086                                     spv::GroupOperation operation,
1087                                     IdRef value,
1088                                     const IdRef *clusterSize);
1089 void WriteGroupNonUniformLogicalOr(Blob *blob,
1090                                    IdResultType idResultType1,
1091                                    IdResult idResult2,
1092                                    IdScope execution,
1093                                    spv::GroupOperation operation,
1094                                    IdRef value,
1095                                    const IdRef *clusterSize);
1096 void WriteGroupNonUniformLogicalXor(Blob *blob,
1097                                     IdResultType idResultType1,
1098                                     IdResult idResult2,
1099                                     IdScope execution,
1100                                     spv::GroupOperation operation,
1101                                     IdRef value,
1102                                     const IdRef *clusterSize);
1103 void WriteGroupNonUniformQuadBroadcast(Blob *blob,
1104                                        IdResultType idResultType1,
1105                                        IdResult idResult2,
1106                                        IdScope execution,
1107                                        IdRef value,
1108                                        IdRef index);
1109 void WriteGroupNonUniformQuadSwap(Blob *blob,
1110                                   IdResultType idResultType1,
1111                                   IdResult idResult2,
1112                                   IdScope execution,
1113                                   IdRef value,
1114                                   IdRef direction);
1115 void WriteCopyLogical(Blob *blob, IdResultType idResultType1, IdResult idResult2, IdRef operand);
1116 void WritePtrEqual(Blob *blob,
1117                    IdResultType idResultType1,
1118                    IdResult idResult2,
1119                    IdRef operand1,
1120                    IdRef operand2);
1121 void WritePtrNotEqual(Blob *blob,
1122                       IdResultType idResultType1,
1123                       IdResult idResult2,
1124                       IdRef operand1,
1125                       IdRef operand2);
1126 void WriteSDot(Blob *blob,
1127                IdResultType idResultType1,
1128                IdResult idResult2,
1129                IdRef vector1,
1130                IdRef vector2,
1131                const spv::PackedVectorFormat *packedVectorFormat);
1132 void WriteUDot(Blob *blob,
1133                IdResultType idResultType1,
1134                IdResult idResult2,
1135                IdRef vector1,
1136                IdRef vector2,
1137                const spv::PackedVectorFormat *packedVectorFormat);
1138 void WriteSUDot(Blob *blob,
1139                 IdResultType idResultType1,
1140                 IdResult idResult2,
1141                 IdRef vector1,
1142                 IdRef vector2,
1143                 const spv::PackedVectorFormat *packedVectorFormat);
1144 void WriteSDotAccSat(Blob *blob,
1145                      IdResultType idResultType1,
1146                      IdResult idResult2,
1147                      IdRef vector1,
1148                      IdRef vector2,
1149                      IdRef accumulator,
1150                      const spv::PackedVectorFormat *packedVectorFormat);
1151 void WriteUDotAccSat(Blob *blob,
1152                      IdResultType idResultType1,
1153                      IdResult idResult2,
1154                      IdRef vector1,
1155                      IdRef vector2,
1156                      IdRef accumulator,
1157                      const spv::PackedVectorFormat *packedVectorFormat);
1158 void WriteSUDotAccSat(Blob *blob,
1159                       IdResultType idResultType1,
1160                       IdResult idResult2,
1161                       IdRef vector1,
1162                       IdRef vector2,
1163                       IdRef accumulator,
1164                       const spv::PackedVectorFormat *packedVectorFormat);
1165 void WriteBeginInvocationInterlockEXT(Blob *blob);
1166 void WriteEndInvocationInterlockEXT(Blob *blob);
1167 void WriteDemoteToHelperInvocation(Blob *blob);
1168 
1169 }  // namespace spirv
1170 }  // namespace angle
1171 
1172 #endif  // COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_
1173