source/operand.cpp

// Copyright (c) 2015 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and/or associated documentation files (the
// "Materials"), to deal in the Materials without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Materials, and to
// permit persons to whom the Materials are furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Materials.
//
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
//    https://www.khronos.org/registry/
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

#include "operand.h"

#include <assert.h>
#include <string.h>

static const spv_operand_desc_t sourceLanguageEntries[] = {
    {"Unknown",
     SourceLanguageUnknown,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"ESSL",
     SourceLanguageESSL,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"GLSL",
     SourceLanguageGLSL,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"OpenCL",
     SourceLanguageOpenCL,
     0,
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t executionModelEntries[] = {
    {"Vertex",
     ExecutionModelVertex,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"TessellationControl",
     ExecutionModelTessellationControl,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"TessellationEvaluation",
     ExecutionModelTessellationEvaluation,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"Geometry",
     ExecutionModelGeometry,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry),
     {SPV_OPERAND_TYPE_NONE}},
    {"Fragment",
     ExecutionModelFragment,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"GLCompute",
     ExecutionModelGLCompute,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Kernel",
     ExecutionModelKernel,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t addressingModelEntries[] = {
    {"Logical",
     AddressingModelLogical,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Physical32",
     AddressingModelPhysical32,
     SPV_CAPABILITY_AS_MASK(CapabilityAddresses),
     {SPV_OPERAND_TYPE_NONE}},
    {"Physical64",
     AddressingModelPhysical64,
     SPV_CAPABILITY_AS_MASK(CapabilityAddresses),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t memoryModelEntries[] = {
    {"Simple",
     MemoryModelSimple,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"GLSL450",
     MemoryModelGLSL450,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"OpenCL",
     MemoryModelOpenCL,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

// Execution mode requiring the given capability and having no operands.
#define ExecMode0(mode, cap)                                             \
  #mode, ExecutionMode##mode, SPV_CAPABILITY_AS_MASK(Capability##cap), { \
    SPV_OPERAND_TYPE_NONE                                                \
  }
// Execution mode requiring the given capability and having one literal number
// operand.
#define ExecMode1(mode, cap)                                             \
  #mode, ExecutionMode##mode, SPV_CAPABILITY_AS_MASK(Capability##cap), { \
    SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE               \
  }
static const spv_operand_desc_t executionModeEntries[] = {
    {ExecMode1(Invocations, Geometry)},
    {ExecMode0(SpacingEqual, Tessellation)},
    {ExecMode0(SpacingFractionalEven, Tessellation)},
    {ExecMode0(SpacingFractionalOdd, Tessellation)},
    {ExecMode0(VertexOrderCw, Tessellation)},
    {ExecMode0(VertexOrderCcw, Tessellation)},
    {ExecMode0(PixelCenterInteger, Shader)},
    {ExecMode0(OriginUpperLeft, Shader)},
    {ExecMode0(OriginLowerLeft, Shader)},
    {ExecMode0(EarlyFragmentTests, Shader)},
    {ExecMode0(PointMode, Tessellation)},
    {ExecMode0(Xfb, TransformFeedback)},
    {ExecMode0(DepthReplacing, Shader)},
    {ExecMode0(DepthGreater, Shader)},
    {ExecMode0(DepthLess, Shader)},
    {ExecMode0(DepthUnchanged, Shader)},
    {"LocalSize",
     ExecutionModeLocalSize,
     0,
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_LITERAL_NUMBER,
      SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"LocalSizeHint",
     ExecutionModeLocalSizeHint,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_LITERAL_NUMBER,
      SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {ExecMode0(InputPoints, Geometry)},
    {ExecMode0(InputLines, Geometry)},
    {ExecMode0(InputLinesAdjacency, Geometry)},
    {"InputTriangles",
     ExecutionModeInputTriangles,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry) |
         SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {ExecMode0(InputTrianglesAdjacency, Geometry)},
    {ExecMode0(InputQuads, Tessellation)},
    {ExecMode0(InputIsolines, Tessellation)},
    {"OutputVertices",
     ExecutionModeOutputVertices,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry) |
         SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {ExecMode0(OutputPoints, Geometry)},
    {ExecMode0(OutputLineStrip, Geometry)},
    {ExecMode0(OutputTriangleStrip, Geometry)},
    {ExecMode1(VecTypeHint, Kernel)},
    {ExecMode0(ContractionOff, Kernel)},
    {ExecMode0(IndependentForwardProgress, Kernel)},
};
#undef ExecMode0
#undef ExecMode1

static const spv_operand_desc_t storageClassEntries[] = {
    // TODO(dneto): There are more storage classes in Rev32 and later.
    {"UniformConstant",
     StorageClassUniformConstant,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Input",
     StorageClassInput,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Uniform",
     StorageClassUniform,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Output",
     StorageClassOutput,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupLocal",
     StorageClassWorkgroupLocal,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupGlobal",
     StorageClassWorkgroupGlobal,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"PrivateGlobal",
     StorageClassPrivateGlobal,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Function",
     StorageClassFunction,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Generic",
     StorageClassGeneric,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"PushConstant",
     StorageClassPushConstant,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"AtomicCounter",
     StorageClassAtomicCounter,
     SPV_CAPABILITY_AS_MASK(CapabilityAtomicStorage),
     {SPV_OPERAND_TYPE_NONE}},
    {"Image",
     StorageClassImage,
     0,
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t dimensionalityEntries[] = {
    {"1D",
     Dim1D,
     SPV_CAPABILITY_AS_MASK(CapabilitySampled1D),
     {SPV_OPERAND_TYPE_NONE}},
    {"2D", Dim2D, 0, {SPV_OPERAND_TYPE_NONE}},
    {"3D", Dim3D, 0, {SPV_OPERAND_TYPE_NONE}},
    {"Cube",
     DimCube,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Rect",
     DimRect,
     SPV_CAPABILITY_AS_MASK(CapabilitySampledRect),
     {SPV_OPERAND_TYPE_NONE}},
    {"Buffer",
     DimBuffer,
     SPV_CAPABILITY_AS_MASK(CapabilitySampledBuffer),
     {SPV_OPERAND_TYPE_NONE}},
    {"InputTarget",
     DimInputTarget,
     SPV_CAPABILITY_AS_MASK(CapabilityInputTarget),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t samplerAddressingModeEntries[] = {
    {"None",
     SamplerAddressingModeNone,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"ClampToEdge",
     SamplerAddressingModeClampToEdge,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Clamp",
     SamplerAddressingModeClamp,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Repeat",
     SamplerAddressingModeRepeat,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"RepeatMirrored",
     SamplerAddressingModeRepeatMirrored,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t samplerFilterModeEntries[] = {
    {"Nearest",
     SamplerFilterModeNearest,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Linear",
     SamplerFilterModeLinear,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t samplerImageFormatEntries[] = {
#define CASE0(NAME)                                        \
  {                                                        \
    #NAME, ImageFormat##NAME, 0, { SPV_OPERAND_TYPE_NONE } \
  }
#define CASE(NAME, CAP)                                                  \
  {                                                                      \
    #NAME, ImageFormat##NAME, SPV_CAPABILITY_AS_MASK(Capability##CAP), { \
      SPV_OPERAND_TYPE_NONE                                              \
    }                                                                    \
  }
    // clang-format off
  CASE0(Unknown),
  CASE(Rgba32f, Shader),
  CASE(Rgba16f, Shader),
  CASE(R32f, Shader),
  CASE(Rgba8, Shader),
  CASE(Rgba8Snorm, Shader),
  CASE(Rg32f, AdvancedFormats),
  CASE(Rg16f, AdvancedFormats),
  CASE(R11fG11fB10f, AdvancedFormats),
  CASE(R16f, AdvancedFormats),
  CASE(Rgba16, AdvancedFormats),
  CASE(Rgb10A2, AdvancedFormats),
  CASE(Rg16, AdvancedFormats),
  CASE(Rg8, AdvancedFormats),
  CASE(R16, AdvancedFormats),
  CASE(R8, AdvancedFormats),
  CASE(Rgba16Snorm, AdvancedFormats),
  CASE(Rg16Snorm, AdvancedFormats),
  CASE(Rg8Snorm, AdvancedFormats),
  CASE(R16Snorm, AdvancedFormats),
  CASE(R8Snorm, AdvancedFormats),
  CASE(Rgba32i, Shader),
  CASE(Rgba16i, Shader),
  CASE(Rgba8i, Shader),
  CASE(R32i, Shader),
  CASE(Rg32i, AdvancedFormats),
  CASE(Rg16i, AdvancedFormats),
  CASE(Rg8i, AdvancedFormats),
  CASE(R16i, AdvancedFormats),
  CASE(R8i, AdvancedFormats),
  CASE(Rgba32ui, Shader),
  CASE(Rgba16ui, Shader),
  CASE(Rgba8ui, Shader),
  CASE(R32ui, Shader),
  CASE(Rgb10a2ui, AdvancedFormats),
  CASE(Rg32ui, AdvancedFormats),
  CASE(Rg16ui, AdvancedFormats),
  CASE(Rg8ui, AdvancedFormats),
  CASE(R16ui, AdvancedFormats),
  CASE(R8ui, AdvancedFormats),
// clang-format on
#undef CASE
};

// All image channel orders depend on the Kernel capability.
#define CASE(NAME)                                                            \
  {                                                                           \
    #NAME, ImageChannelOrder##NAME, SPV_CAPABILITY_AS_MASK(CapabilityKernel), \
    {                                                                         \
      SPV_OPERAND_TYPE_NONE                                                   \
    }                                                                         \
  }
static const spv_operand_desc_t imageChannelOrderEntries[] = {
  CASE(R),
  CASE(A),
  CASE(RG),
  CASE(RA),
  CASE(RGB),
  CASE(RGBA),
  CASE(BGRA),
  CASE(ARGB),
  CASE(Intensity),
  CASE(Luminance),
  CASE(Rx),
  CASE(RGx),
  CASE(RGBx),
  CASE(Depth),
  CASE(DepthStencil),
  CASE(sRGB),
  CASE(sRGBx),
  CASE(sRGBA),
  CASE(sBGRA),
};
#undef CASE

// All image channel data types depend on the Kernel capability.
#define CASE(NAME)                                  \
  {                                                 \
    #NAME, ImageChannelDataType##NAME,              \
        SPV_CAPABILITY_AS_MASK(CapabilityKernel), { \
      SPV_OPERAND_TYPE_NONE                         \
    }                                               \
  }
static const spv_operand_desc_t imageChannelDataTypeEntries[] = {
  CASE(SnormInt8),
  CASE(SnormInt16),
  CASE(UnormInt8),
  CASE(UnormInt16),
  CASE(UnormShort565),
  CASE(UnormShort555),
  CASE(UnormInt101010),
  CASE(SignedInt8),
  CASE(SignedInt16),
  CASE(SignedInt32),
  CASE(UnsignedInt8),
  CASE(UnsignedInt16),
  CASE(UnsignedInt32),
  CASE(HalfFloat),
  CASE(Float),
  CASE(UnormInt24),
};
#undef CASE

// Image operand definitions.  Each enum value is a mask.  When that mask
// bit is set, the instruction should have further ID operands.
// Some mask values depend on a capability.
static const spv_operand_desc_t imageOperandEntries[] = {
// Rev32 and later adds many more enums.
#define CASE(NAME) \
  #NAME, spv::ImageOperands##NAME##Mask, 0
#define CASE_CAP(NAME, CAP) \
  #NAME, spv::ImageOperands##NAME##Mask, CAP
#define ID SPV_OPERAND_TYPE_ID
#define NONE SPV_OPERAND_TYPE_NONE
    {"None", spv::ImageOperandsMaskNone, 0, {NONE}},
    {CASE_CAP(Bias, SPV_CAPABILITY_AS_MASK(CapabilityShader)), {ID, NONE}},
    {CASE(Lod), {ID, NONE}},
    {CASE(Grad), {ID, ID, NONE}},
    {CASE(ConstOffset), {ID, NONE}},
    {CASE_CAP(Offset, SPV_CAPABILITY_AS_MASK(CapabilityImageGatherExtended)),
     {ID, NONE}},
    {CASE(ConstOffsets), {ID, NONE}},
    {CASE(Sample), {ID, NONE}},
    {CASE_CAP(MinLod, SPV_CAPABILITY_AS_MASK(CapabilityMinLod)), {ID, NONE}},
#undef CASE
#undef CASE_CAP
#undef ID
#undef NONE
};

static const spv_operand_desc_t fpFastMathModeEntries[] = {
    {"None",
     FPFastMathModeMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"NotNaN",
     FPFastMathModeNotNaNMask,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NotInf",
     FPFastMathModeNotInfMask,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NSZ",
     FPFastMathModeNSZMask,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"AllowRecip",
     FPFastMathModeAllowRecipMask,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Fast",
     FPFastMathModeFastMask,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t fpRoundingModeEntries[] = {
    {"RTE",
     FPRoundingModeRTE,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"RTZ",
     FPRoundingModeRTZ,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"RTP",
     FPRoundingModeRTP,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"RTN",
     FPRoundingModeRTN,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t linkageTypeEntries[] = {
    {"Export",
     LinkageTypeExport,
     SPV_CAPABILITY_AS_MASK(CapabilityLinkage),
     {SPV_OPERAND_TYPE_NONE}},
    {"Import",
     LinkageTypeImport,
     SPV_CAPABILITY_AS_MASK(CapabilityLinkage),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t accessQualifierEntries[] = {
    {"ReadOnly",
     AccessQualifierReadOnly,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"WriteOnly",
     AccessQualifierWriteOnly,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"ReadWrite",
     AccessQualifierReadWrite,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t functionParameterAttributeEntries[] = {
    {"Zext",
     FunctionParameterAttributeZext,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Sext",
     FunctionParameterAttributeSext,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"ByVal",
     FunctionParameterAttributeByVal,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Sret",
     FunctionParameterAttributeSret,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NoAlias",
     FunctionParameterAttributeNoAlias,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NoCapture",
     FunctionParameterAttributeNoCapture,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NoWrite",
     FunctionParameterAttributeNoWrite,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NoReadWrite",
     FunctionParameterAttributeNoReadWrite,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t decorationEntries[] = {
    {"RelaxedPrecision",
     DecorationRelaxedPrecision,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {
        "SpecId",
        DecorationSpecId,
        SPV_CAPABILITY_AS_MASK(CapabilityShader),
        {SPV_OPERAND_TYPE_LITERAL_NUMBER},
    },
    {"Block",
     DecorationBlock,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"BufferBlock",
     DecorationBufferBlock,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"RowMajor",
     DecorationRowMajor,
     SPV_CAPABILITY_AS_MASK(CapabilityMatrix),
     {SPV_OPERAND_TYPE_NONE}},
    {"ColMajor",
     DecorationColMajor,
     SPV_CAPABILITY_AS_MASK(CapabilityMatrix),
     {SPV_OPERAND_TYPE_NONE}},
    {"ArrayStride",
     DecorationArrayStride,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"MatrixStride",
     DecorationMatrixStride,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"GLSLShared",
     DecorationGLSLShared,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"GLSLPacked",
     DecorationGLSLPacked,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"CPacked",
     DecorationCPacked,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"BuiltIn",
     DecorationBuiltIn,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_BUILT_IN, SPV_OPERAND_TYPE_NONE}},
    {"Smooth",
     DecorationSmooth,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"NoPerspective",
     DecorationNoPerspective,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Flat",
     DecorationFlat,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Patch",
     DecorationPatch,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"Centroid",
     DecorationCentroid,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Sample",
     DecorationSample,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Invariant",
     DecorationInvariant,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"Restrict",
     DecorationRestrict,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Aliased",
     DecorationAliased,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Volatile",
     DecorationVolatile,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Constant",
     DecorationConstant,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Coherent",
     DecorationCoherent,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"NonWritable",
     DecorationNonWritable,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"NonReadable",
     DecorationNonReadable,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Uniform",
     DecorationUniform,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"SaturatedConversion",
     DecorationSaturatedConversion,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"Stream",
     DecorationStream,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"Location",
     DecorationLocation,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"Component",
     DecorationComponent,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"Index",
     DecorationIndex,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"Binding",
     DecorationBinding,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"DescriptorSet",
     DecorationDescriptorSet,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"Offset",
     DecorationOffset,
     0,
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"XfbBuffer",
     DecorationXfbBuffer,
     SPV_CAPABILITY_AS_MASK(CapabilityTransformFeedback),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"XfbStride",
     DecorationXfbStride,
     SPV_CAPABILITY_AS_MASK(CapabilityTransformFeedback),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
    {"FuncParamAttr",
     DecorationFuncParamAttr,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE, SPV_OPERAND_TYPE_NONE}},
    {"FPRoundingMode",
     DecorationFPRoundingMode,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_NONE}},
    {"FPFastMathMode",
     DecorationFPFastMathMode,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, SPV_OPERAND_TYPE_NONE}},
    {"LinkageAttributes",
     DecorationLinkageAttributes,
     SPV_CAPABILITY_AS_MASK(CapabilityLinkage),
     {SPV_OPERAND_TYPE_LITERAL_STRING, SPV_OPERAND_TYPE_LINKAGE_TYPE,
      SPV_OPERAND_TYPE_NONE}},
    {"NoContraction",
     DecorationNoContraction,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"InputTargetIndex",
     DecorationInputTargetIndex,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),  // TODO(dneto): Should this be
                                                // CapabilityInputTarget?
     {SPV_OPERAND_TYPE_NONE}},  // TODO(dneto): Should this have a literal
                                // number argument?
    {"Alignment",
     DecorationAlignment,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t builtInEntries[] = {
    {"Position",
     BuiltInPosition,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"PointSize",
     BuiltInPointSize,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"ClipDistance",
     BuiltInClipDistance,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"CullDistance",
     BuiltInCullDistance,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"VertexId",
     BuiltInVertexId,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"InstanceId",
     BuiltInInstanceId,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"PrimitiveId",
     BuiltInPrimitiveId,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry) |
         SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"InvocationId",
     BuiltInInvocationId,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry) |
         SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"Layer",
     BuiltInLayer,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry),
     {SPV_OPERAND_TYPE_NONE}},
    {"ViewportIndex",
     BuiltInViewportIndex,
     SPV_CAPABILITY_AS_MASK(CapabilityGeometry),
     {SPV_OPERAND_TYPE_NONE}},
    {"TessLevelOuter",
     BuiltInTessLevelOuter,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"TessLevelInner",
     BuiltInTessLevelInner,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"TessCoord",
     BuiltInTessCoord,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"PatchVertices",
     BuiltInPatchVertices,
     SPV_CAPABILITY_AS_MASK(CapabilityTessellation),
     {SPV_OPERAND_TYPE_NONE}},
    {"FragCoord",
     BuiltInFragCoord,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"PointCoord",
     BuiltInPointCoord,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"FrontFacing",
     BuiltInFrontFacing,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"SampleId",
     BuiltInSampleId,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"SamplePosition",
     BuiltInSamplePosition,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"SampleMask",
     BuiltInSampleMask,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"FragColor",
     BuiltInFragColor,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"FragDepth",
     BuiltInFragDepth,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"HelperInvocation",
     BuiltInHelperInvocation,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"NumWorkgroups",
     BuiltInNumWorkgroups,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupSize",
     BuiltInWorkgroupSize,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupId",
     BuiltInWorkgroupId,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"LocalInvocationId",
     BuiltInLocalInvocationId,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"GlobalInvocationId",
     BuiltInGlobalInvocationId,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"LocalInvocationIndex",
     BuiltInLocalInvocationIndex,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkDim",
     BuiltInWorkDim,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"GlobalSize",
     BuiltInGlobalSize,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"EnqueuedWorkgroupSize",
     BuiltInEnqueuedWorkgroupSize,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"GlobalOffset",
     BuiltInGlobalOffset,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"GlobalLinearId",
     BuiltInGlobalLinearId,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupLinearId",
     BuiltInWorkgroupLinearId,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"SubgroupSize",
     BuiltInSubgroupSize,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"SubgroupMaxSize",
     BuiltInSubgroupMaxSize,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NumSubgroups",
     BuiltInNumSubgroups,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"NumEnqueuedSubgroups",
     BuiltInNumEnqueuedSubgroups,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"SubgroupId",
     BuiltInSubgroupId,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"SubgroupLocalInvocationId",
     BuiltInSubgroupLocalInvocationId,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"VertexIndex",
     BuiltInVertexIndex,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"InstanceIndex",
     BuiltInInstanceIndex,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t selectionControlEntries[] = {
    {"None",
     SelectionControlMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Flatten",
     SelectionControlFlattenMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"DontFlatten",
     SelectionControlDontFlattenMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t loopControlEntries[] = {
    {"None",
     LoopControlMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Unroll",
     LoopControlUnrollMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"DontUnroll",
     LoopControlDontUnrollMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t functionControlEntries[] = {
    {"None",
     FunctionControlMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Inline",
     FunctionControlInlineMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"DontInline",
     FunctionControlDontInlineMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Pure",
     FunctionControlPureMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Const",
     FunctionControlConstMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t memorySemanticsEntries[] = {
    // "Relaxed" should be a synonym for "None".
    // Put the Relaxed entry first so that the disassembler
    // will prefer to emit "Relaxed".
    {"Relaxed",
     MemorySemanticsMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"None",
     MemorySemanticsMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"SequentiallyConsistent",
     MemorySemanticsSequentiallyConsistentMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Acquire",
     MemorySemanticsAcquireMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Release",
     MemorySemanticsReleaseMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"UniformMemory",
     MemorySemanticsUniformMemoryMask,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {"SubgroupMemory",
     MemorySemanticsSubgroupMemoryMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupLocalMemory",
     MemorySemanticsWorkgroupLocalMemoryMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"WorkgroupGlobalMemory",
     MemorySemanticsWorkgroupGlobalMemoryMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"AtomicCounterMemory",
     MemorySemanticsAtomicCounterMemoryMask,
     SPV_CAPABILITY_AS_MASK(CapabilityShader),
     {SPV_OPERAND_TYPE_NONE}},
    {
        "ImageMemory",
        MemorySemanticsImageMemoryMask,
        0,
        {SPV_OPERAND_TYPE_NONE},
    },
};

static const spv_operand_desc_t memoryAccessEntries[] = {
    {"None",
     MemoryAccessMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Volatile",
     MemoryAccessVolatileMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {
        "Aligned",
        MemoryAccessAlignedMask,
        0,
        {SPV_OPERAND_TYPE_LITERAL_NUMBER, SPV_OPERAND_TYPE_NONE},
    },
    {"Nontemporal",
     MemoryAccessNontemporalMask,
     0,
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t scopeEntries[] = {
    {"CrossDevice",
     ScopeCrossDevice,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Device", ScopeDevice, 0, {SPV_OPERAND_TYPE_NONE}},
    {"Workgroup",
     ScopeWorkgroup,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"Subgroup",
     ScopeSubgroup,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {
        "Invocation",
        ScopeInvocation,
        0,
        {SPV_OPERAND_TYPE_NONE},
    },
};

static const spv_operand_desc_t groupOperationEntries[] = {
    {"Reduce",
     GroupOperationReduce,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"InclusiveScan",
     GroupOperationInclusiveScan,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"ExclusiveScan",
     GroupOperationExclusiveScan,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t kernelKernelEnqueueFlagssEntries[] = {
    {"NoWait",
     KernelEnqueueFlagsNoWait,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"WaitKernel",
     KernelEnqueueFlagsWaitKernel,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
    {"WaitWorkGroup",
     KernelEnqueueFlagsWaitWorkGroup,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

static const spv_operand_desc_t kernelProfilingInfoEntries[] = {
    {"None",
     KernelProfilingInfoMaskNone,
     0,
     {SPV_OPERAND_TYPE_NONE}},
    {"CmdExecTime",
     KernelProfilingInfoCmdExecTimeMask,
     SPV_CAPABILITY_AS_MASK(CapabilityKernel),
     {SPV_OPERAND_TYPE_NONE}},
};

// A macro for defining a capability that doesn't depend on another capability.
#define CASE(NAME)                                        \
  {                                                       \
    #NAME, Capability##NAME, 0, { SPV_OPERAND_TYPE_NONE } \
  }

// A macro for defining a capability that depends on another.
#define CASE_CAP(NAME, CAP)                                             \
  {                                                                     \
    #NAME, Capability##NAME, SPV_CAPABILITY_AS_MASK(Capability##CAP), { \
      SPV_OPERAND_TYPE_NONE                                             \
    }                                                                   \
  }

static const spv_operand_desc_t capabilityInfoEntries[] = {
    CASE(Matrix),
    CASE_CAP(Shader, Matrix),
    CASE_CAP(Geometry, Shader),
    CASE_CAP(Tessellation, Shader),
    CASE(Addresses),
    CASE(Linkage),
    CASE(Kernel),
    CASE_CAP(Vector16, Kernel),
    CASE_CAP(Float16Buffer, Kernel),
    CASE_CAP(Float16, Float16Buffer),
    CASE(Float64),
    CASE(Int64),
    CASE_CAP(Int64Atomics, Int64),
    CASE_CAP(ImageBasic, Kernel),
    CASE_CAP(ImageReadWrite, Kernel),
    CASE_CAP(ImageMipmap, Kernel),
    CASE_CAP(ImageSRGBWrite, Kernel),
    CASE_CAP(Pipes, Kernel),
    CASE(Groups),
    CASE_CAP(DeviceEnqueue, Kernel),
    CASE_CAP(LiteralSampler, Kernel),
    CASE_CAP(AtomicStorage, Shader),
    CASE(Int16),
    CASE_CAP(TessellationPointSize, Tessellation),
    CASE_CAP(GeometryPointSize, Geometry),
    CASE_CAP(ImageGatherExtended, Shader),
    CASE_CAP(StorageImageExtendedFormats, Shader),
    CASE_CAP(StorageImageMultisample, Shader),
    CASE_CAP(UniformBufferArrayDynamicIndexing, Shader),
    CASE_CAP(SampledImageArrayDynamicIndexing, Shader),
    CASE_CAP(StorageBufferArrayDynamicIndexing, Shader),
    CASE_CAP(StorageImageArrayDynamicIndexing, Shader),
    CASE_CAP(ClipDistance, Shader),
    CASE_CAP(CullDistance, Shader),
    CASE_CAP(ImageCubeArray, SampledCubeArray),
    CASE_CAP(SampleRateShading, Shader),
    CASE_CAP(ImageRect, SampledRect),
    CASE_CAP(SampledRect, Shader),
    CASE_CAP(GenericPointer, Addresses),
    CASE_CAP(Int8, Kernel),
    CASE_CAP(InputTarget, Shader),
    CASE_CAP(SparseResidency, Shader),
    CASE_CAP(MinLod, Shader),
    CASE_CAP(Sampled1D, Shader),
    CASE_CAP(Image1D, Sampled1D),
    CASE_CAP(SampledCubeArray, Shader),
    CASE_CAP(SampledBuffer, Shader),
    CASE_CAP(ImageBuffer, SampledBuffer),
    CASE_CAP(ImageMSArray, Shader),
    CASE_CAP(AdvancedFormats, Shader),
    CASE_CAP(ImageQuery, Shader),
    CASE_CAP(DerivativeControl, Shader),
    CASE_CAP(InterpolationFunction, Shader),
    CASE_CAP(TransformFeedback, Shader),
};
#undef CASE
#undef CASE_CAP

static const spv_operand_desc_group_t opcodeEntryTypes[] = {
    {SPV_OPERAND_TYPE_SOURCE_LANGUAGE,
     sizeof(sourceLanguageEntries) / sizeof(spv_operand_desc_t),
     sourceLanguageEntries},
    {SPV_OPERAND_TYPE_EXECUTION_MODEL,
     sizeof(executionModelEntries) / sizeof(spv_operand_desc_t),
     executionModelEntries},
    {SPV_OPERAND_TYPE_ADDRESSING_MODEL,
     sizeof(addressingModelEntries) / sizeof(spv_operand_desc_t),
     addressingModelEntries},
    {SPV_OPERAND_TYPE_MEMORY_MODEL,
     sizeof(memoryModelEntries) / sizeof(spv_operand_desc_t),
     memoryModelEntries},
    {SPV_OPERAND_TYPE_EXECUTION_MODE,
     sizeof(executionModeEntries) / sizeof(spv_operand_desc_t),
     executionModeEntries},
    {SPV_OPERAND_TYPE_STORAGE_CLASS,
     sizeof(storageClassEntries) / sizeof(spv_operand_desc_t),
     storageClassEntries},
    {SPV_OPERAND_TYPE_DIMENSIONALITY,
     sizeof(dimensionalityEntries) / sizeof(spv_operand_desc_t),
     dimensionalityEntries},
    {SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE,
     sizeof(samplerAddressingModeEntries) / sizeof(spv_operand_desc_t),
     samplerAddressingModeEntries},
    {SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE,
     sizeof(samplerFilterModeEntries) / sizeof(spv_operand_desc_t),
     samplerFilterModeEntries},
    {SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT,
     sizeof(samplerImageFormatEntries) / sizeof(spv_operand_desc_t),
     samplerImageFormatEntries},
    {SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER,
     sizeof(imageChannelOrderEntries) / sizeof(spv_operand_desc_t),
     imageChannelOrderEntries},
    {SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE,
     sizeof(imageChannelDataTypeEntries) / sizeof(spv_operand_desc_t),
     imageChannelDataTypeEntries},
    {SPV_OPERAND_TYPE_OPTIONAL_IMAGE,
     sizeof(imageOperandEntries) / sizeof(spv_operand_desc_t),
     imageOperandEntries},
    {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE,
     sizeof(fpFastMathModeEntries) / sizeof(spv_operand_desc_t),
     fpFastMathModeEntries},
    {SPV_OPERAND_TYPE_FP_ROUNDING_MODE,
     sizeof(fpRoundingModeEntries) / sizeof(spv_operand_desc_t),
     fpRoundingModeEntries},
    {SPV_OPERAND_TYPE_LINKAGE_TYPE,
     sizeof(linkageTypeEntries) / sizeof(spv_operand_desc_t),
     linkageTypeEntries},
    {SPV_OPERAND_TYPE_ACCESS_QUALIFIER,
     sizeof(accessQualifierEntries) / sizeof(spv_operand_desc_t),
     accessQualifierEntries},
    {SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
     sizeof(functionParameterAttributeEntries) / sizeof(spv_operand_desc_t),
     functionParameterAttributeEntries},
    {SPV_OPERAND_TYPE_DECORATION,
     sizeof(decorationEntries) / sizeof(spv_operand_desc_t), decorationEntries},
    {SPV_OPERAND_TYPE_BUILT_IN,
     sizeof(builtInEntries) / sizeof(spv_operand_desc_t), builtInEntries},
    {SPV_OPERAND_TYPE_SELECTION_CONTROL,
     sizeof(selectionControlEntries) / sizeof(spv_operand_desc_t),
     selectionControlEntries},
    {SPV_OPERAND_TYPE_LOOP_CONTROL,
     sizeof(loopControlEntries) / sizeof(spv_operand_desc_t),
     loopControlEntries},
    {SPV_OPERAND_TYPE_FUNCTION_CONTROL,
     sizeof(functionControlEntries) / sizeof(spv_operand_desc_t),
     functionControlEntries},
    {SPV_OPERAND_TYPE_MEMORY_SEMANTICS,
     sizeof(memorySemanticsEntries) / sizeof(spv_operand_desc_t),
     memorySemanticsEntries},
    {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS,
     sizeof(memoryAccessEntries) / sizeof(spv_operand_desc_t),
     memoryAccessEntries},
    {SPV_OPERAND_TYPE_EXECUTION_SCOPE,
     sizeof(scopeEntries) / sizeof(spv_operand_desc_t), scopeEntries},
    {SPV_OPERAND_TYPE_GROUP_OPERATION,
     sizeof(groupOperationEntries) / sizeof(spv_operand_desc_t),
     groupOperationEntries},
    {SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS,
     sizeof(kernelKernelEnqueueFlagssEntries) / sizeof(spv_operand_desc_t),
     kernelKernelEnqueueFlagssEntries},
    {SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO,
     sizeof(kernelProfilingInfoEntries) / sizeof(spv_operand_desc_t),
     kernelProfilingInfoEntries},
    {SPV_OPERAND_TYPE_CAPABILITY,
     sizeof(capabilityInfoEntries) / sizeof(spv_operand_desc_t),
     capabilityInfoEntries},
};

spv_result_t spvOperandTableGet(spv_operand_table* pOperandTable) {
  if (!pOperandTable) return SPV_ERROR_INVALID_POINTER;

  static const spv_operand_table_t table = {
      sizeof(opcodeEntryTypes) / sizeof(spv_operand_desc_group_t),
      opcodeEntryTypes};

  *pOperandTable = &table;

  return SPV_SUCCESS;
}

spv_result_t spvOperandTableNameLookup(const spv_operand_table table,
                                       const spv_operand_type_t type,
                                       const char* name,
                                       const size_t nameLength,
                                       spv_operand_desc* pEntry) {
  if (!table) return SPV_ERROR_INVALID_TABLE;
  if (!name || !pEntry) return SPV_ERROR_INVALID_POINTER;

  for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) {
    if (type == table->types[typeIndex].type) {
      for (uint64_t operandIndex = 0;
           operandIndex < table->types[typeIndex].count; ++operandIndex) {
        if (nameLength ==
                strlen(table->types[typeIndex].entries[operandIndex].name) &&
            !strncmp(table->types[typeIndex].entries[operandIndex].name, name,
                     nameLength)) {
          *pEntry = &table->types[typeIndex].entries[operandIndex];
          return SPV_SUCCESS;
        }
      }
    }
  }

  return SPV_ERROR_INVALID_LOOKUP;
}

spv_result_t spvOperandTableValueLookup(const spv_operand_table table,
                                        const spv_operand_type_t type,
                                        const uint32_t value,
                                        spv_operand_desc* pEntry) {
  if (!table) return SPV_ERROR_INVALID_TABLE;
  if (!pEntry) return SPV_ERROR_INVALID_POINTER;

  for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) {
    if (type == table->types[typeIndex].type) {
      for (uint64_t operandIndex = 0;
           operandIndex < table->types[typeIndex].count; ++operandIndex) {
        if (value == table->types[typeIndex].entries[operandIndex].value) {
          *pEntry = &table->types[typeIndex].entries[operandIndex];
          return SPV_SUCCESS;
        }
      }
    }
  }

  return SPV_ERROR_INVALID_LOOKUP;
}

const char* spvOperandTypeStr(spv_operand_type_t type) {
  switch (type) {
    case SPV_OPERAND_TYPE_ID:
    case SPV_OPERAND_TYPE_OPTIONAL_ID:
    case SPV_OPERAND_TYPE_ID_IN_OPTIONAL_TUPLE:
      return "ID";
    case SPV_OPERAND_TYPE_RESULT_ID:
      return "result ID";
    case SPV_OPERAND_TYPE_LITERAL_NUMBER:
      return "literal number";
    case SPV_OPERAND_TYPE_MULTIWORD_LITERAL_NUMBER:
      return "multiple word literal number";
    case SPV_OPERAND_TYPE_LITERAL_STRING:
      return "literal string";
    case SPV_OPERAND_TYPE_SOURCE_LANGUAGE:
      return "source language";
    case SPV_OPERAND_TYPE_EXECUTION_MODEL:
      return "execution model";
    case SPV_OPERAND_TYPE_ADDRESSING_MODEL:
      return "addressing model";
    case SPV_OPERAND_TYPE_MEMORY_MODEL:
      return "memory model";
    case SPV_OPERAND_TYPE_EXECUTION_MODE:
      return "execution mode";
    case SPV_OPERAND_TYPE_STORAGE_CLASS:
      return "storage class";
    case SPV_OPERAND_TYPE_DIMENSIONALITY:
      return "dimensionality";
    case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE:
      return "addressing mode";
    case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE:
      return "sampler filter mode";
    case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT:
      return "image format";
    case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE:
      return "floating pointer fast math mode";
    case SPV_OPERAND_TYPE_FP_ROUNDING_MODE:
      return "floating point rounding mode";
    case SPV_OPERAND_TYPE_LINKAGE_TYPE:
      return "linkage type";
    case SPV_OPERAND_TYPE_ACCESS_QUALIFIER:
      return "access qualifier";
    case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE:
      return "function parameter attribute";
    case SPV_OPERAND_TYPE_DECORATION:
      return "decoration";
    case SPV_OPERAND_TYPE_BUILT_IN:
      return "built in";
    case SPV_OPERAND_TYPE_SELECTION_CONTROL:
      return "selection control";
    case SPV_OPERAND_TYPE_LOOP_CONTROL:
      return "loop control";
    case SPV_OPERAND_TYPE_FUNCTION_CONTROL:
      return "function control";
    case SPV_OPERAND_TYPE_MEMORY_SEMANTICS:
      return "memory semantics";
    case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS:
      return "memory access";
    case SPV_OPERAND_TYPE_EXECUTION_SCOPE:
      return "execution scope ID";
    case SPV_OPERAND_TYPE_GROUP_OPERATION:
      return "group operation";
    case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS:
      return "kernel enqeue flags";
    case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO:
      return "kernel profiling info";
    case SPV_OPERAND_TYPE_CAPABILITY:
      return "capability";
    case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
      return "image operand";
    case SPV_OPERAND_TYPE_NONE:
      return "NONE";
    default:
      assert(0 && "Unhandled operand type!");
      break;
  }
  return "unknown";
}

void spvPrependOperandTypes(const spv_operand_type_t* types,
                            spv_operand_pattern_t* pattern) {
  const spv_operand_type_t* endTypes;
  for (endTypes = types; *endTypes != SPV_OPERAND_TYPE_NONE; ++endTypes)
    ;
  pattern->insert(pattern->begin(), types, endTypes);
}

void spvPrependOperandTypesForMask(const spv_operand_table operandTable,
                                   const spv_operand_type_t type,
                                   const uint32_t mask,
                                   spv_operand_pattern_t* pattern) {
  // Scan from highest bits to lowest bits because we will prepend in LIFO
  // fashion, and we need the operands for lower order bits to appear first.
  for (uint32_t candidate_bit = (1 << 31); candidate_bit; candidate_bit >>= 1) {
    if (candidate_bit & mask) {
      spv_operand_desc entry = nullptr;
      if (SPV_SUCCESS == spvOperandTableValueLookup(operandTable, type,
                                                    candidate_bit, &entry)) {
        spvPrependOperandTypes(entry->operandTypes, pattern);
      }
    }
  }
}

bool spvOperandIsOptional(spv_operand_type_t type) {
  // Variable means zero or more times.
  if (spvOperandIsVariable(type)) return true;

  switch (type) {
    case SPV_OPERAND_TYPE_OPTIONAL_ID:
    case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
    case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER:
    case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING:
    case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS:
    case SPV_OPERAND_TYPE_OPTIONAL_EXECUTION_MODE:
    case SPV_OPERAND_TYPE_OPTIONAL_CIV:
      return true;
    default:
      break;
  }
  return false;
}

bool spvOperandIsVariable(spv_operand_type_t type) {
  switch (type) {
    case SPV_OPERAND_TYPE_VARIABLE_ID:
    case SPV_OPERAND_TYPE_VARIABLE_LITERAL_NUMBER:
    case SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_NUMBER:
    case SPV_OPERAND_TYPE_VARIABLE_LITERAL_NUMBER_ID:
    case SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE:
      return true;
    default:
      break;
  }
  return false;
}

bool spvExpandOperandSequenceOnce(spv_operand_type_t type,
                                  spv_operand_pattern_t* pattern) {
  switch (type) {
    case SPV_OPERAND_TYPE_VARIABLE_ID:
      pattern->insert(pattern->begin(), {SPV_OPERAND_TYPE_OPTIONAL_ID, type});
      return true;
    case SPV_OPERAND_TYPE_VARIABLE_LITERAL_NUMBER:
      pattern->insert(pattern->begin(),
                      {SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER, type});
      return true;
    case SPV_OPERAND_TYPE_VARIABLE_LITERAL_NUMBER_ID:
      // Represents Zero or more (Literal number, Id) pairs.
      pattern->insert(pattern->begin(),
                      {SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER,
                       SPV_OPERAND_TYPE_ID_IN_OPTIONAL_TUPLE, type});
      return true;
    case SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_NUMBER:
      // Represents Zero or more (Id, Literal number) pairs.
      pattern->insert(
          pattern->begin(),
          {SPV_OPERAND_TYPE_OPTIONAL_ID,
           SPV_OPERAND_TYPE_LITERAL_NUMBER_IN_OPTIONAL_TUPLE, type});
      return true;
    case SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE:
      pattern->insert(pattern->begin(),
                      {SPV_OPERAND_TYPE_OPTIONAL_EXECUTION_MODE, type});
      return true;
    default:
      break;
  }
  return false;
}

spv_operand_type_t spvTakeFirstMatchableOperand(
    spv_operand_pattern_t* pattern) {
  assert(!pattern->empty());
  spv_operand_type_t result;
  do {
    result = pattern->front();
    pattern->pop_front();
  } while (spvExpandOperandSequenceOnce(result, pattern));
  return result;
}

spv_operand_pattern_t spvAlternatePatternFollowingImmediate(
    const spv_operand_pattern_t& pattern) {
  spv_operand_pattern_t alternatePattern;
  for (const auto& operand : pattern) {
    if (operand == SPV_OPERAND_TYPE_RESULT_ID) {
      alternatePattern.push_back(operand);
      alternatePattern.push_back(SPV_OPERAND_TYPE_OPTIONAL_CIV);
      return alternatePattern;
    }
    alternatePattern.push_back(SPV_OPERAND_TYPE_OPTIONAL_CIV);
  }
  // No result-id found, so just expect CIVs.
  return {SPV_OPERAND_TYPE_OPTIONAL_CIV};
}