From 0f34603cfcf4492420f9cbfa7c98381110e3ceda Mon Sep 17 00:00:00 2001
From: Eliza Velasquez <exv@google.com>
Date: Wed, 14 Feb 2024 17:11:24 -0800
Subject: [PATCH] stringify stuff

---
 libs/glslkomi/include/glslkomi/Komi.h |  876 +---------------
 libs/glslkomi/src/Komi.cpp            | 1365 ++++++++++++-------------
 2 files changed, 670 insertions(+), 1571 deletions(-)

diff --git a/libs/glslkomi/include/glslkomi/Komi.h b/libs/glslkomi/include/glslkomi/Komi.h
index 5587151bd7..debd9c0431 100644
--- a/libs/glslkomi/include/glslkomi/Komi.h
+++ b/libs/glslkomi/include/glslkomi/Komi.h
@@ -39,16 +39,12 @@ enum class BranchOperator : uint8_t {
     Default,
 };
 
+// Represents an operation whose syntax differs from a function call. For example, addition,
+// equality. GLSL is not Lisp, unfortunately.
 enum class RValueOperator : uint16_t {
-    Ternary,
-
-    //
-    // Unary operators
-    //
-
+    // Unary
     Negative,
     LogicalNot,
-    VectorLogicalNot,
     BitwiseNot,
 
     PostIncrement,
@@ -56,212 +52,7 @@ enum class RValueOperator : uint16_t {
     PreIncrement,
     PreDecrement,
 
-    CopyObject,
-
-    Declare,        // Used by debugging to force declaration of variable in correct scope
-
-    // (u)int* -> bool
-    ConvInt8ToBool,
-    ConvUint8ToBool,
-    ConvInt16ToBool,
-    ConvUint16ToBool,
-    ConvIntToBool,
-    ConvUintToBool,
-    ConvInt64ToBool,
-    ConvUint64ToBool,
-
-    // float* -> bool
-    ConvFloat16ToBool,
-    ConvFloatToBool,
-    ConvDoubleToBool,
-
-    // bool -> (u)int*
-    ConvBoolToInt8,
-    ConvBoolToUint8,
-    ConvBoolToInt16,
-    ConvBoolToUint16,
-    ConvBoolToInt,
-    ConvBoolToUint,
-    ConvBoolToInt64,
-    ConvBoolToUint64,
-
-    // bool -> float*
-    ConvBoolToFloat16,
-    ConvBoolToFloat,
-    ConvBoolToDouble,
-
-    // int8_t -> (u)int*
-    ConvInt8ToInt16,
-    ConvInt8ToInt,
-    ConvInt8ToInt64,
-    ConvInt8ToUint8,
-    ConvInt8ToUint16,
-    ConvInt8ToUint,
-    ConvInt8ToUint64,
-
-    // uint8_t -> (u)int*
-    ConvUint8ToInt8,
-    ConvUint8ToInt16,
-    ConvUint8ToInt,
-    ConvUint8ToInt64,
-    ConvUint8ToUint16,
-    ConvUint8ToUint,
-    ConvUint8ToUint64,
-
-    // int8_t -> float*
-    ConvInt8ToFloat16,
-    ConvInt8ToFloat,
-    ConvInt8ToDouble,
-
-    // uint8_t -> float*
-    ConvUint8ToFloat16,
-    ConvUint8ToFloat,
-    ConvUint8ToDouble,
-
-    // int16_t -> (u)int*
-    ConvInt16ToInt8,
-    ConvInt16ToInt,
-    ConvInt16ToInt64,
-    ConvInt16ToUint8,
-    ConvInt16ToUint16,
-    ConvInt16ToUint,
-    ConvInt16ToUint64,
-
-    // uint16_t -> (u)int*
-    ConvUint16ToInt8,
-    ConvUint16ToInt16,
-    ConvUint16ToInt,
-    ConvUint16ToInt64,
-    ConvUint16ToUint8,
-    ConvUint16ToUint,
-    ConvUint16ToUint64,
-
-    // int16_t -> float*
-    ConvInt16ToFloat16,
-    ConvInt16ToFloat,
-    ConvInt16ToDouble,
-
-    // uint16_t -> float*
-    ConvUint16ToFloat16,
-    ConvUint16ToFloat,
-    ConvUint16ToDouble,
-
-    // int32_t -> (u)int*
-    ConvIntToInt8,
-    ConvIntToInt16,
-    ConvIntToInt64,
-    ConvIntToUint8,
-    ConvIntToUint16,
-    ConvIntToUint,
-    ConvIntToUint64,
-
-    // uint32_t -> (u)int*
-    ConvUintToInt8,
-    ConvUintToInt16,
-    ConvUintToInt,
-    ConvUintToInt64,
-    ConvUintToUint8,
-    ConvUintToUint16,
-    ConvUintToUint64,
-
-    // int32_t -> float*
-    ConvIntToFloat16,
-    ConvIntToFloat,
-    ConvIntToDouble,
-
-    // uint32_t -> float*
-    ConvUintToFloat16,
-    ConvUintToFloat,
-    ConvUintToDouble,
-
-    // int64_t -> (u)int*
-    ConvInt64ToInt8,
-    ConvInt64ToInt16,
-    ConvInt64ToInt,
-    ConvInt64ToUint8,
-    ConvInt64ToUint16,
-    ConvInt64ToUint,
-    ConvInt64ToUint64,
-
-    // uint64_t -> (u)int*
-    ConvUint64ToInt8,
-    ConvUint64ToInt16,
-    ConvUint64ToInt,
-    ConvUint64ToInt64,
-    ConvUint64ToUint8,
-    ConvUint64ToUint16,
-    ConvUint64ToUint,
-
-    // int64_t -> float*
-    ConvInt64ToFloat16,
-    ConvInt64ToFloat,
-    ConvInt64ToDouble,
-
-    // uint64_t -> float*
-    ConvUint64ToFloat16,
-    ConvUint64ToFloat,
-    ConvUint64ToDouble,
-
-    // float16_t -> (u)int*
-    ConvFloat16ToInt8,
-    ConvFloat16ToInt16,
-    ConvFloat16ToInt,
-    ConvFloat16ToInt64,
-    ConvFloat16ToUint8,
-    ConvFloat16ToUint16,
-    ConvFloat16ToUint,
-    ConvFloat16ToUint64,
-
-    // float16_t -> float*
-    ConvFloat16ToFloat,
-    ConvFloat16ToDouble,
-
-    // float -> (u)int*
-    ConvFloatToInt8,
-    ConvFloatToInt16,
-    ConvFloatToInt,
-    ConvFloatToInt64,
-    ConvFloatToUint8,
-    ConvFloatToUint16,
-    ConvFloatToUint,
-    ConvFloatToUint64,
-
-    // float -> float*
-    ConvFloatToFloat16,
-    ConvFloatToDouble,
-
-    // float64 _t-> (u)int*
-    ConvDoubleToInt8,
-    ConvDoubleToInt16,
-    ConvDoubleToInt,
-    ConvDoubleToInt64,
-    ConvDoubleToUint8,
-    ConvDoubleToUint16,
-    ConvDoubleToUint,
-    ConvDoubleToUint64,
-
-    // float64_t -> float*
-    ConvDoubleToFloat16,
-    ConvDoubleToFloat,
-
-    // uint64_t <-> pointer
-    ConvUint64ToPtr,
-    ConvPtrToUint64,
-
-    // uvec2 <-> pointer
-    ConvUvec2ToPtr,
-    ConvPtrToUvec2,
-
-    // uint64_t -> accelerationStructureEXT
-    ConvUint64ToAccStruct,
-
-    // uvec2 -> accelerationStructureEXT
-    ConvUvec2ToAccStruct,
-
-    //
-    // binary operations
-    //
-
+    // Binary
     Add,
     Sub,
     Mul,
@@ -281,454 +72,13 @@ enum class RValueOperator : uint16_t {
     LessThanEqual,
     GreaterThanEqual,
     Comma,
-
-    VectorTimesScalar,
-    VectorTimesMatrix,
-    MatrixTimesVector,
-    MatrixTimesScalar,
-
     LogicalOr,
     LogicalXor,
     LogicalAnd,
-
     IndexDirect,
     IndexIndirect,
     IndexDirectStruct,
-
     VectorSwizzle,
-
-    Method,
-    Scoping,
-
-    //
-    // Built-in functions mapped to operators
-    //
-
-    Radians,
-    Degrees,
-    Sin,
-    Cos,
-    Tan,
-    Asin,
-    Acos,
-    Atan,
-    Sinh,
-    Cosh,
-    Tanh,
-    Asinh,
-    Acosh,
-    Atanh,
-
-    Pow,
-    Exp,
-    Log,
-    Exp2,
-    Log2,
-    Sqrt,
-    InverseSqrt,
-
-    Abs,
-    Sign,
-    Floor,
-    Trunc,
-    Round,
-    RoundEven,
-    Ceil,
-    Fract,
-    Modf,
-    Min,
-    Max,
-    Clamp,
-    Mix,
-    Step,
-    SmoothStep,
-
-    IsNan,
-    IsInf,
-
-    Fma,
-
-    Frexp,
-    Ldexp,
-
-    FloatBitsToInt,
-    FloatBitsToUint,
-    IntBitsToFloat,
-    UintBitsToFloat,
-    DoubleBitsToInt64,
-    DoubleBitsToUint64,
-    Int64BitsToDouble,
-    Uint64BitsToDouble,
-    Float16BitsToInt16,
-    Float16BitsToUint16,
-    Int16BitsToFloat16,
-    Uint16BitsToFloat16,
-    PackSnorm2x16,
-    UnpackSnorm2x16,
-    PackUnorm2x16,
-    UnpackUnorm2x16,
-    PackSnorm4x8,
-    UnpackSnorm4x8,
-    PackUnorm4x8,
-    UnpackUnorm4x8,
-    PackHalf2x16,
-    UnpackHalf2x16,
-    PackDouble2x32,
-    UnpackDouble2x32,
-    PackInt2x32,
-    UnpackInt2x32,
-    PackUint2x32,
-    UnpackUint2x32,
-    PackFloat2x16,
-    UnpackFloat2x16,
-    PackInt2x16,
-    UnpackInt2x16,
-    PackUint2x16,
-    UnpackUint2x16,
-    PackInt4x16,
-    UnpackInt4x16,
-    PackUint4x16,
-    UnpackUint4x16,
-    Pack16,
-    Pack32,
-    Pack64,
-    Unpack32,
-    Unpack16,
-    Unpack8,
-
-    Length,
-    Distance,
-    Dot,
-    Cross,
-    Normalize,
-    FaceForward,
-    Reflect,
-    Refract,
-
-    Min3,
-    Max3,
-    Mid3,
-
-    DPdx,            // Fragment only
-    DPdy,            // Fragment only
-    Fwidth,          // Fragment only
-    DPdxFine,        // Fragment only
-    DPdyFine,        // Fragment only
-    FwidthFine,      // Fragment only
-    DPdxCoarse,      // Fragment only
-    DPdyCoarse,      // Fragment only
-    FwidthCoarse,    // Fragment only
-
-    InterpolateAtCentroid, // Fragment only
-    InterpolateAtSample,   // Fragment only
-    InterpolateAtOffset,   // Fragment only
-    InterpolateAtVertex,
-
-    MatrixTimesMatrix,
-    OuterProduct,
-    Determinant,
-    MatrixInverse,
-    Transpose,
-
-    Ftransform,
-
-    Noise,
-
-    EmitVertex,           // geometry only
-    EndPrimitive,         // geometry only
-    EmitStreamVertex,     // geometry only
-    EndStreamPrimitive,   // geometry only
-
-    Barrier,
-    MemoryBarrier,
-    MemoryBarrierAtomicCounter,
-    MemoryBarrierBuffer,
-    MemoryBarrierImage,
-    MemoryBarrierShared,  // compute only
-    GroupMemoryBarrier,   // compute only
-
-    Ballot,
-    ReadInvocation,
-    ReadFirstInvocation,
-
-    AnyInvocation,
-    AllInvocations,
-    AllInvocationsEqual,
-
-    SubgroupGuardStart,
-    SubgroupBarrier,
-    SubgroupMemoryBarrier,
-    SubgroupMemoryBarrierBuffer,
-    SubgroupMemoryBarrierImage,
-    SubgroupMemoryBarrierShared, // compute only
-    SubgroupElect,
-    SubgroupAll,
-    SubgroupAny,
-    SubgroupAllEqual,
-    SubgroupBroadcast,
-    SubgroupBroadcastFirst,
-    SubgroupBallot,
-    SubgroupInverseBallot,
-    SubgroupBallotBitExtract,
-    SubgroupBallotBitCount,
-    SubgroupBallotInclusiveBitCount,
-    SubgroupBallotExclusiveBitCount,
-    SubgroupBallotFindLSB,
-    SubgroupBallotFindMSB,
-    SubgroupShuffle,
-    SubgroupShuffleXor,
-    SubgroupShuffleUp,
-    SubgroupShuffleDown,
-    SubgroupAdd,
-    SubgroupMul,
-    SubgroupMin,
-    SubgroupMax,
-    SubgroupAnd,
-    SubgroupOr,
-    SubgroupXor,
-    SubgroupInclusiveAdd,
-    SubgroupInclusiveMul,
-    SubgroupInclusiveMin,
-    SubgroupInclusiveMax,
-    SubgroupInclusiveAnd,
-    SubgroupInclusiveOr,
-    SubgroupInclusiveXor,
-    SubgroupExclusiveAdd,
-    SubgroupExclusiveMul,
-    SubgroupExclusiveMin,
-    SubgroupExclusiveMax,
-    SubgroupExclusiveAnd,
-    SubgroupExclusiveOr,
-    SubgroupExclusiveXor,
-    SubgroupClusteredAdd,
-    SubgroupClusteredMul,
-    SubgroupClusteredMin,
-    SubgroupClusteredMax,
-    SubgroupClusteredAnd,
-    SubgroupClusteredOr,
-    SubgroupClusteredXor,
-    SubgroupQuadBroadcast,
-    SubgroupQuadSwapHorizontal,
-    SubgroupQuadSwapVertical,
-    SubgroupQuadSwapDiagonal,
-
-    SubgroupPartition,
-    SubgroupPartitionedAdd,
-    SubgroupPartitionedMul,
-    SubgroupPartitionedMin,
-    SubgroupPartitionedMax,
-    SubgroupPartitionedAnd,
-    SubgroupPartitionedOr,
-    SubgroupPartitionedXor,
-    SubgroupPartitionedInclusiveAdd,
-    SubgroupPartitionedInclusiveMul,
-    SubgroupPartitionedInclusiveMin,
-    SubgroupPartitionedInclusiveMax,
-    SubgroupPartitionedInclusiveAnd,
-    SubgroupPartitionedInclusiveOr,
-    SubgroupPartitionedInclusiveXor,
-    SubgroupPartitionedExclusiveAdd,
-    SubgroupPartitionedExclusiveMul,
-    SubgroupPartitionedExclusiveMin,
-    SubgroupPartitionedExclusiveMax,
-    SubgroupPartitionedExclusiveAnd,
-    SubgroupPartitionedExclusiveOr,
-    SubgroupPartitionedExclusiveXor,
-
-    SubgroupGuardStop,
-
-    MinInvocations,
-    MaxInvocations,
-    AddInvocations,
-    MinInvocationsNonUniform,
-    MaxInvocationsNonUniform,
-    AddInvocationsNonUniform,
-    MinInvocationsInclusiveScan,
-    MaxInvocationsInclusiveScan,
-    AddInvocationsInclusiveScan,
-    MinInvocationsInclusiveScanNonUniform,
-    MaxInvocationsInclusiveScanNonUniform,
-    AddInvocationsInclusiveScanNonUniform,
-    MinInvocationsExclusiveScan,
-    MaxInvocationsExclusiveScan,
-    AddInvocationsExclusiveScan,
-    MinInvocationsExclusiveScanNonUniform,
-    MaxInvocationsExclusiveScanNonUniform,
-    AddInvocationsExclusiveScanNonUniform,
-    SwizzleInvocations,
-    SwizzleInvocationsMasked,
-    WriteInvocation,
-    Mbcnt,
-
-    CubeFaceIndex,
-    CubeFaceCoord,
-    Time,
-
-    AtomicAdd,
-    AtomicSubtract,
-    AtomicMin,
-    AtomicMax,
-    AtomicAnd,
-    AtomicOr,
-    AtomicXor,
-    AtomicExchange,
-    AtomicCompSwap,
-    AtomicLoad,
-    AtomicStore,
-
-    AtomicCounterIncrement, // results in pre-increment value
-    AtomicCounterDecrement, // results in post-decrement value
-    AtomicCounter,
-    AtomicCounterAdd,
-    AtomicCounterSubtract,
-    AtomicCounterMin,
-    AtomicCounterMax,
-    AtomicCounterAnd,
-    AtomicCounterOr,
-    AtomicCounterXor,
-    AtomicCounterExchange,
-    AtomicCounterCompSwap,
-
-    Any,
-    All,
-
-    CooperativeMatrixLoad,
-    CooperativeMatrixStore,
-    CooperativeMatrixMulAdd,
-    CooperativeMatrixLoadNV,
-    CooperativeMatrixStoreNV,
-    CooperativeMatrixMulAddNV,
-
-    BeginInvocationInterlock, // Fragment only
-    EndInvocationInterlock, // Fragment only
-
-    IsHelperInvocation,
-
-    DebugPrintf,
-
-    //
-    // Constructors
-    //
-
-    ConstructGuardStart,
-    ConstructInt,          // these first scalar forms also identify what implicit conversion is needed
-    ConstructUint,
-    ConstructInt8,
-    ConstructUint8,
-    ConstructInt16,
-    ConstructUint16,
-    ConstructInt64,
-    ConstructUint64,
-    ConstructBool,
-    ConstructFloat,
-    ConstructDouble,
-    // Keep vector and matrix constructors in a consistent relative order for
-    // TParseContext::constructBuiltIn, which converts between 8/16/32 bit
-    // vector constructors
-    ConstructVec2,
-    ConstructVec3,
-    ConstructVec4,
-    ConstructMat2x2,
-    ConstructMat2x3,
-    ConstructMat2x4,
-    ConstructMat3x2,
-    ConstructMat3x3,
-    ConstructMat3x4,
-    ConstructMat4x2,
-    ConstructMat4x3,
-    ConstructMat4x4,
-    ConstructDVec2,
-    ConstructDVec3,
-    ConstructDVec4,
-    ConstructBVec2,
-    ConstructBVec3,
-    ConstructBVec4,
-    ConstructI8Vec2,
-    ConstructI8Vec3,
-    ConstructI8Vec4,
-    ConstructU8Vec2,
-    ConstructU8Vec3,
-    ConstructU8Vec4,
-    ConstructI16Vec2,
-    ConstructI16Vec3,
-    ConstructI16Vec4,
-    ConstructU16Vec2,
-    ConstructU16Vec3,
-    ConstructU16Vec4,
-    ConstructIVec2,
-    ConstructIVec3,
-    ConstructIVec4,
-    ConstructUVec2,
-    ConstructUVec3,
-    ConstructUVec4,
-    ConstructI64Vec2,
-    ConstructI64Vec3,
-    ConstructI64Vec4,
-    ConstructU64Vec2,
-    ConstructU64Vec3,
-    ConstructU64Vec4,
-    ConstructDMat2x2,
-    ConstructDMat2x3,
-    ConstructDMat2x4,
-    ConstructDMat3x2,
-    ConstructDMat3x3,
-    ConstructDMat3x4,
-    ConstructDMat4x2,
-    ConstructDMat4x3,
-    ConstructDMat4x4,
-    ConstructIMat2x2,
-    ConstructIMat2x3,
-    ConstructIMat2x4,
-    ConstructIMat3x2,
-    ConstructIMat3x3,
-    ConstructIMat3x4,
-    ConstructIMat4x2,
-    ConstructIMat4x3,
-    ConstructIMat4x4,
-    ConstructUMat2x2,
-    ConstructUMat2x3,
-    ConstructUMat2x4,
-    ConstructUMat3x2,
-    ConstructUMat3x3,
-    ConstructUMat3x4,
-    ConstructUMat4x2,
-    ConstructUMat4x3,
-    ConstructUMat4x4,
-    ConstructBMat2x2,
-    ConstructBMat2x3,
-    ConstructBMat2x4,
-    ConstructBMat3x2,
-    ConstructBMat3x3,
-    ConstructBMat3x4,
-    ConstructBMat4x2,
-    ConstructBMat4x3,
-    ConstructBMat4x4,
-    ConstructFloat16,
-    ConstructF16Vec2,
-    ConstructF16Vec3,
-    ConstructF16Vec4,
-    ConstructF16Mat2x2,
-    ConstructF16Mat2x3,
-    ConstructF16Mat2x4,
-    ConstructF16Mat3x2,
-    ConstructF16Mat3x3,
-    ConstructF16Mat3x4,
-    ConstructF16Mat4x2,
-    ConstructF16Mat4x3,
-    ConstructF16Mat4x4,
-    ConstructStruct,
-    ConstructTextureSampler,
-    ConstructNonuniform,     // expected to be transformed away, not present in final AST
-    ConstructReference,
-    ConstructCooperativeMatrixNV,
-    ConstructCooperativeMatrixKHR,
-    ConstructAccStruct,
-    ConstructGuardEnd,
-
-    //
-    // moves
-    //
-
     Assign,
     AddAssign,
     SubAssign,
@@ -744,223 +94,13 @@ enum class RValueOperator : uint16_t {
     ExclusiveOrAssign,
     LeftShiftAssign,
     RightShiftAssign,
-
-    //
-    // Array operators
-    //
-
-    // Can apply to arrays, vectors, or matrices.
-    // Can be decomposed to a constant at compile time, but this does not always happen,
-    // due to link-time effects. So, consumer can expect either a link-time sized or
-    // run-time sized array.
     ArrayLength,
 
-    //
-    // Image operations
-    //
+    // Ternary
+    Ternary,
 
-    ImageGuardBegin,
-
-    ImageQuerySize,
-    ImageQuerySamples,
-    ImageLoad,
-    ImageStore,
-    ImageLoadLod,
-    ImageStoreLod,
-    ImageAtomicAdd,
-    ImageAtomicMin,
-    ImageAtomicMax,
-    ImageAtomicAnd,
-    ImageAtomicOr,
-    ImageAtomicXor,
-    ImageAtomicExchange,
-    ImageAtomicCompSwap,
-    ImageAtomicLoad,
-    ImageAtomicStore,
-
-    SubpassLoad,
-    SubpassLoadMS,
-    SparseImageLoad,
-    SparseImageLoadLod,
-    ColorAttachmentReadEXT, // Fragment only
-
-    ImageGuardEnd,
-
-    //
-    // Texture operations
-    //
-
-    TextureGuardBegin,
-
-    TextureQuerySize,
-    TextureQueryLod,
-    TextureQueryLevels,
-    TextureQuerySamples,
-
-    SamplingGuardBegin,
-
-    Texture,
-    TextureProj,
-    TextureLod,
-    TextureOffset,
-    TextureFetch,
-    TextureFetchOffset,
-    TextureProjOffset,
-    TextureLodOffset,
-    TextureProjLod,
-    TextureProjLodOffset,
-    TextureGrad,
-    TextureGradOffset,
-    TextureProjGrad,
-    TextureProjGradOffset,
-    TextureGather,
-    TextureGatherOffset,
-    TextureGatherOffsets,
-    TextureClamp,
-    TextureOffsetClamp,
-    TextureGradClamp,
-    TextureGradOffsetClamp,
-    TextureGatherLod,
-    TextureGatherLodOffset,
-    TextureGatherLodOffsets,
-    FragmentMaskFetch,
-    FragmentFetch,
-
-    SparseTextureGuardBegin,
-
-    SparseTexture,
-    SparseTextureLod,
-    SparseTextureOffset,
-    SparseTextureFetch,
-    SparseTextureFetchOffset,
-    SparseTextureLodOffset,
-    SparseTextureGrad,
-    SparseTextureGradOffset,
-    SparseTextureGather,
-    SparseTextureGatherOffset,
-    SparseTextureGatherOffsets,
-    SparseTexelsResident,
-    SparseTextureClamp,
-    SparseTextureOffsetClamp,
-    SparseTextureGradClamp,
-    SparseTextureGradOffsetClamp,
-    SparseTextureGatherLod,
-    SparseTextureGatherLodOffset,
-    SparseTextureGatherLodOffsets,
-
-    SparseTextureGuardEnd,
-
-    ImageFootprintGuardBegin,
-    ImageSampleFootprintNV,
-    ImageSampleFootprintClampNV,
-    ImageSampleFootprintLodNV,
-    ImageSampleFootprintGradNV,
-    ImageSampleFootprintGradClampNV,
-    ImageFootprintGuardEnd,
-    SamplingGuardEnd,
-    TextureGuardEnd,
-
-    //
-    // Integer operations
-    //
-
-    AddCarry,
-    SubBorrow,
-    UMulExtended,
-    IMulExtended,
-    BitfieldExtract,
-    BitfieldInsert,
-    BitFieldReverse,
-    BitCount,
-    FindLSB,
-    FindMSB,
-
-    CountLeadingZeros,
-    CountTrailingZeros,
-    AbsDifference,
-    AddSaturate,
-    SubSaturate,
-    Average,
-    AverageRounded,
-    Mul32x16,
-
-    TraceNV,
-    TraceRayMotionNV,
-    TraceKHR,
-    ReportIntersection,
-    IgnoreIntersectionNV,
-    TerminateRayNV,
-    ExecuteCallableNV,
-    ExecuteCallableKHR,
-    WritePackedPrimitiveIndices4x8NV,
-    EmitMeshTasksEXT,
-    SetMeshOutputsEXT,
-
-    //
-    // GL_EXT_ray_query operations
-    //
-
-    RayQueryInitialize,
-    RayQueryTerminate,
-    RayQueryGenerateIntersection,
-    RayQueryConfirmIntersection,
-    RayQueryProceed,
-    RayQueryGetIntersectionType,
-    RayQueryGetRayTMin,
-    RayQueryGetRayFlags,
-    RayQueryGetIntersectionT,
-    RayQueryGetIntersectionInstanceCustomIndex,
-    RayQueryGetIntersectionInstanceId,
-    RayQueryGetIntersectionInstanceShaderBindingTableRecordOffset,
-    RayQueryGetIntersectionGeometryIndex,
-    RayQueryGetIntersectionPrimitiveIndex,
-    RayQueryGetIntersectionBarycentrics,
-    RayQueryGetIntersectionFrontFace,
-    RayQueryGetIntersectionCandidateAABBOpaque,
-    RayQueryGetIntersectionObjectRayDirection,
-    RayQueryGetIntersectionObjectRayOrigin,
-    RayQueryGetWorldRayDirection,
-    RayQueryGetWorldRayOrigin,
-    RayQueryGetIntersectionObjectToWorld,
-    RayQueryGetIntersectionWorldToObject,
-
-    //
-    // GL_NV_shader_invocation_reorder
-    //
-
-    HitObjectTraceRayNV,
-    HitObjectTraceRayMotionNV,
-    HitObjectRecordHitNV,
-    HitObjectRecordHitMotionNV,
-    HitObjectRecordHitWithIndexNV,
-    HitObjectRecordHitWithIndexMotionNV,
-    HitObjectRecordMissNV,
-    HitObjectRecordMissMotionNV,
-    HitObjectRecordEmptyNV,
-    HitObjectExecuteShaderNV,
-    HitObjectIsEmptyNV,
-    HitObjectIsMissNV,
-    HitObjectIsHitNV,
-    HitObjectGetRayTMinNV,
-    HitObjectGetRayTMaxNV,
-    HitObjectGetObjectRayOriginNV,
-    HitObjectGetObjectRayDirectionNV,
-    HitObjectGetWorldRayOriginNV,
-    HitObjectGetWorldRayDirectionNV,
-    HitObjectGetWorldToObjectNV,
-    HitObjectGetObjectToWorldNV,
-    HitObjectGetInstanceCustomIndexNV,
-    HitObjectGetInstanceIdNV,
-    HitObjectGetGeometryIndexNV,
-    HitObjectGetPrimitiveIndexNV,
-    HitObjectGetHitKindNV,
-    HitObjectGetShaderBindingTableRecordIndexNV,
-    HitObjectGetShaderRecordBufferHandleNV,
-    HitObjectGetAttributesNV,
-    HitObjectGetCurrentTimeNV,
-    ReorderThreadNV,
-    FetchMicroTriangleVertexPositionNV,
-    FetchMicroTriangleVertexBarycentricNV,
+    // Misc
+    ConstructStruct,
 };
 
 // The order of the fields in this enum is very important due to a hack in glslangTypeToType.
diff --git a/libs/glslkomi/src/Komi.cpp b/libs/glslkomi/src/Komi.cpp
index e614f55b18..41396a77bf 100644
--- a/libs/glslkomi/src/Komi.cpp
+++ b/libs/glslkomi/src/Komi.cpp
@@ -25,160 +25,50 @@
 
 namespace glslkomi {
 
-RValueOperator glslangOperatorToRValueOperator(glslang::TOperator op) {
+std::variant<RValueOperator, std::string_view> glslangOperatorToRValueOperator(glslang::TOperator op) {
     using namespace glslang;
     switch (op) {
         case EOpNegative: return RValueOperator::Negative;
         case EOpLogicalNot: return RValueOperator::LogicalNot;
-        case EOpVectorLogicalNot: return RValueOperator::VectorLogicalNot;
+        case EOpVectorLogicalNot: return "not";
         case EOpBitwiseNot: return RValueOperator::BitwiseNot;
         case EOpPostIncrement: return RValueOperator::PostIncrement;
         case EOpPostDecrement: return RValueOperator::PostDecrement;
         case EOpPreIncrement: return RValueOperator::PreIncrement;
         case EOpPreDecrement: return RValueOperator::PreDecrement;
-        case EOpCopyObject: return RValueOperator::CopyObject;
-        case EOpDeclare: return RValueOperator::Declare;
-        case EOpConvInt8ToBool: return RValueOperator::ConvInt8ToBool;
-        case EOpConvUint8ToBool: return RValueOperator::ConvUint8ToBool;
-        case EOpConvInt16ToBool: return RValueOperator::ConvInt16ToBool;
-        case EOpConvUint16ToBool: return RValueOperator::ConvUint16ToBool;
-        case EOpConvIntToBool: return RValueOperator::ConvIntToBool;
-        case EOpConvUintToBool: return RValueOperator::ConvUintToBool;
-        case EOpConvInt64ToBool: return RValueOperator::ConvInt64ToBool;
-        case EOpConvUint64ToBool: return RValueOperator::ConvUint64ToBool;
-        case EOpConvFloat16ToBool: return RValueOperator::ConvFloat16ToBool;
-        case EOpConvFloatToBool: return RValueOperator::ConvFloatToBool;
-        case EOpConvDoubleToBool: return RValueOperator::ConvDoubleToBool;
-        case EOpConvBoolToInt8: return RValueOperator::ConvBoolToInt8;
-        case EOpConvBoolToUint8: return RValueOperator::ConvBoolToUint8;
-        case EOpConvBoolToInt16: return RValueOperator::ConvBoolToInt16;
-        case EOpConvBoolToUint16: return RValueOperator::ConvBoolToUint16;
-        case EOpConvBoolToInt: return RValueOperator::ConvBoolToInt;
-        case EOpConvBoolToUint: return RValueOperator::ConvBoolToUint;
-        case EOpConvBoolToInt64: return RValueOperator::ConvBoolToInt64;
-        case EOpConvBoolToUint64: return RValueOperator::ConvBoolToUint64;
-        case EOpConvBoolToFloat16: return RValueOperator::ConvBoolToFloat16;
-        case EOpConvBoolToFloat: return RValueOperator::ConvBoolToFloat;
-        case EOpConvBoolToDouble: return RValueOperator::ConvBoolToDouble;
-        case EOpConvInt8ToInt16: return RValueOperator::ConvInt8ToInt16;
-        case EOpConvInt8ToInt: return RValueOperator::ConvInt8ToInt;
-        case EOpConvInt8ToInt64: return RValueOperator::ConvInt8ToInt64;
-        case EOpConvInt8ToUint8: return RValueOperator::ConvInt8ToUint8;
-        case EOpConvInt8ToUint16: return RValueOperator::ConvInt8ToUint16;
-        case EOpConvInt8ToUint: return RValueOperator::ConvInt8ToUint;
-        case EOpConvInt8ToUint64: return RValueOperator::ConvInt8ToUint64;
-        case EOpConvUint8ToInt8: return RValueOperator::ConvUint8ToInt8;
-        case EOpConvUint8ToInt16: return RValueOperator::ConvUint8ToInt16;
-        case EOpConvUint8ToInt: return RValueOperator::ConvUint8ToInt;
-        case EOpConvUint8ToInt64: return RValueOperator::ConvUint8ToInt64;
-        case EOpConvUint8ToUint16: return RValueOperator::ConvUint8ToUint16;
-        case EOpConvUint8ToUint: return RValueOperator::ConvUint8ToUint;
-        case EOpConvUint8ToUint64: return RValueOperator::ConvUint8ToUint64;
-        case EOpConvInt8ToFloat16: return RValueOperator::ConvInt8ToFloat16;
-        case EOpConvInt8ToFloat: return RValueOperator::ConvInt8ToFloat;
-        case EOpConvInt8ToDouble: return RValueOperator::ConvInt8ToDouble;
-        case EOpConvUint8ToFloat16: return RValueOperator::ConvUint8ToFloat16;
-        case EOpConvUint8ToFloat: return RValueOperator::ConvUint8ToFloat;
-        case EOpConvUint8ToDouble: return RValueOperator::ConvUint8ToDouble;
-        case EOpConvInt16ToInt8: return RValueOperator::ConvInt16ToInt8;
-        case EOpConvInt16ToInt: return RValueOperator::ConvInt16ToInt;
-        case EOpConvInt16ToInt64: return RValueOperator::ConvInt16ToInt64;
-        case EOpConvInt16ToUint8: return RValueOperator::ConvInt16ToUint8;
-        case EOpConvInt16ToUint16: return RValueOperator::ConvInt16ToUint16;
-        case EOpConvInt16ToUint: return RValueOperator::ConvInt16ToUint;
-        case EOpConvInt16ToUint64: return RValueOperator::ConvInt16ToUint64;
-        case EOpConvUint16ToInt8: return RValueOperator::ConvUint16ToInt8;
-        case EOpConvUint16ToInt16: return RValueOperator::ConvUint16ToInt16;
-        case EOpConvUint16ToInt: return RValueOperator::ConvUint16ToInt;
-        case EOpConvUint16ToInt64: return RValueOperator::ConvUint16ToInt64;
-        case EOpConvUint16ToUint8: return RValueOperator::ConvUint16ToUint8;
-        case EOpConvUint16ToUint: return RValueOperator::ConvUint16ToUint;
-        case EOpConvUint16ToUint64: return RValueOperator::ConvUint16ToUint64;
-        case EOpConvInt16ToFloat16: return RValueOperator::ConvInt16ToFloat16;
-        case EOpConvInt16ToFloat: return RValueOperator::ConvInt16ToFloat;
-        case EOpConvInt16ToDouble: return RValueOperator::ConvInt16ToDouble;
-        case EOpConvUint16ToFloat16: return RValueOperator::ConvUint16ToFloat16;
-        case EOpConvUint16ToFloat: return RValueOperator::ConvUint16ToFloat;
-        case EOpConvUint16ToDouble: return RValueOperator::ConvUint16ToDouble;
-        case EOpConvIntToInt8: return RValueOperator::ConvIntToInt8;
-        case EOpConvIntToInt16: return RValueOperator::ConvIntToInt16;
-        case EOpConvIntToInt64: return RValueOperator::ConvIntToInt64;
-        case EOpConvIntToUint8: return RValueOperator::ConvIntToUint8;
-        case EOpConvIntToUint16: return RValueOperator::ConvIntToUint16;
-        case EOpConvIntToUint: return RValueOperator::ConvIntToUint;
-        case EOpConvIntToUint64: return RValueOperator::ConvIntToUint64;
-        case EOpConvUintToInt8: return RValueOperator::ConvUintToInt8;
-        case EOpConvUintToInt16: return RValueOperator::ConvUintToInt16;
-        case EOpConvUintToInt: return RValueOperator::ConvUintToInt;
-        case EOpConvUintToInt64: return RValueOperator::ConvUintToInt64;
-        case EOpConvUintToUint8: return RValueOperator::ConvUintToUint8;
-        case EOpConvUintToUint16: return RValueOperator::ConvUintToUint16;
-        case EOpConvUintToUint64: return RValueOperator::ConvUintToUint64;
-        case EOpConvIntToFloat16: return RValueOperator::ConvIntToFloat16;
-        case EOpConvIntToFloat: return RValueOperator::ConvIntToFloat;
-        case EOpConvIntToDouble: return RValueOperator::ConvIntToDouble;
-        case EOpConvUintToFloat16: return RValueOperator::ConvUintToFloat16;
-        case EOpConvUintToFloat: return RValueOperator::ConvUintToFloat;
-        case EOpConvUintToDouble: return RValueOperator::ConvUintToDouble;
-        case EOpConvInt64ToInt8: return RValueOperator::ConvInt64ToInt8;
-        case EOpConvInt64ToInt16: return RValueOperator::ConvInt64ToInt16;
-        case EOpConvInt64ToInt: return RValueOperator::ConvInt64ToInt;
-        case EOpConvInt64ToUint8: return RValueOperator::ConvInt64ToUint8;
-        case EOpConvInt64ToUint16: return RValueOperator::ConvInt64ToUint16;
-        case EOpConvInt64ToUint: return RValueOperator::ConvInt64ToUint;
-        case EOpConvInt64ToUint64: return RValueOperator::ConvInt64ToUint64;
-        case EOpConvUint64ToInt8: return RValueOperator::ConvUint64ToInt8;
-        case EOpConvUint64ToInt16: return RValueOperator::ConvUint64ToInt16;
-        case EOpConvUint64ToInt: return RValueOperator::ConvUint64ToInt;
-        case EOpConvUint64ToInt64: return RValueOperator::ConvUint64ToInt64;
-        case EOpConvUint64ToUint8: return RValueOperator::ConvUint64ToUint8;
-        case EOpConvUint64ToUint16: return RValueOperator::ConvUint64ToUint16;
-        case EOpConvUint64ToUint: return RValueOperator::ConvUint64ToUint;
-        case EOpConvInt64ToFloat16: return RValueOperator::ConvInt64ToFloat16;
-        case EOpConvInt64ToFloat: return RValueOperator::ConvInt64ToFloat;
-        case EOpConvInt64ToDouble: return RValueOperator::ConvInt64ToDouble;
-        case EOpConvUint64ToFloat16: return RValueOperator::ConvUint64ToFloat16;
-        case EOpConvUint64ToFloat: return RValueOperator::ConvUint64ToFloat;
-        case EOpConvUint64ToDouble: return RValueOperator::ConvUint64ToDouble;
-        case EOpConvFloat16ToInt8: return RValueOperator::ConvFloat16ToInt8;
-        case EOpConvFloat16ToInt16: return RValueOperator::ConvFloat16ToInt16;
-        case EOpConvFloat16ToInt: return RValueOperator::ConvFloat16ToInt;
-        case EOpConvFloat16ToInt64: return RValueOperator::ConvFloat16ToInt64;
-        case EOpConvFloat16ToUint8: return RValueOperator::ConvFloat16ToUint8;
-        case EOpConvFloat16ToUint16: return RValueOperator::ConvFloat16ToUint16;
-        case EOpConvFloat16ToUint: return RValueOperator::ConvFloat16ToUint;
-        case EOpConvFloat16ToUint64: return RValueOperator::ConvFloat16ToUint64;
-        case EOpConvFloat16ToFloat: return RValueOperator::ConvFloat16ToFloat;
-        case EOpConvFloat16ToDouble: return RValueOperator::ConvFloat16ToDouble;
-        case EOpConvFloatToInt8: return RValueOperator::ConvFloatToInt8;
-        case EOpConvFloatToInt16: return RValueOperator::ConvFloatToInt16;
-        case EOpConvFloatToInt: return RValueOperator::ConvFloatToInt;
-        case EOpConvFloatToInt64: return RValueOperator::ConvFloatToInt64;
-        case EOpConvFloatToUint8: return RValueOperator::ConvFloatToUint8;
-        case EOpConvFloatToUint16: return RValueOperator::ConvFloatToUint16;
-        case EOpConvFloatToUint: return RValueOperator::ConvFloatToUint;
-        case EOpConvFloatToUint64: return RValueOperator::ConvFloatToUint64;
-        case EOpConvFloatToFloat16: return RValueOperator::ConvFloatToFloat16;
-        case EOpConvFloatToDouble: return RValueOperator::ConvFloatToDouble;
-        case EOpConvDoubleToInt8: return RValueOperator::ConvDoubleToInt8;
-        case EOpConvDoubleToInt16: return RValueOperator::ConvDoubleToInt16;
-        case EOpConvDoubleToInt: return RValueOperator::ConvDoubleToInt;
-        case EOpConvDoubleToInt64: return RValueOperator::ConvDoubleToInt64;
-        case EOpConvDoubleToUint8: return RValueOperator::ConvDoubleToUint8;
-        case EOpConvDoubleToUint16: return RValueOperator::ConvDoubleToUint16;
-        case EOpConvDoubleToUint: return RValueOperator::ConvDoubleToUint;
-        case EOpConvDoubleToUint64: return RValueOperator::ConvDoubleToUint64;
-        case EOpConvDoubleToFloat16: return RValueOperator::ConvDoubleToFloat16;
-        case EOpConvDoubleToFloat: return RValueOperator::ConvDoubleToFloat;
-        case EOpConvUint64ToPtr: return RValueOperator::ConvUint64ToPtr;
-        case EOpConvPtrToUint64: return RValueOperator::ConvPtrToUint64;
-        case EOpConvUvec2ToPtr: return RValueOperator::ConvUvec2ToPtr;
-        case EOpConvPtrToUvec2: return RValueOperator::ConvPtrToUvec2;
-        case EOpConvUint64ToAccStruct: return RValueOperator::ConvUint64ToAccStruct;
-        case EOpConvUvec2ToAccStruct: return RValueOperator::ConvUvec2ToAccStruct;
+        case EOpConvIntToBool:
+        case EOpConvUintToBool:
+        case EOpConvFloatToBool:
+        case EOpConvDoubleToBool:
+            return "bool";
+        case EOpConvBoolToInt:
+        case EOpConvUintToInt:
+        case EOpConvFloatToInt:
+        case EOpConvDoubleToInt:
+            return "int";
+        case EOpConvBoolToFloat:
+        case EOpConvIntToFloat:
+        case EOpConvUintToFloat:
+        case EOpConvDoubleToFloat:
+            return "float";
+        case EOpConvBoolToDouble:
+        case EOpConvIntToDouble:
+        case EOpConvUintToDouble:
+        case EOpConvFloatToDouble:
+            return "double";
+        case EOpConvBoolToUint:
+        case EOpConvIntToUint:
+        case EOpConvFloatToUint:
+        case EOpConvDoubleToUint:
+            return "uint";
         case EOpAdd: return RValueOperator::Add;
         case EOpSub: return RValueOperator::Sub;
-        case EOpMul: return RValueOperator::Mul;
+        case EOpMul:
+        case EOpVectorTimesScalar:
+        case EOpVectorTimesMatrix:
+        case EOpMatrixTimesVector:
+        case EOpMatrixTimesScalar:
+            return RValueOperator::Mul;
         case EOpDiv: return RValueOperator::Div;
         case EOpMod: return RValueOperator::Mod;
         case EOpRightShift: return RValueOperator::RightShift;
@@ -188,17 +78,13 @@ RValueOperator glslangOperatorToRValueOperator(glslang::TOperator op) {
         case EOpExclusiveOr: return RValueOperator::ExclusiveOr;
         case EOpEqual: return RValueOperator::Equal;
         case EOpNotEqual: return RValueOperator::NotEqual;
-        case EOpVectorEqual: return RValueOperator::VectorEqual;
-        case EOpVectorNotEqual: return RValueOperator::VectorNotEqual;
+        case EOpVectorEqual: return "equal";
+        case EOpVectorNotEqual: return "notEqual";
         case EOpLessThan: return RValueOperator::LessThan;
         case EOpGreaterThan: return RValueOperator::GreaterThan;
         case EOpLessThanEqual: return RValueOperator::LessThanEqual;
         case EOpGreaterThanEqual: return RValueOperator::GreaterThanEqual;
         case EOpComma: return RValueOperator::Comma;
-        case EOpVectorTimesScalar: return RValueOperator::VectorTimesScalar;
-        case EOpVectorTimesMatrix: return RValueOperator::VectorTimesMatrix;
-        case EOpMatrixTimesVector: return RValueOperator::MatrixTimesVector;
-        case EOpMatrixTimesScalar: return RValueOperator::MatrixTimesScalar;
         case EOpLogicalOr: return RValueOperator::LogicalOr;
         case EOpLogicalXor: return RValueOperator::LogicalXor;
         case EOpLogicalAnd: return RValueOperator::LogicalAnd;
@@ -206,391 +92,412 @@ RValueOperator glslangOperatorToRValueOperator(glslang::TOperator op) {
         case EOpIndexIndirect: return RValueOperator::IndexIndirect;
         case EOpIndexDirectStruct: return RValueOperator::IndexDirectStruct;
         case EOpVectorSwizzle: return RValueOperator::VectorSwizzle;
-        case EOpMethod: return RValueOperator::Method;
-        case EOpScoping: return RValueOperator::Scoping;
-        case EOpRadians: return RValueOperator::Radians;
-        case EOpDegrees: return RValueOperator::Degrees;
-        case EOpSin: return RValueOperator::Sin;
-        case EOpCos: return RValueOperator::Cos;
-        case EOpTan: return RValueOperator::Tan;
-        case EOpAsin: return RValueOperator::Asin;
-        case EOpAcos: return RValueOperator::Acos;
-        case EOpAtan: return RValueOperator::Atan;
-        case EOpSinh: return RValueOperator::Sinh;
-        case EOpCosh: return RValueOperator::Cosh;
-        case EOpTanh: return RValueOperator::Tanh;
-        case EOpAsinh: return RValueOperator::Asinh;
-        case EOpAcosh: return RValueOperator::Acosh;
-        case EOpAtanh: return RValueOperator::Atanh;
-        case EOpPow: return RValueOperator::Pow;
-        case EOpExp: return RValueOperator::Exp;
-        case EOpLog: return RValueOperator::Log;
-        case EOpExp2: return RValueOperator::Exp2;
-        case EOpLog2: return RValueOperator::Log2;
-        case EOpSqrt: return RValueOperator::Sqrt;
-        case EOpInverseSqrt: return RValueOperator::InverseSqrt;
-        case EOpAbs: return RValueOperator::Abs;
-        case EOpSign: return RValueOperator::Sign;
-        case EOpFloor: return RValueOperator::Floor;
-        case EOpTrunc: return RValueOperator::Trunc;
-        case EOpRound: return RValueOperator::Round;
-        case EOpRoundEven: return RValueOperator::RoundEven;
-        case EOpCeil: return RValueOperator::Ceil;
-        case EOpFract: return RValueOperator::Fract;
-        case EOpModf: return RValueOperator::Modf;
-        case EOpMin: return RValueOperator::Min;
-        case EOpMax: return RValueOperator::Max;
-        case EOpClamp: return RValueOperator::Clamp;
-        case EOpMix: return RValueOperator::Mix;
-        case EOpStep: return RValueOperator::Step;
-        case EOpSmoothStep: return RValueOperator::SmoothStep;
-        case EOpIsNan: return RValueOperator::IsNan;
-        case EOpIsInf: return RValueOperator::IsInf;
-        case EOpFma: return RValueOperator::Fma;
-        case EOpFrexp: return RValueOperator::Frexp;
-        case EOpLdexp: return RValueOperator::Ldexp;
-        case EOpFloatBitsToInt: return RValueOperator::FloatBitsToInt;
-        case EOpFloatBitsToUint: return RValueOperator::FloatBitsToUint;
-        case EOpIntBitsToFloat: return RValueOperator::IntBitsToFloat;
-        case EOpUintBitsToFloat: return RValueOperator::UintBitsToFloat;
-        case EOpDoubleBitsToInt64: return RValueOperator::DoubleBitsToInt64;
-        case EOpDoubleBitsToUint64: return RValueOperator::DoubleBitsToUint64;
-        case EOpInt64BitsToDouble: return RValueOperator::Int64BitsToDouble;
-        case EOpUint64BitsToDouble: return RValueOperator::Uint64BitsToDouble;
-        case EOpFloat16BitsToInt16: return RValueOperator::Float16BitsToInt16;
-        case EOpFloat16BitsToUint16: return RValueOperator::Float16BitsToUint16;
-        case EOpInt16BitsToFloat16: return RValueOperator::Int16BitsToFloat16;
-        case EOpUint16BitsToFloat16: return RValueOperator::Uint16BitsToFloat16;
-        case EOpPackSnorm2x16: return RValueOperator::PackSnorm2x16;
-        case EOpUnpackSnorm2x16: return RValueOperator::UnpackSnorm2x16;
-        case EOpPackUnorm2x16: return RValueOperator::PackUnorm2x16;
-        case EOpUnpackUnorm2x16: return RValueOperator::UnpackUnorm2x16;
-        case EOpPackSnorm4x8: return RValueOperator::PackSnorm4x8;
-        case EOpUnpackSnorm4x8: return RValueOperator::UnpackSnorm4x8;
-        case EOpPackUnorm4x8: return RValueOperator::PackUnorm4x8;
-        case EOpUnpackUnorm4x8: return RValueOperator::UnpackUnorm4x8;
-        case EOpPackHalf2x16: return RValueOperator::PackHalf2x16;
-        case EOpUnpackHalf2x16: return RValueOperator::UnpackHalf2x16;
-        case EOpPackDouble2x32: return RValueOperator::PackDouble2x32;
-        case EOpUnpackDouble2x32: return RValueOperator::UnpackDouble2x32;
-        case EOpPackInt2x32: return RValueOperator::PackInt2x32;
-        case EOpUnpackInt2x32: return RValueOperator::UnpackInt2x32;
-        case EOpPackUint2x32: return RValueOperator::PackUint2x32;
-        case EOpUnpackUint2x32: return RValueOperator::UnpackUint2x32;
-        case EOpPackFloat2x16: return RValueOperator::PackFloat2x16;
-        case EOpUnpackFloat2x16: return RValueOperator::UnpackFloat2x16;
-        case EOpPackInt2x16: return RValueOperator::PackInt2x16;
-        case EOpUnpackInt2x16: return RValueOperator::UnpackInt2x16;
-        case EOpPackUint2x16: return RValueOperator::PackUint2x16;
-        case EOpUnpackUint2x16: return RValueOperator::UnpackUint2x16;
-        case EOpPackInt4x16: return RValueOperator::PackInt4x16;
-        case EOpUnpackInt4x16: return RValueOperator::UnpackInt4x16;
-        case EOpPackUint4x16: return RValueOperator::PackUint4x16;
-        case EOpUnpackUint4x16: return RValueOperator::UnpackUint4x16;
-        case EOpPack16: return RValueOperator::Pack16;
-        case EOpPack32: return RValueOperator::Pack32;
-        case EOpPack64: return RValueOperator::Pack64;
-        case EOpUnpack32: return RValueOperator::Unpack32;
-        case EOpUnpack16: return RValueOperator::Unpack16;
-        case EOpUnpack8: return RValueOperator::Unpack8;
-        case EOpLength: return RValueOperator::Length;
-        case EOpDistance: return RValueOperator::Distance;
-        case EOpDot: return RValueOperator::Dot;
-        case EOpCross: return RValueOperator::Cross;
-        case EOpNormalize: return RValueOperator::Normalize;
-        case EOpFaceForward: return RValueOperator::FaceForward;
-        case EOpReflect: return RValueOperator::Reflect;
-        case EOpRefract: return RValueOperator::Refract;
-        case EOpMin3: return RValueOperator::Min3;
-        case EOpMax3: return RValueOperator::Max3;
-        case EOpMid3: return RValueOperator::Mid3;
-        case EOpDPdx: return RValueOperator::DPdx;
-        case EOpDPdy: return RValueOperator::DPdy;
-        case EOpFwidth: return RValueOperator::Fwidth;
-        case EOpDPdxFine: return RValueOperator::DPdxFine;
-        case EOpDPdyFine: return RValueOperator::DPdyFine;
-        case EOpFwidthFine: return RValueOperator::FwidthFine;
-        case EOpDPdxCoarse: return RValueOperator::DPdxCoarse;
-        case EOpDPdyCoarse: return RValueOperator::DPdyCoarse;
-        case EOpFwidthCoarse: return RValueOperator::FwidthCoarse;
-        case EOpInterpolateAtCentroid: return RValueOperator::InterpolateAtCentroid;
-        case EOpInterpolateAtSample: return RValueOperator::InterpolateAtSample;
-        case EOpInterpolateAtOffset: return RValueOperator::InterpolateAtOffset;
-        case EOpInterpolateAtVertex: return RValueOperator::InterpolateAtVertex;
-        case EOpMatrixTimesMatrix: return RValueOperator::MatrixTimesMatrix;
-        case EOpOuterProduct: return RValueOperator::OuterProduct;
-        case EOpDeterminant: return RValueOperator::Determinant;
-        case EOpMatrixInverse: return RValueOperator::MatrixInverse;
-        case EOpTranspose: return RValueOperator::Transpose;
-        case EOpFtransform: return RValueOperator::Ftransform;
-        case EOpNoise: return RValueOperator::Noise;
-        case EOpEmitVertex: return RValueOperator::EmitVertex;
-        case EOpEndPrimitive: return RValueOperator::EndPrimitive;
-        case EOpEmitStreamVertex: return RValueOperator::EmitStreamVertex;
-        case EOpEndStreamPrimitive: return RValueOperator::EndStreamPrimitive;
-        case EOpBarrier: return RValueOperator::Barrier;
-        case EOpMemoryBarrier: return RValueOperator::MemoryBarrier;
-        case EOpMemoryBarrierAtomicCounter: return RValueOperator::MemoryBarrierAtomicCounter;
-        case EOpMemoryBarrierBuffer: return RValueOperator::MemoryBarrierBuffer;
-        case EOpMemoryBarrierImage: return RValueOperator::MemoryBarrierImage;
-        case EOpMemoryBarrierShared: return RValueOperator::MemoryBarrierShared;
-        case EOpGroupMemoryBarrier: return RValueOperator::GroupMemoryBarrier;
-        case EOpBallot: return RValueOperator::Ballot;
-        case EOpReadInvocation: return RValueOperator::ReadInvocation;
-        case EOpReadFirstInvocation: return RValueOperator::ReadFirstInvocation;
-        case EOpAnyInvocation: return RValueOperator::AnyInvocation;
-        case EOpAllInvocations: return RValueOperator::AllInvocations;
-        case EOpAllInvocationsEqual: return RValueOperator::AllInvocationsEqual;
-        case EOpSubgroupGuardStart: return RValueOperator::SubgroupGuardStart;
-        case EOpSubgroupBarrier: return RValueOperator::SubgroupBarrier;
-        case EOpSubgroupMemoryBarrier: return RValueOperator::SubgroupMemoryBarrier;
-        case EOpSubgroupMemoryBarrierBuffer: return RValueOperator::SubgroupMemoryBarrierBuffer;
-        case EOpSubgroupMemoryBarrierImage: return RValueOperator::SubgroupMemoryBarrierImage;
-        case EOpSubgroupMemoryBarrierShared: return RValueOperator::SubgroupMemoryBarrierShared;
-        case EOpSubgroupElect: return RValueOperator::SubgroupElect;
-        case EOpSubgroupAll: return RValueOperator::SubgroupAll;
-        case EOpSubgroupAny: return RValueOperator::SubgroupAny;
-        case EOpSubgroupAllEqual: return RValueOperator::SubgroupAllEqual;
-        case EOpSubgroupBroadcast: return RValueOperator::SubgroupBroadcast;
-        case EOpSubgroupBroadcastFirst: return RValueOperator::SubgroupBroadcastFirst;
-        case EOpSubgroupBallot: return RValueOperator::SubgroupBallot;
-        case EOpSubgroupInverseBallot: return RValueOperator::SubgroupInverseBallot;
-        case EOpSubgroupBallotBitExtract: return RValueOperator::SubgroupBallotBitExtract;
-        case EOpSubgroupBallotBitCount: return RValueOperator::SubgroupBallotBitCount;
-        case EOpSubgroupBallotInclusiveBitCount: return RValueOperator::SubgroupBallotInclusiveBitCount;
-        case EOpSubgroupBallotExclusiveBitCount: return RValueOperator::SubgroupBallotExclusiveBitCount;
-        case EOpSubgroupBallotFindLSB: return RValueOperator::SubgroupBallotFindLSB;
-        case EOpSubgroupBallotFindMSB: return RValueOperator::SubgroupBallotFindMSB;
-        case EOpSubgroupShuffle: return RValueOperator::SubgroupShuffle;
-        case EOpSubgroupShuffleXor: return RValueOperator::SubgroupShuffleXor;
-        case EOpSubgroupShuffleUp: return RValueOperator::SubgroupShuffleUp;
-        case EOpSubgroupShuffleDown: return RValueOperator::SubgroupShuffleDown;
-        case EOpSubgroupAdd: return RValueOperator::SubgroupAdd;
-        case EOpSubgroupMul: return RValueOperator::SubgroupMul;
-        case EOpSubgroupMin: return RValueOperator::SubgroupMin;
-        case EOpSubgroupMax: return RValueOperator::SubgroupMax;
-        case EOpSubgroupAnd: return RValueOperator::SubgroupAnd;
-        case EOpSubgroupOr: return RValueOperator::SubgroupOr;
-        case EOpSubgroupXor: return RValueOperator::SubgroupXor;
-        case EOpSubgroupInclusiveAdd: return RValueOperator::SubgroupInclusiveAdd;
-        case EOpSubgroupInclusiveMul: return RValueOperator::SubgroupInclusiveMul;
-        case EOpSubgroupInclusiveMin: return RValueOperator::SubgroupInclusiveMin;
-        case EOpSubgroupInclusiveMax: return RValueOperator::SubgroupInclusiveMax;
-        case EOpSubgroupInclusiveAnd: return RValueOperator::SubgroupInclusiveAnd;
-        case EOpSubgroupInclusiveOr: return RValueOperator::SubgroupInclusiveOr;
-        case EOpSubgroupInclusiveXor: return RValueOperator::SubgroupInclusiveXor;
-        case EOpSubgroupExclusiveAdd: return RValueOperator::SubgroupExclusiveAdd;
-        case EOpSubgroupExclusiveMul: return RValueOperator::SubgroupExclusiveMul;
-        case EOpSubgroupExclusiveMin: return RValueOperator::SubgroupExclusiveMin;
-        case EOpSubgroupExclusiveMax: return RValueOperator::SubgroupExclusiveMax;
-        case EOpSubgroupExclusiveAnd: return RValueOperator::SubgroupExclusiveAnd;
-        case EOpSubgroupExclusiveOr: return RValueOperator::SubgroupExclusiveOr;
-        case EOpSubgroupExclusiveXor: return RValueOperator::SubgroupExclusiveXor;
-        case EOpSubgroupClusteredAdd: return RValueOperator::SubgroupClusteredAdd;
-        case EOpSubgroupClusteredMul: return RValueOperator::SubgroupClusteredMul;
-        case EOpSubgroupClusteredMin: return RValueOperator::SubgroupClusteredMin;
-        case EOpSubgroupClusteredMax: return RValueOperator::SubgroupClusteredMax;
-        case EOpSubgroupClusteredAnd: return RValueOperator::SubgroupClusteredAnd;
-        case EOpSubgroupClusteredOr: return RValueOperator::SubgroupClusteredOr;
-        case EOpSubgroupClusteredXor: return RValueOperator::SubgroupClusteredXor;
-        case EOpSubgroupQuadBroadcast: return RValueOperator::SubgroupQuadBroadcast;
-        case EOpSubgroupQuadSwapHorizontal: return RValueOperator::SubgroupQuadSwapHorizontal;
-        case EOpSubgroupQuadSwapVertical: return RValueOperator::SubgroupQuadSwapVertical;
-        case EOpSubgroupQuadSwapDiagonal: return RValueOperator::SubgroupQuadSwapDiagonal;
-        case EOpSubgroupPartition: return RValueOperator::SubgroupPartition;
-        case EOpSubgroupPartitionedAdd: return RValueOperator::SubgroupPartitionedAdd;
-        case EOpSubgroupPartitionedMul: return RValueOperator::SubgroupPartitionedMul;
-        case EOpSubgroupPartitionedMin: return RValueOperator::SubgroupPartitionedMin;
-        case EOpSubgroupPartitionedMax: return RValueOperator::SubgroupPartitionedMax;
-        case EOpSubgroupPartitionedAnd: return RValueOperator::SubgroupPartitionedAnd;
-        case EOpSubgroupPartitionedOr: return RValueOperator::SubgroupPartitionedOr;
-        case EOpSubgroupPartitionedXor: return RValueOperator::SubgroupPartitionedXor;
-        case EOpSubgroupPartitionedInclusiveAdd: return RValueOperator::SubgroupPartitionedInclusiveAdd;
-        case EOpSubgroupPartitionedInclusiveMul: return RValueOperator::SubgroupPartitionedInclusiveMul;
-        case EOpSubgroupPartitionedInclusiveMin: return RValueOperator::SubgroupPartitionedInclusiveMin;
-        case EOpSubgroupPartitionedInclusiveMax: return RValueOperator::SubgroupPartitionedInclusiveMax;
-        case EOpSubgroupPartitionedInclusiveAnd: return RValueOperator::SubgroupPartitionedInclusiveAnd;
-        case EOpSubgroupPartitionedInclusiveOr: return RValueOperator::SubgroupPartitionedInclusiveOr;
-        case EOpSubgroupPartitionedInclusiveXor: return RValueOperator::SubgroupPartitionedInclusiveXor;
-        case EOpSubgroupPartitionedExclusiveAdd: return RValueOperator::SubgroupPartitionedExclusiveAdd;
-        case EOpSubgroupPartitionedExclusiveMul: return RValueOperator::SubgroupPartitionedExclusiveMul;
-        case EOpSubgroupPartitionedExclusiveMin: return RValueOperator::SubgroupPartitionedExclusiveMin;
-        case EOpSubgroupPartitionedExclusiveMax: return RValueOperator::SubgroupPartitionedExclusiveMax;
-        case EOpSubgroupPartitionedExclusiveAnd: return RValueOperator::SubgroupPartitionedExclusiveAnd;
-        case EOpSubgroupPartitionedExclusiveOr: return RValueOperator::SubgroupPartitionedExclusiveOr;
-        case EOpSubgroupPartitionedExclusiveXor: return RValueOperator::SubgroupPartitionedExclusiveXor;
-        case EOpSubgroupGuardStop: return RValueOperator::SubgroupGuardStop;
-        case EOpMinInvocations: return RValueOperator::MinInvocations;
-        case EOpMaxInvocations: return RValueOperator::MaxInvocations;
-        case EOpAddInvocations: return RValueOperator::AddInvocations;
-        case EOpMinInvocationsNonUniform: return RValueOperator::MinInvocationsNonUniform;
-        case EOpMaxInvocationsNonUniform: return RValueOperator::MaxInvocationsNonUniform;
-        case EOpAddInvocationsNonUniform: return RValueOperator::AddInvocationsNonUniform;
-        case EOpMinInvocationsInclusiveScan: return RValueOperator::MinInvocationsInclusiveScan;
-        case EOpMaxInvocationsInclusiveScan: return RValueOperator::MaxInvocationsInclusiveScan;
-        case EOpAddInvocationsInclusiveScan: return RValueOperator::AddInvocationsInclusiveScan;
-        case EOpMinInvocationsInclusiveScanNonUniform: return RValueOperator::MinInvocationsInclusiveScanNonUniform;
-        case EOpMaxInvocationsInclusiveScanNonUniform: return RValueOperator::MaxInvocationsInclusiveScanNonUniform;
-        case EOpAddInvocationsInclusiveScanNonUniform: return RValueOperator::AddInvocationsInclusiveScanNonUniform;
-        case EOpMinInvocationsExclusiveScan: return RValueOperator::MinInvocationsExclusiveScan;
-        case EOpMaxInvocationsExclusiveScan: return RValueOperator::MaxInvocationsExclusiveScan;
-        case EOpAddInvocationsExclusiveScan: return RValueOperator::AddInvocationsExclusiveScan;
-        case EOpMinInvocationsExclusiveScanNonUniform: return RValueOperator::MinInvocationsExclusiveScanNonUniform;
-        case EOpMaxInvocationsExclusiveScanNonUniform: return RValueOperator::MaxInvocationsExclusiveScanNonUniform;
-        case EOpAddInvocationsExclusiveScanNonUniform: return RValueOperator::AddInvocationsExclusiveScanNonUniform;
-        case EOpSwizzleInvocations: return RValueOperator::SwizzleInvocations;
-        case EOpSwizzleInvocationsMasked: return RValueOperator::SwizzleInvocationsMasked;
-        case EOpWriteInvocation: return RValueOperator::WriteInvocation;
-        case EOpMbcnt: return RValueOperator::Mbcnt;
-        case EOpCubeFaceIndex: return RValueOperator::CubeFaceIndex;
-        case EOpCubeFaceCoord: return RValueOperator::CubeFaceCoord;
-        case EOpTime: return RValueOperator::Time;
-        case EOpAtomicAdd: return RValueOperator::AtomicAdd;
-        case EOpAtomicSubtract: return RValueOperator::AtomicSubtract;
-        case EOpAtomicMin: return RValueOperator::AtomicMin;
-        case EOpAtomicMax: return RValueOperator::AtomicMax;
-        case EOpAtomicAnd: return RValueOperator::AtomicAnd;
-        case EOpAtomicOr: return RValueOperator::AtomicOr;
-        case EOpAtomicXor: return RValueOperator::AtomicXor;
-        case EOpAtomicExchange: return RValueOperator::AtomicExchange;
-        case EOpAtomicCompSwap: return RValueOperator::AtomicCompSwap;
-        case EOpAtomicLoad: return RValueOperator::AtomicLoad;
-        case EOpAtomicStore: return RValueOperator::AtomicStore;
-        case EOpAtomicCounterIncrement: return RValueOperator::AtomicCounterIncrement;
-        case EOpAtomicCounterDecrement: return RValueOperator::AtomicCounterDecrement;
-        case EOpAtomicCounter: return RValueOperator::AtomicCounter;
-        case EOpAtomicCounterAdd: return RValueOperator::AtomicCounterAdd;
-        case EOpAtomicCounterSubtract: return RValueOperator::AtomicCounterSubtract;
-        case EOpAtomicCounterMin: return RValueOperator::AtomicCounterMin;
-        case EOpAtomicCounterMax: return RValueOperator::AtomicCounterMax;
-        case EOpAtomicCounterAnd: return RValueOperator::AtomicCounterAnd;
-        case EOpAtomicCounterOr: return RValueOperator::AtomicCounterOr;
-        case EOpAtomicCounterXor: return RValueOperator::AtomicCounterXor;
-        case EOpAtomicCounterExchange: return RValueOperator::AtomicCounterExchange;
-        case EOpAtomicCounterCompSwap: return RValueOperator::AtomicCounterCompSwap;
-        case EOpAny: return RValueOperator::Any;
-        case EOpAll: return RValueOperator::All;
-        case EOpCooperativeMatrixLoad: return RValueOperator::CooperativeMatrixLoad;
-        case EOpCooperativeMatrixStore: return RValueOperator::CooperativeMatrixStore;
-        case EOpCooperativeMatrixMulAdd: return RValueOperator::CooperativeMatrixMulAdd;
-        case EOpCooperativeMatrixLoadNV: return RValueOperator::CooperativeMatrixLoadNV;
-        case EOpCooperativeMatrixStoreNV: return RValueOperator::CooperativeMatrixStoreNV;
-        case EOpCooperativeMatrixMulAddNV: return RValueOperator::CooperativeMatrixMulAddNV;
-        case EOpBeginInvocationInterlock: return RValueOperator::BeginInvocationInterlock;
-        case EOpEndInvocationInterlock: return RValueOperator::EndInvocationInterlock;
-        case EOpIsHelperInvocation: return RValueOperator::IsHelperInvocation;
-        case EOpDebugPrintf: return RValueOperator::DebugPrintf;
-        case EOpConstructGuardStart: return RValueOperator::ConstructGuardStart;
-        case EOpConstructInt: return RValueOperator::ConstructInt;
-        case EOpConstructUint: return RValueOperator::ConstructUint;
-        case EOpConstructInt8: return RValueOperator::ConstructInt8;
-        case EOpConstructUint8: return RValueOperator::ConstructUint8;
-        case EOpConstructInt16: return RValueOperator::ConstructInt16;
-        case EOpConstructUint16: return RValueOperator::ConstructUint16;
-        case EOpConstructInt64: return RValueOperator::ConstructInt64;
-        case EOpConstructUint64: return RValueOperator::ConstructUint64;
-        case EOpConstructBool: return RValueOperator::ConstructBool;
-        case EOpConstructFloat: return RValueOperator::ConstructFloat;
-        case EOpConstructDouble: return RValueOperator::ConstructDouble;
-        case EOpConstructVec2: return RValueOperator::ConstructVec2;
-        case EOpConstructVec3: return RValueOperator::ConstructVec3;
-        case EOpConstructVec4: return RValueOperator::ConstructVec4;
-        case EOpConstructMat2x2: return RValueOperator::ConstructMat2x2;
-        case EOpConstructMat2x3: return RValueOperator::ConstructMat2x3;
-        case EOpConstructMat2x4: return RValueOperator::ConstructMat2x4;
-        case EOpConstructMat3x2: return RValueOperator::ConstructMat3x2;
-        case EOpConstructMat3x3: return RValueOperator::ConstructMat3x3;
-        case EOpConstructMat3x4: return RValueOperator::ConstructMat3x4;
-        case EOpConstructMat4x2: return RValueOperator::ConstructMat4x2;
-        case EOpConstructMat4x3: return RValueOperator::ConstructMat4x3;
-        case EOpConstructMat4x4: return RValueOperator::ConstructMat4x4;
-        case EOpConstructDVec2: return RValueOperator::ConstructDVec2;
-        case EOpConstructDVec3: return RValueOperator::ConstructDVec3;
-        case EOpConstructDVec4: return RValueOperator::ConstructDVec4;
-        case EOpConstructBVec2: return RValueOperator::ConstructBVec2;
-        case EOpConstructBVec3: return RValueOperator::ConstructBVec3;
-        case EOpConstructBVec4: return RValueOperator::ConstructBVec4;
-        case EOpConstructI8Vec2: return RValueOperator::ConstructI8Vec2;
-        case EOpConstructI8Vec3: return RValueOperator::ConstructI8Vec3;
-        case EOpConstructI8Vec4: return RValueOperator::ConstructI8Vec4;
-        case EOpConstructU8Vec2: return RValueOperator::ConstructU8Vec2;
-        case EOpConstructU8Vec3: return RValueOperator::ConstructU8Vec3;
-        case EOpConstructU8Vec4: return RValueOperator::ConstructU8Vec4;
-        case EOpConstructI16Vec2: return RValueOperator::ConstructI16Vec2;
-        case EOpConstructI16Vec3: return RValueOperator::ConstructI16Vec3;
-        case EOpConstructI16Vec4: return RValueOperator::ConstructI16Vec4;
-        case EOpConstructU16Vec2: return RValueOperator::ConstructU16Vec2;
-        case EOpConstructU16Vec3: return RValueOperator::ConstructU16Vec3;
-        case EOpConstructU16Vec4: return RValueOperator::ConstructU16Vec4;
-        case EOpConstructIVec2: return RValueOperator::ConstructIVec2;
-        case EOpConstructIVec3: return RValueOperator::ConstructIVec3;
-        case EOpConstructIVec4: return RValueOperator::ConstructIVec4;
-        case EOpConstructUVec2: return RValueOperator::ConstructUVec2;
-        case EOpConstructUVec3: return RValueOperator::ConstructUVec3;
-        case EOpConstructUVec4: return RValueOperator::ConstructUVec4;
-        case EOpConstructI64Vec2: return RValueOperator::ConstructI64Vec2;
-        case EOpConstructI64Vec3: return RValueOperator::ConstructI64Vec3;
-        case EOpConstructI64Vec4: return RValueOperator::ConstructI64Vec4;
-        case EOpConstructU64Vec2: return RValueOperator::ConstructU64Vec2;
-        case EOpConstructU64Vec3: return RValueOperator::ConstructU64Vec3;
-        case EOpConstructU64Vec4: return RValueOperator::ConstructU64Vec4;
-        case EOpConstructDMat2x2: return RValueOperator::ConstructDMat2x2;
-        case EOpConstructDMat2x3: return RValueOperator::ConstructDMat2x3;
-        case EOpConstructDMat2x4: return RValueOperator::ConstructDMat2x4;
-        case EOpConstructDMat3x2: return RValueOperator::ConstructDMat3x2;
-        case EOpConstructDMat3x3: return RValueOperator::ConstructDMat3x3;
-        case EOpConstructDMat3x4: return RValueOperator::ConstructDMat3x4;
-        case EOpConstructDMat4x2: return RValueOperator::ConstructDMat4x2;
-        case EOpConstructDMat4x3: return RValueOperator::ConstructDMat4x3;
-        case EOpConstructDMat4x4: return RValueOperator::ConstructDMat4x4;
-        case EOpConstructIMat2x2: return RValueOperator::ConstructIMat2x2;
-        case EOpConstructIMat2x3: return RValueOperator::ConstructIMat2x3;
-        case EOpConstructIMat2x4: return RValueOperator::ConstructIMat2x4;
-        case EOpConstructIMat3x2: return RValueOperator::ConstructIMat3x2;
-        case EOpConstructIMat3x3: return RValueOperator::ConstructIMat3x3;
-        case EOpConstructIMat3x4: return RValueOperator::ConstructIMat3x4;
-        case EOpConstructIMat4x2: return RValueOperator::ConstructIMat4x2;
-        case EOpConstructIMat4x3: return RValueOperator::ConstructIMat4x3;
-        case EOpConstructIMat4x4: return RValueOperator::ConstructIMat4x4;
-        case EOpConstructUMat2x2: return RValueOperator::ConstructUMat2x2;
-        case EOpConstructUMat2x3: return RValueOperator::ConstructUMat2x3;
-        case EOpConstructUMat2x4: return RValueOperator::ConstructUMat2x4;
-        case EOpConstructUMat3x2: return RValueOperator::ConstructUMat3x2;
-        case EOpConstructUMat3x3: return RValueOperator::ConstructUMat3x3;
-        case EOpConstructUMat3x4: return RValueOperator::ConstructUMat3x4;
-        case EOpConstructUMat4x2: return RValueOperator::ConstructUMat4x2;
-        case EOpConstructUMat4x3: return RValueOperator::ConstructUMat4x3;
-        case EOpConstructUMat4x4: return RValueOperator::ConstructUMat4x4;
-        case EOpConstructBMat2x2: return RValueOperator::ConstructBMat2x2;
-        case EOpConstructBMat2x3: return RValueOperator::ConstructBMat2x3;
-        case EOpConstructBMat2x4: return RValueOperator::ConstructBMat2x4;
-        case EOpConstructBMat3x2: return RValueOperator::ConstructBMat3x2;
-        case EOpConstructBMat3x3: return RValueOperator::ConstructBMat3x3;
-        case EOpConstructBMat3x4: return RValueOperator::ConstructBMat3x4;
-        case EOpConstructBMat4x2: return RValueOperator::ConstructBMat4x2;
-        case EOpConstructBMat4x3: return RValueOperator::ConstructBMat4x3;
-        case EOpConstructBMat4x4: return RValueOperator::ConstructBMat4x4;
-        case EOpConstructFloat16: return RValueOperator::ConstructFloat16;
-        case EOpConstructF16Vec2: return RValueOperator::ConstructF16Vec2;
-        case EOpConstructF16Vec3: return RValueOperator::ConstructF16Vec3;
-        case EOpConstructF16Vec4: return RValueOperator::ConstructF16Vec4;
-        case EOpConstructF16Mat2x2: return RValueOperator::ConstructF16Mat2x2;
-        case EOpConstructF16Mat2x3: return RValueOperator::ConstructF16Mat2x3;
-        case EOpConstructF16Mat2x4: return RValueOperator::ConstructF16Mat2x4;
-        case EOpConstructF16Mat3x2: return RValueOperator::ConstructF16Mat3x2;
-        case EOpConstructF16Mat3x3: return RValueOperator::ConstructF16Mat3x3;
-        case EOpConstructF16Mat3x4: return RValueOperator::ConstructF16Mat3x4;
-        case EOpConstructF16Mat4x2: return RValueOperator::ConstructF16Mat4x2;
-        case EOpConstructF16Mat4x3: return RValueOperator::ConstructF16Mat4x3;
-        case EOpConstructF16Mat4x4: return RValueOperator::ConstructF16Mat4x4;
+        case EOpRadians: return "radians";
+        case EOpDegrees: return "degrees";
+        case EOpSin: return "sin";
+        case EOpCos: return "cos";
+        case EOpTan: return "tan";
+        case EOpAsin: return "asin";
+        case EOpAcos: return "acos";
+        case EOpAtan: return "atan";
+        case EOpSinh: return "sinh";
+        case EOpCosh: return "cosh";
+        case EOpTanh: return "tanh";
+        case EOpAsinh: return "asinh";
+        case EOpAcosh: return "acosh";
+        case EOpAtanh: return "atanh";
+        case EOpPow: return "pow";
+        case EOpExp: return "exp";
+        case EOpLog: return "log";
+        case EOpExp2: return "exp2";
+        case EOpLog2: return "log2";
+        case EOpSqrt: return "sqrt";
+        case EOpInverseSqrt: return "inversesqrt";
+        case EOpAbs: return "abs";
+        case EOpSign: return "sign";
+        case EOpFloor: return "floor";
+        case EOpTrunc: return "trunc";
+        case EOpRound: return "round";
+        case EOpRoundEven: return "roundEven";
+        case EOpCeil: return "ceil";
+        case EOpFract: return "fract";
+        case EOpModf: return "modf";
+        case EOpMin: return "min";
+        case EOpMax: return "max";
+        case EOpClamp: return "clamp";
+        case EOpMix: return "mix";
+        case EOpStep: return "step";
+        case EOpSmoothStep: return "smoothstep";
+        case EOpIsNan: return "isnan";
+        case EOpIsInf: return "isinf";
+        case EOpFma: return "fma";
+        case EOpFrexp: return "frexp";
+        case EOpLdexp: return "ldexp";
+        case EOpFloatBitsToInt: return "floatBitsToInt";
+        case EOpFloatBitsToUint: return "floatBitsToUint";
+        case EOpIntBitsToFloat: return "intBitsToFloat";
+        case EOpUintBitsToFloat: return "uintBitsToFloat";
+        case EOpDoubleBitsToInt64: return "doubleBitsToInt64";
+        case EOpDoubleBitsToUint64: return "doubleBitsToUint64";
+        case EOpInt64BitsToDouble: return "int64BitsToDouble";
+        case EOpUint64BitsToDouble: return "uint64BitsToDouble";
+        case EOpFloat16BitsToInt16: return "float16BitsToInt16";
+        case EOpFloat16BitsToInt16: return "halfBitsToInt16";
+        case EOpFloat16BitsToUint16: return "float16BitsToUint16";
+        case EOpFloat16BitsToUint16: return "halfBitsToUint16";
+        case EOpInt16BitsToFloat16: return "int16BitsToFloat16";
+        case EOpInt16BitsToFloat16: return "int16BitsToHalf";
+        case EOpUint16BitsToFloat16: return "uint16BitsToFloat16";
+        case EOpUint16BitsToFloat16: return "uint16BitsToHalf";
+        case EOpPackSnorm2x16: return "packSnorm2x16";
+        case EOpUnpackSnorm2x16: return "unpackSnorm2x16";
+        case EOpPackUnorm2x16: return "packUnorm2x16";
+        case EOpUnpackUnorm2x16: return "unpackUnorm2x16";
+        case EOpPackSnorm4x8: return "packSnorm4x8";
+        case EOpUnpackSnorm4x8: return "unpackSnorm4x8";
+        case EOpPackUnorm4x8: return "packUnorm4x8";
+        case EOpUnpackUnorm4x8: return "unpackUnorm4x8";
+        case EOpPackHalf2x16: return "packHalf2x16";
+        case EOpUnpackHalf2x16: return "unpackHalf2x16";
+        case EOpPackDouble2x32: return "packDouble2x32";
+        case EOpUnpackDouble2x32: return "unpackDouble2x32";
+        case EOpPackInt2x32: return "packInt2x32";
+        case EOpUnpackInt2x32: return "unpackInt2x32";
+        case EOpPackUint2x32: return "packUint2x32";
+        case EOpUnpackUint2x32: return "unpackUint2x32";
+        case EOpPackFloat2x16: return "packFloat2x16";
+        case EOpUnpackFloat2x16: return "unpackFloat2x16";
+        case EOpPackInt2x16: return "packInt2x16";
+        case EOpUnpackInt2x16: return "unpackInt2x16";
+        case EOpPackUint2x16: return "packUint2x16";
+        case EOpUnpackUint2x16: return "unpackUint2x16";
+        case EOpPackInt4x16: return "packInt4x16";
+        case EOpUnpackInt4x16: return "unpackInt4x16";
+        case EOpPackUint4x16: return "packUint4x16";
+        case EOpUnpackUint4x16: return "unpackUint4x16";
+        case EOpPack16: return "pack16";
+        case EOpPack32: return "pack32";
+        case EOpPack64: return "pack64";
+        case EOpUnpack32: return "unpack32";
+        case EOpUnpack16: return "unpack16";
+        case EOpUnpack8: return "unpack8";
+        case EOpLength: return "length";
+        case EOpDistance: return "distance";
+        case EOpDot: return "dot";
+        case EOpCross: return "cross";
+        case EOpNormalize: return "normalize";
+        case EOpFaceForward: return "faceforward";
+        case EOpReflect: return "reflect";
+        case EOpRefract: return "refract";
+        case EOpMin3: return "min3";
+        case EOpMax3: return "max3";
+        case EOpMid3: return "mid3";
+        case EOpDPdx: return "dFdx";
+        case EOpDPdy: return "dFdy";
+        case EOpFwidth: return "fwidth";
+        case EOpDPdxFine: return "dFdxFine";
+        case EOpDPdyFine: return "dFdyFine";
+        case EOpFwidthFine: return "fwidthFine";
+        case EOpDPdxCoarse: return "dFdxCoarse";
+        case EOpDPdyCoarse: return "dFdyCoarse";
+        case EOpFwidthCoarse: return "fwidthCoarse";
+        case EOpInterpolateAtCentroid: return "interpolateAtCentroid";
+        case EOpInterpolateAtSample: return "interpolateAtSample";
+        case EOpInterpolateAtOffset: return "interpolateAtOffset";
+        case EOpInterpolateAtVertex: return "interpolateAtVertexAMD";
+        case EOpOuterProduct: return "outerProduct";
+        case EOpDeterminant: return "determinant";
+        case EOpMatrixInverse: return "inverse";
+        case EOpTranspose: return "transpose";
+        case EOpFtransform: return "ftransform";
+        case EOpNoise: return "noise1";
+        case EOpNoise: return "noise2";
+        case EOpNoise: return "noise3";
+        case EOpNoise: return "noise4";
+        case EOpEmitVertex: return "EmitVertex";
+        case EOpEndPrimitive: return "EndPrimitive";
+        case EOpEmitStreamVertex: return "EmitStreamVertex";
+        case EOpEndStreamPrimitive: return "EndStreamPrimitive";
+        case EOpBarrier: return "barrier";
+        case EOpBarrier: return "controlBarrier";
+        case EOpMemoryBarrier: return "memoryBarrier";
+        case EOpMemoryBarrierAtomicCounter: return "memoryBarrierAtomicCounter";
+        case EOpMemoryBarrierBuffer: return "memoryBarrierAtomicCounter";
+        case EOpMemoryBarrierBuffer: return "memoryBarrierBuffer";
+        case EOpMemoryBarrierImage: return "memoryBarrierImage";
+        case EOpMemoryBarrierShared: return "memoryBarrierShared";
+        case EOpGroupMemoryBarrier: return "groupMemoryBarrier";
+        case EOpBallot: return "ballotARB";
+        case EOpReadInvocation: return "readInvocationARB";
+        case EOpReadFirstInvocation: return "readFirstInvocationARB";
+        case EOpAnyInvocation: return "anyInvocation";
+        case EOpAnyInvocation: return "anyInvocationARB";
+        case EOpAllInvocations: return "allInvocations";
+        case EOpAllInvocations: return "allInvocationsARB";
+        case EOpAllInvocationsEqual: return "allInvocationsEqual";
+        case EOpAllInvocationsEqual: return "allInvocationsEqualARB";
+        case EOpSubgroupBarrier: return "subgroupBarrier";
+        case EOpSubgroupMemoryBarrier: return "subgroupMemoryBarrier";
+        case EOpSubgroupMemoryBarrierBuffer: return "subgroupMemoryBarrierBuffer";
+        case EOpSubgroupMemoryBarrierImage: return "subgroupMemoryBarrierImage";
+        case EOpSubgroupMemoryBarrierShared: return "subgroupMemoryBarrierShared";
+        case EOpSubgroupElect: return "subgroupElect";
+        case EOpSubgroupAll: return "subgroupAll";
+        case EOpSubgroupAny: return "subgroupAny";
+        case EOpSubgroupAllEqual: return "subgroupAllEqual";
+        case EOpSubgroupBroadcast: return "subgroupBroadcast";
+        case EOpSubgroupBroadcastFirst: return "subgroupBroadcastFirst";
+        case EOpSubgroupBallot: return "subgroupBallot";
+        case EOpSubgroupInverseBallot: return "subgroupInverseBallot";
+        case EOpSubgroupBallotBitExtract: return "subgroupBallotBitExtract";
+        case EOpSubgroupBallotBitCount: return "subgroupBallotBitCount";
+        case EOpSubgroupBallotInclusiveBitCount: return "subgroupBallotInclusiveBitCount";
+        case EOpSubgroupBallotExclusiveBitCount: return "subgroupBallotExclusiveBitCount";
+        case EOpSubgroupBallotFindLSB: return "subgroupBallotFindLSB";
+        case EOpSubgroupBallotFindMSB: return "subgroupBallotFindMSB";
+        case EOpSubgroupShuffle: return "subgroupShuffle";
+        case EOpSubgroupShuffleXor: return "subgroupShuffleXor";
+        case EOpSubgroupShuffleUp: return "subgroupShuffleUp";
+        case EOpSubgroupShuffleDown: return "subgroupShuffleDown";
+        case EOpSubgroupAdd: return "subgroupAdd";
+        case EOpSubgroupMul: return "subgroupMul";
+        case EOpSubgroupMin: return "subgroupMin";
+        case EOpSubgroupMax: return "subgroupMax";
+        case EOpSubgroupAnd: return "subgroupAnd";
+        case EOpSubgroupOr: return "subgroupOr";
+        case EOpSubgroupXor: return "subgroupXor";
+        case EOpSubgroupInclusiveAdd: return "subgroupInclusiveAdd";
+        case EOpSubgroupInclusiveMul: return "subgroupInclusiveMul";
+        case EOpSubgroupInclusiveMin: return "subgroupInclusiveMin";
+        case EOpSubgroupInclusiveMax: return "subgroupInclusiveMax";
+        case EOpSubgroupInclusiveAnd: return "subgroupInclusiveAnd";
+        case EOpSubgroupInclusiveOr: return "subgroupInclusiveOr";
+        case EOpSubgroupInclusiveXor: return "subgroupInclusiveXor";
+        case EOpSubgroupExclusiveAdd: return "subgroupExclusiveAdd";
+        case EOpSubgroupExclusiveMul: return "subgroupExclusiveMul";
+        case EOpSubgroupExclusiveMin: return "subgroupExclusiveMin";
+        case EOpSubgroupExclusiveMax: return "subgroupExclusiveMax";
+        case EOpSubgroupExclusiveAnd: return "subgroupExclusiveAnd";
+        case EOpSubgroupExclusiveOr: return "subgroupExclusiveOr";
+        case EOpSubgroupExclusiveXor: return "subgroupExclusiveXor";
+        case EOpSubgroupClusteredAdd: return "subgroupClusteredAdd";
+        case EOpSubgroupClusteredMul: return "subgroupClusteredMul";
+        case EOpSubgroupClusteredMin: return "subgroupClusteredMin";
+        case EOpSubgroupClusteredMax: return "subgroupClusteredMax";
+        case EOpSubgroupClusteredAnd: return "subgroupClusteredAnd";
+        case EOpSubgroupClusteredOr: return "subgroupClusteredOr";
+        case EOpSubgroupClusteredXor: return "subgroupClusteredXor";
+        case EOpSubgroupQuadBroadcast: return "subgroupQuadBroadcast";
+        case EOpSubgroupQuadSwapHorizontal: return "subgroupQuadSwapHorizontal";
+        case EOpSubgroupQuadSwapVertical: return "subgroupQuadSwapVertical";
+        case EOpSubgroupQuadSwapDiagonal: return "subgroupQuadSwapDiagonal";
+        case EOpSubgroupPartition: return "subgroupPartitionNV";
+        case EOpSubgroupPartitionedAdd: return "subgroupPartitionedAddNV";
+        case EOpSubgroupPartitionedMul: return "subgroupPartitionedMulNV";
+        case EOpSubgroupPartitionedMin: return "subgroupPartitionedMinNV";
+        case EOpSubgroupPartitionedMax: return "subgroupPartitionedMaxNV";
+        case EOpSubgroupPartitionedAnd: return "subgroupPartitionedAndNV";
+        case EOpSubgroupPartitionedOr: return "subgroupPartitionedOrNV";
+        case EOpSubgroupPartitionedXor: return "subgroupPartitionedXorNV";
+        case EOpSubgroupPartitionedInclusiveAdd: return "subgroupPartitionedInclusiveAddNV";
+        case EOpSubgroupPartitionedInclusiveMul: return "subgroupPartitionedInclusiveMulNV";
+        case EOpSubgroupPartitionedInclusiveMin: return "subgroupPartitionedInclusiveMinNV";
+        case EOpSubgroupPartitionedInclusiveMax: return "subgroupPartitionedInclusiveMaxNV";
+        case EOpSubgroupPartitionedInclusiveAnd: return "subgroupPartitionedInclusiveAndNV";
+        case EOpSubgroupPartitionedInclusiveOr: return "subgroupPartitionedInclusiveOrNV";
+        case EOpSubgroupPartitionedInclusiveXor: return "subgroupPartitionedInclusiveXorNV";
+        case EOpSubgroupPartitionedExclusiveAdd: return "subgroupPartitionedExclusiveAddNV";
+        case EOpSubgroupPartitionedExclusiveMul: return "subgroupPartitionedExclusiveMulNV";
+        case EOpSubgroupPartitionedExclusiveMin: return "subgroupPartitionedExclusiveMinNV";
+        case EOpSubgroupPartitionedExclusiveMax: return "subgroupPartitionedExclusiveMaxNV";
+        case EOpSubgroupPartitionedExclusiveAnd: return "subgroupPartitionedExclusiveAndNV";
+        case EOpSubgroupPartitionedExclusiveOr: return "subgroupPartitionedExclusiveOrNV";
+        case EOpSubgroupPartitionedExclusiveXor: return "subgroupPartitionedExclusiveXorNV";
+        case EOpMinInvocations: return "minInvocationsAMD";
+        case EOpMaxInvocations: return "maxInvocationsAMD";
+        case EOpAddInvocations: return "addInvocationsAMD";
+        case EOpMinInvocationsNonUniform: return "minInvocationsNonUniformAMD";
+        case EOpMaxInvocationsNonUniform: return "maxInvocationsNonUniformAMD";
+        case EOpAddInvocationsNonUniform: return "addInvocationsNonUniformAMD";
+        case EOpMinInvocationsInclusiveScan: return "minInvocationsInclusiveScanAMD";
+        case EOpMaxInvocationsInclusiveScan: return "maxInvocationsInclusiveScanAMD";
+        case EOpAddInvocationsInclusiveScan: return "addInvocationsInclusiveScanAMD";
+        case EOpMinInvocationsInclusiveScanNonUniform: return "minInvocationsInclusiveScanNonUniformAMD";
+        case EOpMaxInvocationsInclusiveScanNonUniform: return "maxInvocationsInclusiveScanNonUniformAMD";
+        case EOpAddInvocationsInclusiveScanNonUniform: return "addInvocationsInclusiveScanNonUniformAMD";
+        case EOpMinInvocationsExclusiveScan: return "minInvocationsExclusiveScanAMD";
+        case EOpMaxInvocationsExclusiveScan: return "maxInvocationsExclusiveScanAMD";
+        case EOpAddInvocationsExclusiveScan: return "addInvocationsExclusiveScanAMD";
+        case EOpMinInvocationsExclusiveScanNonUniform: return "minInvocationsExclusiveScanNonUniformAMD";
+        case EOpMaxInvocationsExclusiveScanNonUniform: return "maxInvocationsExclusiveScanNonUniformAMD";
+        case EOpAddInvocationsExclusiveScanNonUniform: return "addInvocationsExclusiveScanNonUniformAMD";
+        case EOpSwizzleInvocations: return "swizzleInvocationsAMD";
+        case EOpSwizzleInvocationsMasked: return "swizzleInvocationsMaskedAMD";
+        case EOpWriteInvocation: return "writeInvocationAMD";
+        case EOpMbcnt: return "mbcntAMD";
+        case EOpCubeFaceIndex: return "cubeFaceIndexAMD";
+        case EOpCubeFaceCoord: return "cubeFaceCoordAMD";
+        case EOpTime: return "timeAMD";
+        case EOpAtomicAdd: return "atomicAdd";
+        case EOpAtomicAdd: return "atomicCounterAdd";
+        case EOpAtomicSubtract: return "atomicCounterSubtract";
+        case EOpAtomicMin: return "atomicCounterMin";
+        case EOpAtomicMin: return "atomicMin";
+        case EOpAtomicMax: return "atomicCounterMax";
+        case EOpAtomicMax: return "atomicMax";
+        case EOpAtomicAnd: return "atomicAnd";
+        case EOpAtomicAnd: return "atomicCounterAnd";
+        case EOpAtomicOr: return "atomicCounterOr";
+        case EOpAtomicOr: return "atomicOr";
+        case EOpAtomicXor: return "atomicCounterXor";
+        case EOpAtomicXor: return "atomicXor";
+        case EOpAtomicExchange: return "atomicCounterExchange";
+        case EOpAtomicExchange: return "atomicExchange";
+        case EOpAtomicCompSwap: return "atomicCompSwap";
+        case EOpAtomicCompSwap: return "atomicCounterCompSwap";
+        case EOpAtomicLoad: return "atomicLoad";
+        case EOpAtomicStore: return "atomicStore";
+        case EOpAtomicCounterIncrement: return "atomicCounterIncrement";
+        case EOpAtomicCounterDecrement: return "atomicCounterDecrement";
+        case EOpAtomicCounter: return "atomicCounter";
+        case EOpAtomicCounterAdd: return "atomicCounterAdd";
+        case EOpAtomicCounterAdd: return "atomicCounterAddARB";
+        case EOpAtomicCounterSubtract: return "atomicCounterSubtract";
+        case EOpAtomicCounterSubtract: return "atomicCounterSubtractARB";
+        case EOpAtomicCounterMin: return "atomicCounterMin";
+        case EOpAtomicCounterMin: return "atomicCounterMinARB";
+        case EOpAtomicCounterMax: return "atomicCounterMax";
+        case EOpAtomicCounterMax: return "atomicCounterMaxARB";
+        case EOpAtomicCounterAnd: return "atomicCounterAnd";
+        case EOpAtomicCounterAnd: return "atomicCounterAndARB";
+        case EOpAtomicCounterOr: return "atomicCounterOr";
+        case EOpAtomicCounterOr: return "atomicCounterOrARB";
+        case EOpAtomicCounterXor: return "atomicCounterXor";
+        case EOpAtomicCounterXor: return "atomicCounterXorARB";
+        case EOpAtomicCounterExchange: return "atomicCounterExchange";
+        case EOpAtomicCounterExchange: return "atomicCounterExchangeARB";
+        case EOpAtomicCounterCompSwap: return "atomicCounterCompSwap";
+        case EOpAtomicCounterCompSwap: return "atomicCounterCompSwapARB";
+        case EOpAny: return "any";
+        case EOpAll: return "all";
+        case EOpCooperativeMatrixLoad: return "coopMatLoad";
+        case EOpCooperativeMatrixStore: return "coopMatStore";
+        case EOpCooperativeMatrixMulAdd: return "coopMatMulAdd";
+        case EOpCooperativeMatrixLoadNV: return "coopMatLoadNV";
+        case EOpCooperativeMatrixStoreNV: return "coopMatStoreNV";
+        case EOpCooperativeMatrixMulAddNV: return "coopMatMulAddNV";
+        case EOpBeginInvocationInterlock: return "beginInvocationInterlockARB";
+        case EOpEndInvocationInterlock: return "endInvocationInterlockARB";
+        case EOpIsHelperInvocation: return "helperInvocationEXT";
+        case EOpDebugPrintf: return "debugPrintfEXT";
+        case EOpConstructInt: return "int";
+        case EOpConstructUint: return "uint";
+        case EOpConstructInt8: return "int8";
+        case EOpConstructUint8: return "uint8";
+        case EOpConstructInt16: return "int16";
+        case EOpConstructUint16: return "uint16";
+        case EOpConstructInt64: return "int64";
+        case EOpConstructUint64: return "uint64";
+        case EOpConstructBool: return "bool";
+        case EOpConstructFloat: return "float";
+        case EOpConstructDouble: return "double";
+        case EOpConstructVec2: return "vec2";
+        case EOpConstructVec3: return "vec3";
+        case EOpConstructVec4: return "vec4";
+        case EOpConstructMat2x2: return "mat2x2";
+        case EOpConstructMat2x3: return "mat2x3";
+        case EOpConstructMat2x4: return "mat2x4";
+        case EOpConstructMat3x2: return "mat3x2";
+        case EOpConstructMat3x3: return "mat3x3";
+        case EOpConstructMat3x4: return "mat3x4";
+        case EOpConstructMat4x2: return "mat4x2";
+        case EOpConstructMat4x3: return "mat4x3";
+        case EOpConstructMat4x4: return "mat4x4";
+        case EOpConstructDVec2: return "dvec2";
+        case EOpConstructDVec3: return "dvec3";
+        case EOpConstructDVec4: return "dvec4";
+        case EOpConstructBVec2: return "bvec2";
+        case EOpConstructBVec3: return "bvec3";
+        case EOpConstructBVec4: return "bvec4";
+        case EOpConstructI8Vec2: return "i8vec2";
+        case EOpConstructI8Vec3: return "i8vec3";
+        case EOpConstructI8Vec4: return "i8vec4";
+        case EOpConstructU8Vec2: return "u8vec2";
+        case EOpConstructU8Vec3: return "u8vec3";
+        case EOpConstructU8Vec4: return "u8vec4";
+        case EOpConstructI16Vec2: return "i16vec2";
+        case EOpConstructI16Vec3: return "i16vec3";
+        case EOpConstructI16Vec4: return "i16vec4";
+        case EOpConstructU16Vec2: return "u16vec2";
+        case EOpConstructU16Vec3: return "u16vec3";
+        case EOpConstructU16Vec4: return "u16vec4";
+        case EOpConstructIVec2: return "ivec2";
+        case EOpConstructIVec3: return "ivec3";
+        case EOpConstructIVec4: return "ivec4";
+        case EOpConstructUVec2: return "uvec2";
+        case EOpConstructUVec3: return "uvec3";
+        case EOpConstructUVec4: return "uvec4";
+        case EOpConstructI64Vec2: return "i64vec2";
+        case EOpConstructI64Vec3: return "i64vec3";
+        case EOpConstructI64Vec4: return "i64vec4";
+        case EOpConstructU64Vec2: return "u64vec2";
+        case EOpConstructU64Vec3: return "u64vec3";
+        case EOpConstructU64Vec4: return "u64vec4";
+        case EOpConstructDMat2x2: return "dmat2x2";
+        case EOpConstructDMat2x3: return "dmat2x3";
+        case EOpConstructDMat2x4: return "dmat2x4";
+        case EOpConstructDMat3x2: return "dmat3x2";
+        case EOpConstructDMat3x3: return "dmat3x3";
+        case EOpConstructDMat3x4: return "dmat3x4";
+        case EOpConstructDMat4x2: return "dmat4x2";
+        case EOpConstructDMat4x3: return "dmat4x3";
+        case EOpConstructDMat4x4: return "dmat4x4";
+        case EOpConstructIMat2x2: return "imat2x2";
+        case EOpConstructIMat2x3: return "imat2x3";
+        case EOpConstructIMat2x4: return "imat2x4";
+        case EOpConstructIMat3x2: return "imat3x2";
+        case EOpConstructIMat3x3: return "imat3x3";
+        case EOpConstructIMat3x4: return "imat3x4";
+        case EOpConstructIMat4x2: return "imat4x2";
+        case EOpConstructIMat4x3: return "imat4x3";
+        case EOpConstructIMat4x4: return "imat4x4";
+        case EOpConstructUMat2x2: return "umat2x2";
+        case EOpConstructUMat2x3: return "umat2x3";
+        case EOpConstructUMat2x4: return "umat2x4";
+        case EOpConstructUMat3x2: return "umat3x2";
+        case EOpConstructUMat3x3: return "umat3x3";
+        case EOpConstructUMat3x4: return "umat3x4";
+        case EOpConstructUMat4x2: return "umat4x2";
+        case EOpConstructUMat4x3: return "umat4x3";
+        case EOpConstructUMat4x4: return "umat4x4";
+        case EOpConstructBMat2x2: return "bmat2x2";
+        case EOpConstructBMat2x3: return "bmat2x3";
+        case EOpConstructBMat2x4: return "bmat2x4";
+        case EOpConstructBMat3x2: return "bmat3x2";
+        case EOpConstructBMat3x3: return "bmat3x3";
+        case EOpConstructBMat3x4: return "bmat3x4";
+        case EOpConstructBMat4x2: return "bmat4x2";
+        case EOpConstructBMat4x3: return "bmat4x3";
+        case EOpConstructBMat4x4: return "bmat4x4";
+        case EOpConstructFloat16: return "float16";
+        case EOpConstructF16Vec2: return "f16vec2";
+        case EOpConstructF16Vec3: return "f16vec3";
+        case EOpConstructF16Vec4: return "f16vec4";
+        case EOpConstructF16Mat2x2: return "f16mat2x2";
+        case EOpConstructF16Mat2x3: return "f16mat2x3";
+        case EOpConstructF16Mat2x4: return "f16mat2x4";
+        case EOpConstructF16Mat3x2: return "f16mat3x2";
+        case EOpConstructF16Mat3x3: return "f16mat3x3";
+        case EOpConstructF16Mat3x4: return "f16mat3x4";
+        case EOpConstructF16Mat4x2: return "f16mat4x2";
+        case EOpConstructF16Mat4x3: return "f16mat4x3";
+        case EOpConstructF16Mat4x4: return "f16mat4x4";
         case EOpConstructStruct: return RValueOperator::ConstructStruct;
-        case EOpConstructTextureSampler: return RValueOperator::ConstructTextureSampler;
-        case EOpConstructNonuniform: return RValueOperator::ConstructNonuniform;
-        case EOpConstructReference: return RValueOperator::ConstructReference;
-        case EOpConstructCooperativeMatrixNV: return RValueOperator::ConstructCooperativeMatrixNV;
-        case EOpConstructCooperativeMatrixKHR: return RValueOperator::ConstructCooperativeMatrixKHR;
-        case EOpConstructAccStruct: return RValueOperator::ConstructAccStruct;
-        case EOpConstructGuardEnd: return RValueOperator::ConstructGuardEnd;
+        case EOpConstructTextureSampler: return "textureSampler";
+        case EOpConstructNonuniform: return "nonuniform";
+        case EOpConstructReference: return "reference";
+        case EOpConstructCooperativeMatrixNV: return "cooperativeMatrixNV";
+        case EOpConstructCooperativeMatrixKHR: return "cooperativeMatrixKHR";
         case EOpAssign: return RValueOperator::Assign;
         case EOpAddAssign: return RValueOperator::AddAssign;
         case EOpSubAssign: return RValueOperator::SubAssign;
@@ -607,176 +514,228 @@ RValueOperator glslangOperatorToRValueOperator(glslang::TOperator op) {
         case EOpLeftShiftAssign: return RValueOperator::LeftShiftAssign;
         case EOpRightShiftAssign: return RValueOperator::RightShiftAssign;
         case EOpArrayLength: return RValueOperator::ArrayLength;
-        case EOpImageGuardBegin: return RValueOperator::ImageGuardBegin;
-        case EOpImageQuerySize: return RValueOperator::ImageQuerySize;
-        case EOpImageQuerySamples: return RValueOperator::ImageQuerySamples;
-        case EOpImageLoad: return RValueOperator::ImageLoad;
-        case EOpImageStore: return RValueOperator::ImageStore;
-        case EOpImageLoadLod: return RValueOperator::ImageLoadLod;
-        case EOpImageStoreLod: return RValueOperator::ImageStoreLod;
-        case EOpImageAtomicAdd: return RValueOperator::ImageAtomicAdd;
-        case EOpImageAtomicMin: return RValueOperator::ImageAtomicMin;
-        case EOpImageAtomicMax: return RValueOperator::ImageAtomicMax;
-        case EOpImageAtomicAnd: return RValueOperator::ImageAtomicAnd;
-        case EOpImageAtomicOr: return RValueOperator::ImageAtomicOr;
-        case EOpImageAtomicXor: return RValueOperator::ImageAtomicXor;
-        case EOpImageAtomicExchange: return RValueOperator::ImageAtomicExchange;
-        case EOpImageAtomicCompSwap: return RValueOperator::ImageAtomicCompSwap;
-        case EOpImageAtomicLoad: return RValueOperator::ImageAtomicLoad;
-        case EOpImageAtomicStore: return RValueOperator::ImageAtomicStore;
-        case EOpSubpassLoad: return RValueOperator::SubpassLoad;
-        case EOpSubpassLoadMS: return RValueOperator::SubpassLoadMS;
-        case EOpSparseImageLoad: return RValueOperator::SparseImageLoad;
-        case EOpSparseImageLoadLod: return RValueOperator::SparseImageLoadLod;
-        case EOpColorAttachmentReadEXT: return RValueOperator::ColorAttachmentReadEXT;
-        case EOpImageGuardEnd: return RValueOperator::ImageGuardEnd;
-        case EOpTextureGuardBegin: return RValueOperator::TextureGuardBegin;
-        case EOpTextureQuerySize: return RValueOperator::TextureQuerySize;
-        case EOpTextureQueryLod: return RValueOperator::TextureQueryLod;
-        case EOpTextureQueryLevels: return RValueOperator::TextureQueryLevels;
-        case EOpTextureQuerySamples: return RValueOperator::TextureQuerySamples;
-        case EOpSamplingGuardBegin: return RValueOperator::SamplingGuardBegin;
-        case EOpTexture: return RValueOperator::Texture;
-        case EOpTextureProj: return RValueOperator::TextureProj;
-        case EOpTextureLod: return RValueOperator::TextureLod;
-        case EOpTextureOffset: return RValueOperator::TextureOffset;
-        case EOpTextureFetch: return RValueOperator::TextureFetch;
-        case EOpTextureFetchOffset: return RValueOperator::TextureFetchOffset;
-        case EOpTextureProjOffset: return RValueOperator::TextureProjOffset;
-        case EOpTextureLodOffset: return RValueOperator::TextureLodOffset;
-        case EOpTextureProjLod: return RValueOperator::TextureProjLod;
-        case EOpTextureProjLodOffset: return RValueOperator::TextureProjLodOffset;
-        case EOpTextureGrad: return RValueOperator::TextureGrad;
-        case EOpTextureGradOffset: return RValueOperator::TextureGradOffset;
-        case EOpTextureProjGrad: return RValueOperator::TextureProjGrad;
-        case EOpTextureProjGradOffset: return RValueOperator::TextureProjGradOffset;
-        case EOpTextureGather: return RValueOperator::TextureGather;
-        case EOpTextureGatherOffset: return RValueOperator::TextureGatherOffset;
-        case EOpTextureGatherOffsets: return RValueOperator::TextureGatherOffsets;
-        case EOpTextureClamp: return RValueOperator::TextureClamp;
-        case EOpTextureOffsetClamp: return RValueOperator::TextureOffsetClamp;
-        case EOpTextureGradClamp: return RValueOperator::TextureGradClamp;
-        case EOpTextureGradOffsetClamp: return RValueOperator::TextureGradOffsetClamp;
-        case EOpTextureGatherLod: return RValueOperator::TextureGatherLod;
-        case EOpTextureGatherLodOffset: return RValueOperator::TextureGatherLodOffset;
-        case EOpTextureGatherLodOffsets: return RValueOperator::TextureGatherLodOffsets;
-        case EOpFragmentMaskFetch: return RValueOperator::FragmentMaskFetch;
-        case EOpFragmentFetch: return RValueOperator::FragmentFetch;
-        case EOpSparseTextureGuardBegin: return RValueOperator::SparseTextureGuardBegin;
-        case EOpSparseTexture: return RValueOperator::SparseTexture;
-        case EOpSparseTextureLod: return RValueOperator::SparseTextureLod;
-        case EOpSparseTextureOffset: return RValueOperator::SparseTextureOffset;
-        case EOpSparseTextureFetch: return RValueOperator::SparseTextureFetch;
-        case EOpSparseTextureFetchOffset: return RValueOperator::SparseTextureFetchOffset;
-        case EOpSparseTextureLodOffset: return RValueOperator::SparseTextureLodOffset;
-        case EOpSparseTextureGrad: return RValueOperator::SparseTextureGrad;
-        case EOpSparseTextureGradOffset: return RValueOperator::SparseTextureGradOffset;
-        case EOpSparseTextureGather: return RValueOperator::SparseTextureGather;
-        case EOpSparseTextureGatherOffset: return RValueOperator::SparseTextureGatherOffset;
-        case EOpSparseTextureGatherOffsets: return RValueOperator::SparseTextureGatherOffsets;
-        case EOpSparseTexelsResident: return RValueOperator::SparseTexelsResident;
-        case EOpSparseTextureClamp: return RValueOperator::SparseTextureClamp;
-        case EOpSparseTextureOffsetClamp: return RValueOperator::SparseTextureOffsetClamp;
-        case EOpSparseTextureGradClamp: return RValueOperator::SparseTextureGradClamp;
-        case EOpSparseTextureGradOffsetClamp: return RValueOperator::SparseTextureGradOffsetClamp;
-        case EOpSparseTextureGatherLod: return RValueOperator::SparseTextureGatherLod;
-        case EOpSparseTextureGatherLodOffset: return RValueOperator::SparseTextureGatherLodOffset;
-        case EOpSparseTextureGatherLodOffsets: return RValueOperator::SparseTextureGatherLodOffsets;
-        case EOpSparseTextureGuardEnd: return RValueOperator::SparseTextureGuardEnd;
-        case EOpImageFootprintGuardBegin: return RValueOperator::ImageFootprintGuardBegin;
-        case EOpImageSampleFootprintNV: return RValueOperator::ImageSampleFootprintNV;
-        case EOpImageSampleFootprintClampNV: return RValueOperator::ImageSampleFootprintClampNV;
-        case EOpImageSampleFootprintLodNV: return RValueOperator::ImageSampleFootprintLodNV;
-        case EOpImageSampleFootprintGradNV: return RValueOperator::ImageSampleFootprintGradNV;
-        case EOpImageSampleFootprintGradClampNV: return RValueOperator::ImageSampleFootprintGradClampNV;
-        case EOpImageFootprintGuardEnd: return RValueOperator::ImageFootprintGuardEnd;
-        case EOpSamplingGuardEnd: return RValueOperator::SamplingGuardEnd;
-        case EOpTextureGuardEnd: return RValueOperator::TextureGuardEnd;
-        case EOpAddCarry: return RValueOperator::AddCarry;
-        case EOpSubBorrow: return RValueOperator::SubBorrow;
-        case EOpUMulExtended: return RValueOperator::UMulExtended;
-        case EOpIMulExtended: return RValueOperator::IMulExtended;
-        case EOpBitfieldExtract: return RValueOperator::BitfieldExtract;
-        case EOpBitfieldInsert: return RValueOperator::BitfieldInsert;
-        case EOpBitFieldReverse: return RValueOperator::BitFieldReverse;
-        case EOpBitCount: return RValueOperator::BitCount;
-        case EOpFindLSB: return RValueOperator::FindLSB;
-        case EOpFindMSB: return RValueOperator::FindMSB;
-        case EOpCountLeadingZeros: return RValueOperator::CountLeadingZeros;
-        case EOpCountTrailingZeros: return RValueOperator::CountTrailingZeros;
-        case EOpAbsDifference: return RValueOperator::AbsDifference;
-        case EOpAddSaturate: return RValueOperator::AddSaturate;
-        case EOpSubSaturate: return RValueOperator::SubSaturate;
-        case EOpAverage: return RValueOperator::Average;
-        case EOpAverageRounded: return RValueOperator::AverageRounded;
-        case EOpMul32x16: return RValueOperator::Mul32x16;
-        case EOpTraceNV: return RValueOperator::TraceNV;
-        case EOpTraceRayMotionNV: return RValueOperator::TraceRayMotionNV;
-        case EOpTraceKHR: return RValueOperator::TraceKHR;
-        case EOpReportIntersection: return RValueOperator::ReportIntersection;
-        case EOpIgnoreIntersectionNV: return RValueOperator::IgnoreIntersectionNV;
-        case EOpTerminateRayNV: return RValueOperator::TerminateRayNV;
-        case EOpExecuteCallableNV: return RValueOperator::ExecuteCallableNV;
-        case EOpExecuteCallableKHR: return RValueOperator::ExecuteCallableKHR;
-        case EOpWritePackedPrimitiveIndices4x8NV: return RValueOperator::WritePackedPrimitiveIndices4x8NV;
-        case EOpEmitMeshTasksEXT: return RValueOperator::EmitMeshTasksEXT;
-        case EOpSetMeshOutputsEXT: return RValueOperator::SetMeshOutputsEXT;
-        case EOpRayQueryInitialize: return RValueOperator::RayQueryInitialize;
-        case EOpRayQueryTerminate: return RValueOperator::RayQueryTerminate;
-        case EOpRayQueryGenerateIntersection: return RValueOperator::RayQueryGenerateIntersection;
-        case EOpRayQueryConfirmIntersection: return RValueOperator::RayQueryConfirmIntersection;
-        case EOpRayQueryProceed: return RValueOperator::RayQueryProceed;
-        case EOpRayQueryGetIntersectionType: return RValueOperator::RayQueryGetIntersectionType;
-        case EOpRayQueryGetRayTMin: return RValueOperator::RayQueryGetRayTMin;
-        case EOpRayQueryGetRayFlags: return RValueOperator::RayQueryGetRayFlags;
-        case EOpRayQueryGetIntersectionT: return RValueOperator::RayQueryGetIntersectionT;
-        case EOpRayQueryGetIntersectionInstanceCustomIndex: return RValueOperator::RayQueryGetIntersectionInstanceCustomIndex;
-        case EOpRayQueryGetIntersectionInstanceId: return RValueOperator::RayQueryGetIntersectionInstanceId;
-        case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: return RValueOperator::RayQueryGetIntersectionInstanceShaderBindingTableRecordOffset;
-        case EOpRayQueryGetIntersectionGeometryIndex: return RValueOperator::RayQueryGetIntersectionGeometryIndex;
-        case EOpRayQueryGetIntersectionPrimitiveIndex: return RValueOperator::RayQueryGetIntersectionPrimitiveIndex;
-        case EOpRayQueryGetIntersectionBarycentrics: return RValueOperator::RayQueryGetIntersectionBarycentrics;
-        case EOpRayQueryGetIntersectionFrontFace: return RValueOperator::RayQueryGetIntersectionFrontFace;
-        case EOpRayQueryGetIntersectionCandidateAABBOpaque: return RValueOperator::RayQueryGetIntersectionCandidateAABBOpaque;
-        case EOpRayQueryGetIntersectionObjectRayDirection: return RValueOperator::RayQueryGetIntersectionObjectRayDirection;
-        case EOpRayQueryGetIntersectionObjectRayOrigin: return RValueOperator::RayQueryGetIntersectionObjectRayOrigin;
-        case EOpRayQueryGetWorldRayDirection: return RValueOperator::RayQueryGetWorldRayDirection;
-        case EOpRayQueryGetWorldRayOrigin: return RValueOperator::RayQueryGetWorldRayOrigin;
-        case EOpRayQueryGetIntersectionObjectToWorld: return RValueOperator::RayQueryGetIntersectionObjectToWorld;
-        case EOpRayQueryGetIntersectionWorldToObject: return RValueOperator::RayQueryGetIntersectionWorldToObject;
-        case EOpHitObjectTraceRayNV: return RValueOperator::HitObjectTraceRayNV;
-        case EOpHitObjectTraceRayMotionNV: return RValueOperator::HitObjectTraceRayMotionNV;
-        case EOpHitObjectRecordHitNV: return RValueOperator::HitObjectRecordHitNV;
-        case EOpHitObjectRecordHitMotionNV: return RValueOperator::HitObjectRecordHitMotionNV;
-        case EOpHitObjectRecordHitWithIndexNV: return RValueOperator::HitObjectRecordHitWithIndexNV;
-        case EOpHitObjectRecordHitWithIndexMotionNV: return RValueOperator::HitObjectRecordHitWithIndexMotionNV;
-        case EOpHitObjectRecordMissNV: return RValueOperator::HitObjectRecordMissNV;
-        case EOpHitObjectRecordMissMotionNV: return RValueOperator::HitObjectRecordMissMotionNV;
-        case EOpHitObjectRecordEmptyNV: return RValueOperator::HitObjectRecordEmptyNV;
-        case EOpHitObjectExecuteShaderNV: return RValueOperator::HitObjectExecuteShaderNV;
-        case EOpHitObjectIsEmptyNV: return RValueOperator::HitObjectIsEmptyNV;
-        case EOpHitObjectIsMissNV: return RValueOperator::HitObjectIsMissNV;
-        case EOpHitObjectIsHitNV: return RValueOperator::HitObjectIsHitNV;
-        case EOpHitObjectGetRayTMinNV: return RValueOperator::HitObjectGetRayTMinNV;
-        case EOpHitObjectGetRayTMaxNV: return RValueOperator::HitObjectGetRayTMaxNV;
-        case EOpHitObjectGetObjectRayOriginNV: return RValueOperator::HitObjectGetObjectRayOriginNV;
-        case EOpHitObjectGetObjectRayDirectionNV: return RValueOperator::HitObjectGetObjectRayDirectionNV;
-        case EOpHitObjectGetWorldRayOriginNV: return RValueOperator::HitObjectGetWorldRayOriginNV;
-        case EOpHitObjectGetWorldRayDirectionNV: return RValueOperator::HitObjectGetWorldRayDirectionNV;
-        case EOpHitObjectGetWorldToObjectNV: return RValueOperator::HitObjectGetWorldToObjectNV;
-        case EOpHitObjectGetObjectToWorldNV: return RValueOperator::HitObjectGetObjectToWorldNV;
-        case EOpHitObjectGetInstanceCustomIndexNV: return RValueOperator::HitObjectGetInstanceCustomIndexNV;
-        case EOpHitObjectGetInstanceIdNV: return RValueOperator::HitObjectGetInstanceIdNV;
-        case EOpHitObjectGetGeometryIndexNV: return RValueOperator::HitObjectGetGeometryIndexNV;
-        case EOpHitObjectGetPrimitiveIndexNV: return RValueOperator::HitObjectGetPrimitiveIndexNV;
-        case EOpHitObjectGetHitKindNV: return RValueOperator::HitObjectGetHitKindNV;
-        case EOpHitObjectGetShaderBindingTableRecordIndexNV: return RValueOperator::HitObjectGetShaderBindingTableRecordIndexNV;
-        case EOpHitObjectGetShaderRecordBufferHandleNV: return RValueOperator::HitObjectGetShaderRecordBufferHandleNV;
-        case EOpHitObjectGetAttributesNV: return RValueOperator::HitObjectGetAttributesNV;
-        case EOpHitObjectGetCurrentTimeNV: return RValueOperator::HitObjectGetCurrentTimeNV;
-        case EOpReorderThreadNV: return RValueOperator::ReorderThreadNV;
-        case EOpFetchMicroTriangleVertexPositionNV: return RValueOperator::FetchMicroTriangleVertexPositionNV;
-        case EOpFetchMicroTriangleVertexBarycentricNV: return RValueOperator::FetchMicroTriangleVertexBarycentricNV;
+        case EOpImageQuerySize: return "imageSize";
+        case EOpImageQuerySamples: return "imageSamples";
+        case EOpImageLoad: return "imageLoad";
+        case EOpImageStore: return "imageStore";
+        case EOpImageLoadLod: return "imageLoadLodAMD";
+        case EOpImageStoreLod: return "imageStoreLodAMD";
+        case EOpImageAtomicAdd: return "imageAtomicAdd";
+        case EOpImageAtomicMin: return "imageAtomicMin";
+        case EOpImageAtomicMax: return "imageAtomicMax";
+        case EOpImageAtomicAnd: return "imageAtomicAnd";
+        case EOpImageAtomicOr: return "imageAtomicOr";
+        case EOpImageAtomicXor: return "imageAtomicXor";
+        case EOpImageAtomicExchange: return "imageAtomicExchange";
+        case EOpImageAtomicCompSwap: return "imageAtomicCompSwap";
+        case EOpImageAtomicLoad: return "imageAtomicLoad";
+        case EOpImageAtomicStore: return "imageAtomicStore";
+        case EOpSubpassLoad: return "subpassLoad";
+        case EOpSubpassLoadMS: return "subpassLoadMS";
+        case EOpSparseImageLoad: return "sparseImageLoadARB";
+        case EOpSparseImageLoadLod: return "sparseImageLoadLodAMD";
+        case EOpColorAttachmentReadEXT: return "colorAttachmentReadEXT";
+        case EOpTextureQuerySize: return "textureSize";
+        case EOpTextureQueryLod: return "textureQueryLOD";
+        case EOpTextureQueryLod: return "textureQueryLod";
+        case EOpTextureQueryLevels: return "textureQueryLevels";
+        case EOpTextureQuerySamples: return "textureSamples";
+        case EOpTexture: return "shadow1D";
+        case EOpTexture: return "shadow2D";
+        case EOpTexture: return "shadow2DEXT";
+        case EOpTexture: return "shadow2DRect";
+        case EOpTexture: return "texture";
+        case EOpTexture: return "texture1D";
+        case EOpTexture: return "texture2D";
+        case EOpTexture: return "texture2DRect";
+        case EOpTexture: return "texture3D";
+        case EOpTexture: return "textureCube";
+        case EOpTextureProj: return "shadow1DProj";
+        case EOpTextureProj: return "shadow2DProj";
+        case EOpTextureProj: return "shadow2DProjEXT";
+        case EOpTextureProj: return "shadow2DRectProj";
+        case EOpTextureProj: return "texture1DProj";
+        case EOpTextureProj: return "texture2DProj";
+        case EOpTextureProj: return "texture2DRectProj";
+        case EOpTextureProj: return "texture3DProj";
+        case EOpTextureProj: return "textureProj";
+        case EOpTextureLod: return "shadow1DLod";
+        case EOpTextureLod: return "shadow2DLod";
+        case EOpTextureLod: return "texture1DLod";
+        case EOpTextureLod: return "texture2DLod";
+        case EOpTextureLod: return "texture2DLodEXT";
+        case EOpTextureLod: return "texture3DLod";
+        case EOpTextureLod: return "textureCubeLod";
+        case EOpTextureLod: return "textureCubeLodEXT";
+        case EOpTextureLod: return "textureLod";
+        case EOpTextureOffset: return "textureOffset";
+        case EOpTextureFetch: return "texelFetch";
+        case EOpTextureFetchOffset: return "texelFetchOffset";
+        case EOpTextureProjOffset: return "textureProjOffset";
+        case EOpTextureLodOffset: return "textureLodOffset";
+        case EOpTextureProjLod: return "shadow1DProjLod";
+        case EOpTextureProjLod: return "shadow2DProjLod";
+        case EOpTextureProjLod: return "texture1DProjLod";
+        case EOpTextureProjLod: return "texture2DProjLod";
+        case EOpTextureProjLod: return "texture2DProjLodEXT";
+        case EOpTextureProjLod: return "texture3DProjLod";
+        case EOpTextureProjLod: return "textureProjLod";
+        case EOpTextureProjLodOffset: return "textureProjLodOffset";
+        case EOpTextureGrad: return "shadow1DGradARB";
+        case EOpTextureGrad: return "shadow2DGradARB";
+        case EOpTextureGrad: return "shadow2DRectGradARB";
+        case EOpTextureGrad: return "texture1DGradARB";
+        case EOpTextureGrad: return "texture2DGradARB";
+        case EOpTextureGrad: return "texture2DGradEXT";
+        case EOpTextureGrad: return "texture2DRectGradARB";
+        case EOpTextureGrad: return "texture3DGradARB";
+        case EOpTextureGrad: return "textureCubeGradARB";
+        case EOpTextureGrad: return "textureCubeGradEXT";
+        case EOpTextureGrad: return "textureGrad";
+        case EOpTextureGradOffset: return "textureGradOffset";
+        case EOpTextureProjGrad: return "shadow1DProjGradARB";
+        case EOpTextureProjGrad: return "shadow2DProjGradARB";
+        case EOpTextureProjGrad: return "shadow2DRectProjGradARB";
+        case EOpTextureProjGrad: return "texture1DProjGradARB";
+        case EOpTextureProjGrad: return "texture2DProjGradARB";
+        case EOpTextureProjGrad: return "texture2DProjGradEXT";
+        case EOpTextureProjGrad: return "texture2DRectProjGradARB";
+        case EOpTextureProjGrad: return "texture3DProjGradARB";
+        case EOpTextureProjGrad: return "textureProjGrad";
+        case EOpTextureProjGradOffset: return "textureProjGradOffset";
+        case EOpTextureGather: return "textureGather";
+        case EOpTextureGatherOffset: return "textureGatherOffset";
+        case EOpTextureGatherOffsets: return "textureGatherOffsets";
+        case EOpTextureClamp: return "textureClampARB";
+        case EOpTextureOffsetClamp: return "textureOffsetClampARB";
+        case EOpTextureGradClamp: return "textureGradClampARB";
+        case EOpTextureGradOffsetClamp: return "textureGradOffsetClampARB";
+        case EOpTextureGatherLod: return "textureGatherLodAMD";
+        case EOpTextureGatherLodOffset: return "textureGatherLodOffsetAMD";
+        case EOpTextureGatherLodOffsets: return "textureGatherLodOffsetsAMD";
+        case EOpFragmentMaskFetch: return "fragmentMaskFetchAMD";
+        case EOpFragmentFetch: return "fragmentFetchAMD";
+        case EOpSparseTexture: return "sparseTextureARB";
+        case EOpSparseTextureLod: return "sparseTextureLodARB";
+        case EOpSparseTextureOffset: return "sparseTextureOffsetARB";
+        case EOpSparseTextureFetch: return "sparseTexelFetchARB";
+        case EOpSparseTextureFetchOffset: return "sparseTexelFetchOffsetARB";
+        case EOpSparseTextureLodOffset: return "sparseTextureLodOffsetARB";
+        case EOpSparseTextureGrad: return "sparseTextureGradARB";
+        case EOpSparseTextureGradOffset: return "sparseTextureGradOffsetARB";
+        case EOpSparseTextureGather: return "sparseTextureGatherARB";
+        case EOpSparseTextureGatherOffset: return "sparseTextureGatherOffsetARB";
+        case EOpSparseTextureGatherOffsets: return "sparseTextureGatherOffsetsARB";
+        case EOpSparseTexelsResident: return "sparseTexelsResidentARB";
+        case EOpSparseTextureClamp: return "sparseTextureClampARB";
+        case EOpSparseTextureOffsetClamp: return "sparseTextureOffsetClampARB";
+        case EOpSparseTextureGradClamp: return "sparseTextureGradClampARB";
+        case EOpSparseTextureGradOffsetClamp: return "sparseTextureGradOffsetClampARB";
+        case EOpSparseTextureGatherLod: return "sparseTextureGatherLodAMD";
+        case EOpSparseTextureGatherLodOffset: return "sparseTextureGatherLodOffsetAMD";
+        case EOpSparseTextureGatherLodOffsets: return "sparseTextureGatherLodOffsetsAMD";
+        case EOpImageSampleFootprintNV: return "textureFootprintNV";
+        case EOpImageSampleFootprintClampNV: return "textureFootprintClampNV";
+        case EOpImageSampleFootprintLodNV: return "textureFootprintLodNV";
+        case EOpImageSampleFootprintGradNV: return "textureFootprintGradNV";
+        case EOpImageSampleFootprintGradClampNV: return "textureFootprintGradClampNV";
+        case EOpAddCarry: return "uaddCarry";
+        case EOpSubBorrow: return "usubBorrow";
+        case EOpUMulExtended: return "umulExtended";
+        case EOpIMulExtended: return "imulExtended";
+        case EOpBitfieldExtract: return "bitfieldExtract";
+        case EOpBitfieldInsert: return "bitfieldInsert";
+        case EOpBitFieldReverse: return "bitfieldReverse";
+        case EOpBitCount: return "bitCount";
+        case EOpFindLSB: return "findLSB";
+        case EOpFindMSB: return "findMSB";
+        case EOpCountLeadingZeros: return "countLeadingZeros";
+        case EOpCountTrailingZeros: return "countTrailingZeros";
+        case EOpAbsDifference: return "absoluteDifference";
+        case EOpAddSaturate: return "addSaturate";
+        case EOpSubSaturate: return "subtractSaturate";
+        case EOpAverage: return "average";
+        case EOpAverageRounded: return "averageRounded";
+        case EOpMul32x16: return "multiply32x16";
+        case EOpTraceNV: return "traceNV";
+        case EOpTraceRayMotionNV: return "traceRayMotionNV";
+        case EOpTraceKHR: return "traceRayEXT";
+        case EOpReportIntersection: return "reportIntersectionEXT";
+        case EOpReportIntersection: return "reportIntersectionNV";
+        case EOpIgnoreIntersectionNV: return "ignoreIntersectionNV";
+        case EOpTerminateRayNV: return "terminateRayNV";
+        case EOpExecuteCallableNV: return "executeCallableNV";
+        case EOpExecuteCallableKHR: return "executeCallableEXT";
+        case EOpWritePackedPrimitiveIndices4x8NV: return "writePackedPrimitiveIndices4x8NV";
+        case EOpEmitMeshTasksEXT: return "EmitMeshTasksEXT";
+        case EOpSetMeshOutputsEXT: return "SetMeshOutputsEXT";
+        case EOpRayQueryInitialize: return "rayQueryInitializeEXT";
+        case EOpRayQueryTerminate: return "rayQueryTerminateEXT";
+        case EOpRayQueryGenerateIntersection: return "rayQueryGenerateIntersectionEXT";
+        case EOpRayQueryConfirmIntersection: return "rayQueryConfirmIntersectionEXT";
+        case EOpRayQueryProceed: return "rayQueryProceedEXT";
+        case EOpRayQueryGetIntersectionType: return "rayQueryGetIntersectionTypeEXT";
+        case EOpRayQueryGetRayTMin: return "rayQueryGetRayTMinEXT";
+        case EOpRayQueryGetRayFlags: return "rayQueryGetRayFlagsEXT";
+        case EOpRayQueryGetIntersectionT: return "rayQueryGetIntersectionTEXT";
+        case EOpRayQueryGetIntersectionInstanceCustomIndex: return "rayQueryGetIntersectionInstanceCustomIndexEXT";
+        case EOpRayQueryGetIntersectionInstanceId: return "rayQueryGetIntersectionInstanceIdEXT";
+        case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: return "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT";
+        case EOpRayQueryGetIntersectionGeometryIndex: return "rayQueryGetIntersectionGeometryIndexEXT";
+        case EOpRayQueryGetIntersectionPrimitiveIndex: return "rayQueryGetIntersectionPrimitiveIndexEXT";
+        case EOpRayQueryGetIntersectionBarycentrics: return "rayQueryGetIntersectionBarycentricsEXT";
+        case EOpRayQueryGetIntersectionFrontFace: return "rayQueryGetIntersectionFrontFaceEXT";
+        case EOpRayQueryGetIntersectionCandidateAABBOpaque: return "rayQueryGetIntersectionCandidateAABBOpaqueEXT";
+        case EOpRayQueryGetIntersectionObjectRayDirection: return "rayQueryGetIntersectionObjectRayDirectionEXT";
+        case EOpRayQueryGetIntersectionObjectRayOrigin: return "rayQueryGetIntersectionObjectRayOriginEXT";
+        case EOpRayQueryGetWorldRayDirection: return "rayQueryGetWorldRayDirectionEXT";
+        case EOpRayQueryGetWorldRayOrigin: return "rayQueryGetWorldRayOriginEXT";
+        case EOpRayQueryGetIntersectionObjectToWorld: return "rayQueryGetIntersectionObjectToWorldEXT";
+        case EOpRayQueryGetIntersectionWorldToObject: return "rayQueryGetIntersectionWorldToObjectEXT";
+        case EOpHitObjectTraceRayNV: return "hitObjectTraceRayNV";
+        case EOpHitObjectTraceRayMotionNV: return "hitObjectTraceRayMotionNV";
+        case EOpHitObjectRecordHitNV: return "hitObjectRecordHitNV";
+        case EOpHitObjectRecordHitMotionNV: return "hitObjectRecordHitMotionNV";
+        case EOpHitObjectRecordHitWithIndexNV: return "hitObjectRecordHitWithIndexNV";
+        case EOpHitObjectRecordHitWithIndexMotionNV: return "hitObjectRecordHitWithIndexMotionNV";
+        case EOpHitObjectRecordMissNV: return "hitObjectRecordMissNV";
+        case EOpHitObjectRecordMissMotionNV: return "hitObjectRecordMissMotionNV";
+        case EOpHitObjectRecordEmptyNV: return "hitObjectRecordEmptyNV";
+        case EOpHitObjectExecuteShaderNV: return "hitObjectExecuteShaderNV";
+        case EOpHitObjectIsEmptyNV: return "hitObjectIsEmptyNV";
+        case EOpHitObjectIsMissNV: return "hitObjectIsMissNV";
+        case EOpHitObjectIsHitNV: return "hitObjectIsHitNV";
+        case EOpHitObjectGetRayTMinNV: return "hitObjectGetRayTMinNV";
+        case EOpHitObjectGetRayTMaxNV: return "hitObjectGetRayTMaxNV";
+        case EOpHitObjectGetObjectRayOriginNV: return "hitObjectGetObjectRayOriginNV";
+        case EOpHitObjectGetObjectRayDirectionNV: return "hitObjectGetObjectRayDirectionNV";
+        case EOpHitObjectGetWorldRayOriginNV: return "hitObjectGetWorldRayOriginNV";
+        case EOpHitObjectGetWorldRayDirectionNV: return "hitObjectGetWorldRayDirectionNV";
+        case EOpHitObjectGetWorldToObjectNV: return "hitObjectGetWorldToObjectNV";
+        case EOpHitObjectGetObjectToWorldNV: return "hitObjectGetObjectToWorldNV";
+        case EOpHitObjectGetInstanceCustomIndexNV: return "hitObjectGetInstanceCustomIndexNV";
+        case EOpHitObjectGetInstanceIdNV: return "hitObjectGetInstanceIdNV";
+        case EOpHitObjectGetGeometryIndexNV: return "hitObjectGetGeometryIndexNV";
+        case EOpHitObjectGetPrimitiveIndexNV: return "hitObjectGetPrimitiveIndexNV";
+        case EOpHitObjectGetHitKindNV: return "hitObjectGetHitKindNV";
+        case EOpHitObjectGetShaderBindingTableRecordIndexNV: return "hitObjectGetShaderBindingTableRecordIndexNV";
+        case EOpHitObjectGetShaderRecordBufferHandleNV: return "hitObjectGetShaderRecordBufferHandleNV";
+        case EOpHitObjectGetAttributesNV: return "hitObjectGetAttributesNV";
+        case EOpHitObjectGetCurrentTimeNV: return "hitObjectGetCurrentTimeNV";
+        case EOpReorderThreadNV: return "reorderThreadNV";
+        case EOpFetchMicroTriangleVertexPositionNV: return "fetchMicroTriangleVertexPositionNV";
+        case EOpFetchMicroTriangleVertexBarycentricNV: return "fetchMicroTriangleVertexBarycentricNV";
+        case EOpReadClockSubgroupKHR: return "clock2x32ARB";
+        case EOpReadClockSubgroupKHR: return "clockARB";
+        case EOpReadClockDeviceKHR: return "clockRealtime2x32EXT";
+        case EOpReadClockDeviceKHR: return "clockRealtimeEXT";
+        case EOpRayQueryGetIntersectionTriangleVertexPositionsEXT: return "rayQueryGetIntersectionTriangleVertexPositionsEXT";
+        case EOpStencilAttachmentReadEXT: return "stencilAttachmentReadEXT";
+        case EOpDepthAttachmentReadEXT: return "depthAttachmentReadEXT";
+        case EOpImageSampleWeightedQCOM: return "textureWeightedQCOM";
+        case EOpImageBoxFilterQCOM: return "textureBoxFilterQCOM";
+        case EOpImageBlockMatchSADQCOM: return "textureBlockMatchSADQCOM";
+        case EOpImageBlockMatchSSDQCOM: return "textureBlockMatchSSDQCOM";
         default:
             utils::slog.e << "Cannot convert operator " << glslangOperatorToString(op) << " to RValue operator.";
             // TODO: abort here