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