tor-browser

ShaderLang.h (40904B)

---

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
#ifndef GLSLANG_SHADERLANG_H_
#define GLSLANG_SHADERLANG_H_

#include <stddef.h>

#include "KHR/khrplatform.h"

#include <array>
#include <map>
#include <set>
#include <string>
#include <vector>

//
// This is the platform independent interface between an OGL driver
// and the shading language compiler.
//

// Note: make sure to increment ANGLE_SH_VERSION when changing ShaderVars.h
#include "ShaderVars.h"

// Version number for shader translation API.
// It is incremented every time the API changes.
#define ANGLE_SH_VERSION 308

enum ShShaderSpec
{
   SH_GLES2_SPEC,
   SH_WEBGL_SPEC,

   SH_GLES3_SPEC,
   SH_WEBGL2_SPEC,

   SH_GLES3_1_SPEC,
   SH_WEBGL3_SPEC,

   SH_GLES3_2_SPEC,

   SH_GL_CORE_SPEC,
   SH_GL_COMPATIBILITY_SPEC,
};

enum ShShaderOutput
{
   // ESSL output only supported in some configurations.
   SH_ESSL_OUTPUT = 0x8B45,

   // GLSL output only supported in some configurations.
   SH_GLSL_COMPATIBILITY_OUTPUT = 0x8B46,
   // Note: GL introduced core profiles in 1.5.
   SH_GLSL_130_OUTPUT      = 0x8B47,
   SH_GLSL_140_OUTPUT      = 0x8B80,
   SH_GLSL_150_CORE_OUTPUT = 0x8B81,
   SH_GLSL_330_CORE_OUTPUT = 0x8B82,
   SH_GLSL_400_CORE_OUTPUT = 0x8B83,
   SH_GLSL_410_CORE_OUTPUT = 0x8B84,
   SH_GLSL_420_CORE_OUTPUT = 0x8B85,
   SH_GLSL_430_CORE_OUTPUT = 0x8B86,
   SH_GLSL_440_CORE_OUTPUT = 0x8B87,
   SH_GLSL_450_CORE_OUTPUT = 0x8B88,

   // Prefer using these to specify HLSL output type:
   SH_HLSL_3_0_OUTPUT       = 0x8B48,  // D3D 9
   SH_HLSL_4_1_OUTPUT       = 0x8B49,  // D3D 11
   SH_HLSL_4_0_FL9_3_OUTPUT = 0x8B4A,  // D3D 11 feature level 9_3

   // Output SPIR-V for the Vulkan backend.
   SH_SPIRV_VULKAN_OUTPUT = 0x8B4B,

   // Output SPIR-V to be cross compiled to Metal.
   SH_SPIRV_METAL_OUTPUT = 0x8B4C,

   // Output for MSL
   SH_MSL_METAL_OUTPUT = 0x8B4D,
};

// For ANGLE_shader_pixel_local_storage.
// Instructs the compiler which pixel local storage configuration to generate code for.
enum class ShPixelLocalStorageType
{
   NotSupported,
   ImageStoreR32PackedFormats,
   ImageStoreNativeFormats,
   FramebufferFetch
};

// For ANGLE_shader_pixel_local_storage_coherent.
// Instructs the compiler which fragment synchronization method to use, if any.
enum class ShFragmentSynchronizationType
{
   NotSupported,  // Fragments cannot be ordered or synchronized.

   Automatic,  // Fragments are automatically raster-ordered and synchronized.

   FragmentShaderInterlock_NV_GL,
   FragmentShaderOrdering_INTEL_GL,
   FragmentShaderInterlock_ARB_GL,  // Also compiles to SPV_EXT_fragment_shader_interlock.

   RasterizerOrderViews_D3D,

   RasterOrderGroups_Metal,

   InvalidEnum,
   EnumCount = InvalidEnum,
};

// Compile options.
struct ShCompileOptionsMetal
{
   // Direct-to-metal backend constants:

   // Binding index for driver uniforms:
   int driverUniformsBindingIndex;
   // Binding index for default uniforms:
   int defaultUniformsBindingIndex;
   // Binding index for UBO's argument buffer
   int UBOArgumentBufferBindingIndex;
};

struct ShCompileOptionsPLS
{
   ShPixelLocalStorageType type = ShPixelLocalStorageType::NotSupported;
   // For ANGLE_shader_pixel_local_storage_coherent.
   ShFragmentSynchronizationType fragmentSynchronizationType =
       ShFragmentSynchronizationType::NotSupported;
};

struct ShCompileOptions
{
   ShCompileOptions();
   ShCompileOptions(const ShCompileOptions &other);
   ShCompileOptions &operator=(const ShCompileOptions &other);

   // Translates intermediate tree to glsl, hlsl, msl, or SPIR-V binary.  Can be queried by
   // calling sh::GetObjectCode().
   uint64_t objectCode : 1;

   // Extracts attributes, uniforms, and varyings.  Can be queried by calling ShGetVariableInfo().
   uint64_t variables : 1;

   // Tracks the source path for shaders.  Can be queried with getSourcePath().
   uint64_t sourcePath : 1;

   // Whether the internal representation of the AST should be output.
   uint64_t intermediateTree : 1;

   // If requested, validates the AST after every transformation.  Useful for debugging.
   uint64_t validateAST : 1;

   // Validates loop and indexing in the shader to ensure that they do not exceed the minimum
   // functionality mandated in GLSL 1.0 spec, Appendix A, Section 4 and 5.  There is no need to
   // specify this parameter when compiling for WebGL - it is implied.
   uint64_t validateLoopIndexing : 1;

   // Emits #line directives in HLSL.
   uint64_t lineDirectives : 1;

   // Due to spec difference between GLSL 4.1 or lower and ESSL3, some platforms (for example, Mac
   // OSX core profile) require a variable's "invariant"/"centroid" qualifiers to match between
   // vertex and fragment shader. A simple solution to allow such shaders to link is to omit the
   // two qualifiers.  AMD driver in Linux requires invariant qualifier to match between vertex and
   // fragment shaders, while ESSL3 disallows invariant qualifier in fragment shader and GLSL >=
   // 4.2 doesn't require invariant qualifier to match between shaders. Remove invariant qualifier
   // from vertex shader to workaround AMD driver bug.
   // Note that the two flags take effect on ESSL3 input shaders translated to GLSL 4.1 or lower
   // and to GLSL 4.2 or newer on Linux AMD.
   // TODO(zmo): This is not a good long-term solution. Simply dropping these qualifiers may break
   // some developers' content. A more complex workaround of dynamically generating, compiling, and
   // re-linking shaders that use these qualifiers should be implemented.
   uint64_t removeInvariantAndCentroidForESSL3 : 1;

   // This flag works around bug in Intel Mac drivers related to abs(i) where i is an integer.
   uint64_t emulateAbsIntFunction : 1;

   // Enforce the GLSL 1.017 Appendix A section 7 packing restrictions.  This flag only enforces
   // (and can only enforce) the packing restrictions for uniform variables in both vertex and
   // fragment shaders. ShCheckVariablesWithinPackingLimits() lets embedders enforce the packing
   // restrictions for varying variables during program link time.
   uint64_t enforcePackingRestrictions : 1;

   // This flag ensures all indirect (expression-based) array indexing is clamped to the bounds of
   // the array. This ensures, for example, that you cannot read off the end of a uniform, whether
   // an array vec234, or mat234 type.
   uint64_t clampIndirectArrayBounds : 1;

   // This flag limits the complexity of an expression.
   uint64_t limitExpressionComplexity : 1;

   // This flag limits the depth of the call stack.
   uint64_t limitCallStackDepth : 1;

   // This flag initializes gl_Position to vec4(0,0,0,0) at the beginning of the vertex shader's
   // main(), and has no effect in the fragment shader. It is intended as a workaround for drivers
   // which incorrectly fail to link programs if gl_Position is not written.
   uint64_t initGLPosition : 1;

   // This flag initializes gl_PointSize to 0.0f at the beginning of the vertex shader's
   // main(), and has no effect in the fragment shader. It is intended to assist in working around
   // bugs on some drivers when this is left written and then POINTS are drawn.
   uint64_t initGLPointSize : 1;

   // This flag replaces
   //   "a && b" with "a ? b : false",
   //   "a || b" with "a ? true : b".
   // This is to work around a MacOSX driver bug that |b| is executed independent of |a|'s value.
   uint64_t unfoldShortCircuit : 1;

   // This flag initializes output variables to 0 at the beginning of main().  It is to avoid
   // undefined behaviors.
   uint64_t initOutputVariables : 1;

   // This flag scalarizes vec/ivec/bvec/mat constructor args.  It is intended as a workaround for
   // Linux/Mac driver bugs.
   uint64_t scalarizeVecAndMatConstructorArgs : 1;

   // This flag overwrites a struct name with a unique prefix.  It is intended as a workaround for
   // drivers that do not handle struct scopes correctly, including all Mac drivers and Linux AMD.
   uint64_t regenerateStructNames : 1;

   // This flag works around bugs in Mac drivers related to do-while by transforming them into an
   // other construct.
   uint64_t rewriteDoWhileLoops : 1;

   // This flag works around a bug in the HLSL compiler optimizer that folds certain constant pow
   // expressions incorrectly. Only applies to the HLSL back-end. It works by expanding the integer
   // pow expressions into a series of multiplies.
   uint64_t expandSelectHLSLIntegerPowExpressions : 1;

   // Flatten "#pragma STDGL invariant(all)" into the declarations of varying variables and
   // built-in GLSL variables. This compiler option is enabled automatically when needed.
   uint64_t flattenPragmaSTDGLInvariantAll : 1;

   // Some drivers do not take into account the base level of the texture in the results of the
   // HLSL GetDimensions builtin.  This flag instructs the compiler to manually add the base level
   // offsetting.
   uint64_t HLSLGetDimensionsIgnoresBaseLevel : 1;

   // This flag works around an issue in translating GLSL function texelFetchOffset on INTEL
   // drivers. It works by translating texelFetchOffset into texelFetch.
   uint64_t rewriteTexelFetchOffsetToTexelFetch : 1;

   // This flag works around condition bug of for and while loops in Intel Mac OSX drivers.
   // Condition calculation is not correct. Rewrite it from "CONDITION" to "CONDITION && true".
   uint64_t addAndTrueToLoopCondition : 1;

   // This flag works around a bug in evaluating unary minus operator on integer on some INTEL
   // drivers. It works by translating -(int) into ~(int) + 1.
   uint64_t rewriteIntegerUnaryMinusOperator : 1;

   // This flag works around a bug in evaluating isnan() on some INTEL D3D and Mac OSX drivers.  It
   // works by using an expression to emulate this function.
   uint64_t emulateIsnanFloatFunction : 1;

   // This flag will use all uniforms of unused std140 and shared uniform blocks at the beginning
   // of the vertex/fragment shader's main(). It is intended as a workaround for Mac drivers with
   // shader version 4.10. In those drivers, they will treat unused std140 and shared uniform
   // blocks' members as inactive. However, WebGL2.0 based on OpenGL ES3.0.4 requires all members
   // of a named uniform block declared with a shared or std140 layout qualifier to be considered
   // active. The uniform block itself is also considered active.
   uint64_t useUnusedStandardSharedBlocks : 1;

   // This flag works around a bug in unary minus operator on float numbers on Intel Mac OSX 10.11
   // drivers. It works by translating -float into 0.0 - float.
   uint64_t rewriteFloatUnaryMinusOperator : 1;

   // This flag works around a bug in evaluating atan(y, x) on some NVIDIA OpenGL drivers.  It
   // works by using an expression to emulate this function.
   uint64_t emulateAtan2FloatFunction : 1;

   // Set to initialize uninitialized local and global temporary variables. Should only be used
   // with GLSL output. In HLSL output variables are initialized regardless of if this flag is set.
   uint64_t initializeUninitializedLocals : 1;

   // The flag modifies the shader in the following way:
   //
   // Every occurrence of gl_InstanceID is replaced by the global temporary variable InstanceID.
   // Every occurrence of gl_ViewID_OVR is replaced by the varying variable ViewID_OVR.
   // At the beginning of the body of main() in a vertex shader the following initializers are
   // added:
   //   ViewID_OVR = uint(gl_InstanceID) % num_views;
   //   InstanceID = gl_InstanceID / num_views;
   // ViewID_OVR is added as a varying variable to both the vertex and fragment shaders.
   uint64_t initializeBuiltinsForInstancedMultiview : 1;

   // With the flag enabled the GLSL/ESSL vertex shader is modified to include code for viewport
   // selection in the following way:
   // - Code to enable the extension ARB_shader_viewport_layer_array/NV_viewport_array2 is
   // included.
   // - Code to select the viewport index or layer is inserted at the beginning of main after
   //   ViewID_OVR's initialization.
   // - A declaration of the uniform multiviewBaseViewLayerIndex.
   // Note: The initializeBuiltinsForInstancedMultiview flag also has to be enabled to have the
   // temporary variable ViewID_OVR declared and initialized.
   uint64_t selectViewInNvGLSLVertexShader : 1;

   // If the flag is enabled, gl_PointSize is clamped to the maximum point size specified in
   // ShBuiltInResources in vertex shaders.
   uint64_t clampPointSize : 1;

   // This flag indicates whether advanced blend equation should be emulated.  Currently only
   // implemented for the Vulkan backend.
   uint64_t addAdvancedBlendEquationsEmulation : 1;

   // Don't use loops to initialize uninitialized variables. Only has an effect if some kind of
   // variable initialization is turned on.
   uint64_t dontUseLoopsToInitializeVariables : 1;

   // Don't use D3D constant register zero when allocating space for uniforms. This is targeted to
   // work around a bug in NVIDIA D3D driver version 388.59 where in very specific cases the driver
   // would not handle constant register zero correctly. Only has an effect on HLSL translation.
   uint64_t skipD3DConstantRegisterZero : 1;

   // Clamp gl_FragDepth to the range [0.0, 1.0] in case it is statically used.
   uint64_t clampFragDepth : 1;

   // Rewrite expressions like "v.x = z = expression;". Works around a bug in NVIDIA OpenGL drivers
   // prior to version 397.31.
   uint64_t rewriteRepeatedAssignToSwizzled : 1;

   // Rewrite gl_DrawID as a uniform int
   uint64_t emulateGLDrawID : 1;

   // This flag initializes shared variables to 0.  It is to avoid ompute shaders being able to
   // read undefined values that could be coming from another webpage/application.
   uint64_t initSharedVariables : 1;

   // Forces the value returned from an atomic operations to be always be resolved. This is
   // targeted to workaround a bug in NVIDIA D3D driver where the return value from
   // RWByteAddressBuffer.InterlockedAdd does not get resolved when used in the .yzw components of
   // a RWByteAddressBuffer.Store operation. Only has an effect on HLSL translation.
   // http://anglebug.com/3246
   uint64_t forceAtomicValueResolution : 1;

   // Rewrite gl_BaseVertex and gl_BaseInstance as uniform int
   uint64_t emulateGLBaseVertexBaseInstance : 1;

   // Emulate seamful cube map sampling for OpenGL ES2.0.  Currently only applies to the Vulkan
   // backend, as is done after samplers are moved out of structs.  Can likely be made to work on
   // the other backends as well.
   uint64_t emulateSeamfulCubeMapSampling : 1;

   // This flag controls how to translate WEBGL_video_texture sampling function.
   uint64_t takeVideoTextureAsExternalOES : 1;

   // This flag works around a inconsistent behavior in Mac AMD driver where gl_VertexID doesn't
   // include base vertex value. It replaces gl_VertexID with (gl_VertexID + angle_BaseVertex) when
   // angle_BaseVertex is available.
   uint64_t addBaseVertexToVertexID : 1;

   // This works around the dynamic lvalue indexing of swizzled vectors on various platforms.
   uint64_t removeDynamicIndexingOfSwizzledVector : 1;

   // This flag works around a slow fxc compile performance issue with dynamic uniform indexing.
   uint64_t allowTranslateUniformBlockToStructuredBuffer : 1;

   // This flag allows us to add a decoration for layout(yuv) in shaders.
   uint64_t addVulkanYUVLayoutQualifier : 1;

   // This flag allows disabling ARB_texture_rectangle on a per-compile basis. This is necessary
   // for WebGL contexts becuase ARB_texture_rectangle may be necessary for the WebGL
   // implementation internally but shouldn't be exposed to WebGL user code.
   uint64_t disableARBTextureRectangle : 1;

   // This flag works around a driver bug by rewriting uses of row-major matrices as column-major
   // in ESSL 3.00 and greater shaders.
   uint64_t rewriteRowMajorMatrices : 1;

   // Drop any explicit precision qualifiers from shader.
   uint64_t ignorePrecisionQualifiers : 1;

   // Ask compiler to generate code for depth correction to conform to the Vulkan clip space.  If
   // VK_EXT_depth_clip_control is supported, this code is not generated, saving a uniform look up.
   uint64_t addVulkanDepthCorrection : 1;

   uint64_t forceShaderPrecisionHighpToMediump : 1;

   // Allow compiler to use specialization constant to do pre-rotation and y flip.
   uint64_t useSpecializationConstant : 1;

   // Ask compiler to generate Vulkan transform feedback emulation support code.
   uint64_t addVulkanXfbEmulationSupportCode : 1;

   // Ask compiler to generate Vulkan transform feedback support code when using the
   // VK_EXT_transform_feedback extension.
   uint64_t addVulkanXfbExtensionSupportCode : 1;

   // This flag initializes fragment shader's output variables to zero at the beginning of the
   // fragment shader's main(). It is intended as a workaround for drivers which get context lost
   // if gl_FragColor is not written.
   uint64_t initFragmentOutputVariables : 1;

   // Transitory flag to select between producing SPIR-V directly vs using glslang.  Ignored in
   // non-assert-enabled builds to avoid increasing ANGLE's binary size.
   uint64_t generateSpirvThroughGlslang : 1;

   // Insert explicit casts for float/double/unsigned/signed int on macOS 10.15 with Intel driver
   uint64_t addExplicitBoolCasts : 1;

   // Add round() after applying dither.  This works around a Qualcomm quirk where values can get
   // ceil()ed instead.
   uint64_t roundOutputAfterDithering : 1;

   // Even when the dividend and divisor have the same value some platforms do not return 1.0f.
   // Need to emit different division code for such platforms.
   uint64_t precisionSafeDivision : 1;

   // anglebug.com/7527: packUnorm4x8 fails on Pixel 4 if it is not passed a highp vec4.
   // TODO(anglebug.com/7527): This workaround is currently only applied for pixel local storage.
   // We may want to apply it generally.
   uint64_t passHighpToPackUnormSnormBuiltins : 1;

   ShCompileOptionsMetal metal;
   ShCompileOptionsPLS pls;
};

// The 64 bits hash function. The first parameter is the input string; the
// second parameter is the string length.
using ShHashFunction64 = khronos_uint64_t (*)(const char *, size_t);

//
// Implementation dependent built-in resources (constants and extensions).
// The names for these resources has been obtained by stripping gl_/GL_.
//
struct ShBuiltInResources
{
   ShBuiltInResources();
   ShBuiltInResources(const ShBuiltInResources &other);
   ShBuiltInResources &operator=(const ShBuiltInResources &other);

   // Constants.
   int MaxVertexAttribs;
   int MaxVertexUniformVectors;
   int MaxVaryingVectors;
   int MaxVertexTextureImageUnits;
   int MaxCombinedTextureImageUnits;
   int MaxTextureImageUnits;
   int MaxFragmentUniformVectors;
   int MaxDrawBuffers;

   // Extensions.
   // Set to 1 to enable the extension, else 0.
   int OES_standard_derivatives;
   int OES_EGL_image_external;
   int OES_EGL_image_external_essl3;
   int NV_EGL_stream_consumer_external;
   int ARB_texture_rectangle;
   int EXT_blend_func_extended;
   int EXT_draw_buffers;
   int EXT_frag_depth;
   int EXT_shader_texture_lod;
   int EXT_shader_framebuffer_fetch;
   int EXT_shader_framebuffer_fetch_non_coherent;
   int NV_shader_framebuffer_fetch;
   int NV_shader_noperspective_interpolation;
   int ARM_shader_framebuffer_fetch;
   int OVR_multiview;
   int OVR_multiview2;
   int EXT_multisampled_render_to_texture;
   int EXT_multisampled_render_to_texture2;
   int EXT_YUV_target;
   int EXT_geometry_shader;
   int OES_geometry_shader;
   int OES_shader_io_blocks;
   int EXT_shader_io_blocks;
   int EXT_gpu_shader5;
   int EXT_shader_non_constant_global_initializers;
   int OES_texture_storage_multisample_2d_array;
   int OES_texture_3D;
   int ANGLE_shader_pixel_local_storage;
   int ANGLE_texture_multisample;
   int ANGLE_multi_draw;
   // TODO(angleproject:3402) remove after chromium side removal to pass compilation
   int ANGLE_base_vertex_base_instance;
   int WEBGL_video_texture;
   int APPLE_clip_distance;
   int OES_texture_cube_map_array;
   int EXT_texture_cube_map_array;
   int EXT_shadow_samplers;
   int OES_shader_multisample_interpolation;
   int OES_shader_image_atomic;
   int EXT_tessellation_shader;
   int OES_texture_buffer;
   int EXT_texture_buffer;
   int OES_sample_variables;
   int EXT_clip_cull_distance;
   int EXT_primitive_bounding_box;
   int OES_primitive_bounding_box;
   int ANGLE_base_vertex_base_instance_shader_builtin;
   int ANDROID_extension_pack_es31a;
   int KHR_blend_equation_advanced;

   // Set to 1 to enable replacing GL_EXT_draw_buffers #extension directives
   // with GL_NV_draw_buffers in ESSL output. This flag can be used to emulate
   // EXT_draw_buffers by using it in combination with GLES3.0 glDrawBuffers
   // function. This applies to Tegra K1 devices.
   int NV_draw_buffers;

   // Set to 1 if highp precision is supported in the ESSL 1.00 version of the
   // fragment language. Does not affect versions of the language where highp
   // support is mandatory.
   // Default is 0.
   int FragmentPrecisionHigh;

   // GLSL ES 3.0 constants.
   int MaxVertexOutputVectors;
   int MaxFragmentInputVectors;
   int MinProgramTexelOffset;
   int MaxProgramTexelOffset;

   // Extension constants.

   // Value of GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT for OpenGL ES output context.
   // Value of GL_MAX_DUAL_SOURCE_DRAW_BUFFERS for OpenGL output context.
   // GLES SL version 100 gl_MaxDualSourceDrawBuffersEXT value for EXT_blend_func_extended.
   int MaxDualSourceDrawBuffers;

   // Value of GL_MAX_VIEWS_OVR.
   int MaxViewsOVR;

   // Name Hashing.
   // Set a 64 bit hash function to enable user-defined name hashing.
   // Default is NULL.
   ShHashFunction64 HashFunction;

   // The maximum complexity an expression can be when limitExpressionComplexity is turned on.
   int MaxExpressionComplexity;

   // The maximum depth a call stack can be.
   int MaxCallStackDepth;

   // The maximum number of parameters a function can have when limitExpressionComplexity is turned
   // on.
   int MaxFunctionParameters;

   // GLES 3.1 constants

   // texture gather offset constraints.
   int MinProgramTextureGatherOffset;
   int MaxProgramTextureGatherOffset;

   // maximum number of available image units
   int MaxImageUnits;

   // OES_sample_variables constant
   // maximum number of available samples
   int MaxSamples;

   // maximum number of image uniforms in a vertex shader
   int MaxVertexImageUniforms;

   // maximum number of image uniforms in a fragment shader
   int MaxFragmentImageUniforms;

   // maximum number of image uniforms in a compute shader
   int MaxComputeImageUniforms;

   // maximum total number of image uniforms in a program
   int MaxCombinedImageUniforms;

   // maximum number of uniform locations
   int MaxUniformLocations;

   // maximum number of ssbos and images in a shader
   int MaxCombinedShaderOutputResources;

   // maximum number of groups in each dimension
   std::array<int, 3> MaxComputeWorkGroupCount;
   // maximum number of threads per work group in each dimension
   std::array<int, 3> MaxComputeWorkGroupSize;

   // maximum number of total uniform components
   int MaxComputeUniformComponents;

   // maximum number of texture image units in a compute shader
   int MaxComputeTextureImageUnits;

   // maximum number of atomic counters in a compute shader
   int MaxComputeAtomicCounters;

   // maximum number of atomic counter buffers in a compute shader
   int MaxComputeAtomicCounterBuffers;

   // maximum number of atomic counters in a vertex shader
   int MaxVertexAtomicCounters;

   // maximum number of atomic counters in a fragment shader
   int MaxFragmentAtomicCounters;

   // maximum number of atomic counters in a program
   int MaxCombinedAtomicCounters;

   // maximum binding for an atomic counter
   int MaxAtomicCounterBindings;

   // maximum number of atomic counter buffers in a vertex shader
   int MaxVertexAtomicCounterBuffers;

   // maximum number of atomic counter buffers in a fragment shader
   int MaxFragmentAtomicCounterBuffers;

   // maximum number of atomic counter buffers in a program
   int MaxCombinedAtomicCounterBuffers;

   // maximum number of buffer object storage in machine units
   int MaxAtomicCounterBufferSize;

   // maximum number of uniform block bindings
   int MaxUniformBufferBindings;

   // maximum number of shader storage buffer bindings
   int MaxShaderStorageBufferBindings;

   // maximum point size (higher limit from ALIASED_POINT_SIZE_RANGE)
   float MaxPointSize;

   // EXT_geometry_shader constants
   int MaxGeometryUniformComponents;
   int MaxGeometryUniformBlocks;
   int MaxGeometryInputComponents;
   int MaxGeometryOutputComponents;
   int MaxGeometryOutputVertices;
   int MaxGeometryTotalOutputComponents;
   int MaxGeometryTextureImageUnits;
   int MaxGeometryAtomicCounterBuffers;
   int MaxGeometryAtomicCounters;
   int MaxGeometryShaderStorageBlocks;
   int MaxGeometryShaderInvocations;
   int MaxGeometryImageUniforms;

   // EXT_tessellation_shader constants
   int MaxTessControlInputComponents;
   int MaxTessControlOutputComponents;
   int MaxTessControlTextureImageUnits;
   int MaxTessControlUniformComponents;
   int MaxTessControlTotalOutputComponents;
   int MaxTessControlImageUniforms;
   int MaxTessControlAtomicCounters;
   int MaxTessControlAtomicCounterBuffers;

   int MaxTessPatchComponents;
   int MaxPatchVertices;
   int MaxTessGenLevel;

   int MaxTessEvaluationInputComponents;
   int MaxTessEvaluationOutputComponents;
   int MaxTessEvaluationTextureImageUnits;
   int MaxTessEvaluationUniformComponents;
   int MaxTessEvaluationImageUniforms;
   int MaxTessEvaluationAtomicCounters;
   int MaxTessEvaluationAtomicCounterBuffers;

   // Subpixel bits used in rasterization.
   int SubPixelBits;

   // APPLE_clip_distance/EXT_clip_cull_distance constant
   int MaxClipDistances;
   int MaxCullDistances;
   int MaxCombinedClipAndCullDistances;

   // ANGLE_shader_pixel_local_storage.
   int MaxPixelLocalStoragePlanes;
   int MaxColorAttachmentsWithActivePixelLocalStorage;
   int MaxCombinedDrawBuffersAndPixelLocalStoragePlanes;

   // Variable size limits for webgl-mode validation.
   size_t MaxVariableSizeInBytes;
   size_t MaxPrivateVariableSizeInBytes;
};

//
// ShHandle held by but opaque to the driver.  It is allocated,
// managed, and de-allocated by the compiler. Its contents
// are defined by and used by the compiler.
//
// If handle creation fails, 0 will be returned.
//
using ShHandle = void *;

namespace sh
{
using BinaryBlob = std::vector<uint32_t>;

//
// Driver must call this first, once, before doing any other compiler operations.
// If the function succeeds, the return value is true, else false.
//
bool Initialize();
//
// Driver should call this at shutdown.
// If the function succeeds, the return value is true, else false.
//
bool Finalize();

//
// Initialize built-in resources with minimum expected values.
// Parameters:
// resources: The object to initialize. Will be comparable with memcmp.
//
void InitBuiltInResources(ShBuiltInResources *resources);

//
// Returns a copy of the current ShBuiltInResources stored in the compiler.
// Parameters:
// handle: Specifies the handle of the compiler to be used.
ShBuiltInResources GetBuiltInResources(const ShHandle handle);

//
// Returns the a concatenated list of the items in ShBuiltInResources as a null-terminated string.
// This function must be updated whenever ShBuiltInResources is changed.
// Parameters:
// handle: Specifies the handle of the compiler to be used.
const std::string &GetBuiltInResourcesString(const ShHandle handle);

//
// Driver calls these to create and destroy compiler objects.
//
// Returns the handle of constructed compiler, null if the requested compiler is not supported.
// Parameters:
// type: Specifies the type of shader - GL_FRAGMENT_SHADER or GL_VERTEX_SHADER.
// spec: Specifies the language spec the compiler must conform to - SH_GLES2_SPEC or SH_WEBGL_SPEC.
// output: Specifies the output code type - for example SH_ESSL_OUTPUT, SH_GLSL_OUTPUT,
//         SH_HLSL_3_0_OUTPUT or SH_HLSL_4_1_OUTPUT. Note: Each output type may only
//         be supported in some configurations.
// resources: Specifies the built-in resources.
ShHandle ConstructCompiler(sh::GLenum type,
                          ShShaderSpec spec,
                          ShShaderOutput output,
                          const ShBuiltInResources *resources);
void Destruct(ShHandle handle);

//
// Compiles the given shader source.
// If the function succeeds, the return value is true, else false.
// Parameters:
// handle: Specifies the handle of compiler to be used.
// shaderStrings: Specifies an array of pointers to null-terminated strings containing the shader
// source code.
// numStrings: Specifies the number of elements in shaderStrings array.
// compileOptions: A mask of compile options defined above.
bool Compile(const ShHandle handle,
            const char *const shaderStrings[],
            size_t numStrings,
            const ShCompileOptions &compileOptions);

// Clears the results from the previous compilation.
void ClearResults(const ShHandle handle);

// Return the version of the shader language.
int GetShaderVersion(const ShHandle handle);

// Return the currently set language output type.
ShShaderOutput GetShaderOutputType(const ShHandle handle);

// Returns null-terminated information log for a compiled shader.
// Parameters:
// handle: Specifies the compiler
const std::string &GetInfoLog(const ShHandle handle);

// Returns null-terminated object code for a compiled shader.  Only valid for output types that
// generate human-readable code (GLSL, ESSL or HLSL).
// Parameters:
// handle: Specifies the compiler
const std::string &GetObjectCode(const ShHandle handle);

// Returns object binary blob for a compiled shader.  Only valid for output types that
// generate binary blob (SPIR-V).
// Parameters:
// handle: Specifies the compiler
const BinaryBlob &GetObjectBinaryBlob(const ShHandle handle);

// Returns a (original_name, hash) map containing all the user defined names in the shader,
// including variable names, function names, struct names, and struct field names.
// Parameters:
// handle: Specifies the compiler
const std::map<std::string, std::string> *GetNameHashingMap(const ShHandle handle);

// Shader variable inspection.
// Returns a pointer to a list of variables of the designated type.
// (See ShaderVars.h for type definitions, included above)
// Returns NULL on failure.
// Parameters:
// handle: Specifies the compiler
const std::vector<sh::ShaderVariable> *GetUniforms(const ShHandle handle);
const std::vector<sh::ShaderVariable> *GetVaryings(const ShHandle handle);
const std::vector<sh::ShaderVariable> *GetInputVaryings(const ShHandle handle);
const std::vector<sh::ShaderVariable> *GetOutputVaryings(const ShHandle handle);
const std::vector<sh::ShaderVariable> *GetAttributes(const ShHandle handle);
const std::vector<sh::ShaderVariable> *GetOutputVariables(const ShHandle handle);
const std::vector<sh::InterfaceBlock> *GetInterfaceBlocks(const ShHandle handle);
const std::vector<sh::InterfaceBlock> *GetUniformBlocks(const ShHandle handle);
const std::vector<sh::InterfaceBlock> *GetShaderStorageBlocks(const ShHandle handle);
sh::WorkGroupSize GetComputeShaderLocalGroupSize(const ShHandle handle);
// Returns the number of views specified through the num_views layout qualifier. If num_views is
// not set, the function returns -1.
int GetVertexShaderNumViews(const ShHandle handle);
// Returns true if the shader has specified the |sample| qualifier, implying that per-sample shading
// should be enabled
bool EnablesPerSampleShading(const ShHandle handle);

// Returns specialization constant usage bits
uint32_t GetShaderSpecConstUsageBits(const ShHandle handle);

// Returns true if the passed in variables pack in maxVectors followingthe packing rules from the
// GLSL 1.017 spec, Appendix A, section 7.
// Returns false otherwise. Also look at the enforcePackingRestrictions flag above.
// Parameters:
// maxVectors: the available rows of registers.
// variables: an array of variables.
bool CheckVariablesWithinPackingLimits(int maxVectors,
                                      const std::vector<sh::ShaderVariable> &variables);

// Gives the compiler-assigned register for a shader storage block.
// The method writes the value to the output variable "indexOut".
// Returns true if it found a valid shader storage block, false otherwise.
// Parameters:
// handle: Specifies the compiler
// shaderStorageBlockName: Specifies the shader storage block
// indexOut: output variable that stores the assigned register
bool GetShaderStorageBlockRegister(const ShHandle handle,
                                  const std::string &shaderStorageBlockName,
                                  unsigned int *indexOut);

// Gives the compiler-assigned register for a uniform block.
// The method writes the value to the output variable "indexOut".
// Returns true if it found a valid uniform block, false otherwise.
// Parameters:
// handle: Specifies the compiler
// uniformBlockName: Specifies the uniform block
// indexOut: output variable that stores the assigned register
bool GetUniformBlockRegister(const ShHandle handle,
                            const std::string &uniformBlockName,
                            unsigned int *indexOut);

bool ShouldUniformBlockUseStructuredBuffer(const ShHandle handle,
                                          const std::string &uniformBlockName);
const std::set<std::string> *GetSlowCompilingUniformBlockSet(const ShHandle handle);

// Gives a map from uniform names to compiler-assigned registers in the default uniform block.
// Note that the map contains also registers of samplers that have been extracted from structs.
const std::map<std::string, unsigned int> *GetUniformRegisterMap(const ShHandle handle);

// Sampler, image and atomic counters share registers(t type and u type),
// GetReadonlyImage2DRegisterIndex and GetImage2DRegisterIndex return the first index into
// a range of reserved registers for image2D/iimage2D/uimage2D variables.
// Parameters: handle: Specifies the compiler
unsigned int GetReadonlyImage2DRegisterIndex(const ShHandle handle);
unsigned int GetImage2DRegisterIndex(const ShHandle handle);

// The method records these used function names related with image2D/iimage2D/uimage2D, these
// functions will be dynamically generated.
// Parameters:
// handle: Specifies the compiler
const std::set<std::string> *GetUsedImage2DFunctionNames(const ShHandle handle);

bool HasDiscardInFragmentShader(const ShHandle handle);
bool HasValidGeometryShaderInputPrimitiveType(const ShHandle handle);
bool HasValidGeometryShaderOutputPrimitiveType(const ShHandle handle);
bool HasValidGeometryShaderMaxVertices(const ShHandle handle);
bool HasValidTessGenMode(const ShHandle handle);
bool HasValidTessGenSpacing(const ShHandle handle);
bool HasValidTessGenVertexOrder(const ShHandle handle);
bool HasValidTessGenPointMode(const ShHandle handle);
GLenum GetGeometryShaderInputPrimitiveType(const ShHandle handle);
GLenum GetGeometryShaderOutputPrimitiveType(const ShHandle handle);
int GetGeometryShaderInvocations(const ShHandle handle);
int GetGeometryShaderMaxVertices(const ShHandle handle);
unsigned int GetShaderSharedMemorySize(const ShHandle handle);
int GetTessControlShaderVertices(const ShHandle handle);
GLenum GetTessGenMode(const ShHandle handle);
GLenum GetTessGenSpacing(const ShHandle handle);
GLenum GetTessGenVertexOrder(const ShHandle handle);
GLenum GetTessGenPointMode(const ShHandle handle);

// Returns the blend equation list supported in the fragment shader.  This is a bitset of
// gl::BlendEquationType, and can only include bits from KHR_blend_equation_advanced.
uint32_t GetAdvancedBlendEquations(const ShHandle handle);

//
// Helper function to identify specs that are based on the WebGL spec.
//
inline bool IsWebGLBasedSpec(ShShaderSpec spec)
{
   return (spec == SH_WEBGL_SPEC || spec == SH_WEBGL2_SPEC || spec == SH_WEBGL3_SPEC);
}

//
// Helper function to identify DesktopGL specs
//
inline bool IsDesktopGLSpec(ShShaderSpec spec)
{
   return spec == SH_GL_CORE_SPEC || spec == SH_GL_COMPATIBILITY_SPEC;
}

// Can't prefix with just _ because then we might introduce a double underscore, which is not safe
// in GLSL (ESSL 3.00.6 section 3.8: All identifiers containing a double underscore are reserved for
// use by the underlying implementation). u is short for user-defined.
extern const char kUserDefinedNamePrefix[];

namespace vk
{

// Specialization constant ids
enum class SpecializationConstantId : uint32_t
{
   SurfaceRotation = 0,
   Dither          = 1,

   InvalidEnum = 2,
   EnumCount   = InvalidEnum,
};

enum class SpecConstUsage : uint32_t
{
   Rotation = 0,
   Dither   = 1,

   InvalidEnum = 2,
   EnumCount   = InvalidEnum,
};

enum ColorAttachmentDitherControl
{
   // See comments in ContextVk::updateDither and EmulateDithering.cpp
   kDitherControlNoDither   = 0,
   kDitherControlDither4444 = 1,
   kDitherControlDither5551 = 2,
   kDitherControlDither565  = 3,
};

// Interface block name containing the aggregate default uniforms
extern const char kDefaultUniformsNameVS[];
extern const char kDefaultUniformsNameTCS[];
extern const char kDefaultUniformsNameTES[];
extern const char kDefaultUniformsNameGS[];
extern const char kDefaultUniformsNameFS[];
extern const char kDefaultUniformsNameCS[];

// Interface block and variable names containing driver uniforms
extern const char kDriverUniformsBlockName[];
extern const char kDriverUniformsVarName[];

// Packing information for driver uniform's misc field:
// - 1 bit for whether surface rotation results in swapped axes
// - 5 bits for advanced blend equation
// - 6 bits for sample count
// - 8 bits for enabled clip planes
// - 1 bit for whether depth should be transformed to Vulkan clip space
// - 11 bits unused
constexpr uint32_t kDriverUniformsMiscSwapXYMask                  = 0x1;
constexpr uint32_t kDriverUniformsMiscAdvancedBlendEquationOffset = 1;
constexpr uint32_t kDriverUniformsMiscAdvancedBlendEquationMask   = 0x1F;
constexpr uint32_t kDriverUniformsMiscSampleCountOffset           = 6;
constexpr uint32_t kDriverUniformsMiscSampleCountMask             = 0x3F;
constexpr uint32_t kDriverUniformsMiscEnabledClipPlanesOffset     = 12;
constexpr uint32_t kDriverUniformsMiscEnabledClipPlanesMask       = 0xFF;
constexpr uint32_t kDriverUniformsMiscTransformDepthOffset        = 20;
constexpr uint32_t kDriverUniformsMiscTransformDepthMask          = 0x1;

// Interface block array name used for atomic counter emulation
extern const char kAtomicCountersBlockName[];

// Transform feedback emulation support
extern const char kXfbEmulationGetOffsetsFunctionName[];
extern const char kXfbEmulationCaptureFunctionName[];
extern const char kXfbEmulationBufferBlockName[];
extern const char kXfbEmulationBufferName[];
extern const char kXfbEmulationBufferFieldName[];

// Transform feedback extension support
extern const char kXfbExtensionPositionOutName[];

// Pre-rotation support
extern const char kTransformPositionFunctionName[];

// EXT_shader_framebuffer_fetch and EXT_shader_framebuffer_fetch_non_coherent
extern const char kInputAttachmentName[];

}  // namespace vk

namespace mtl
{
// Specialization constant to enable GL_SAMPLE_COVERAGE_VALUE emulation.
extern const char kCoverageMaskEnabledConstName[];

// Specialization constant to emulate rasterizer discard.
extern const char kRasterizerDiscardEnabledConstName[];

// Specialization constant to enable depth write in fragment shaders.
extern const char kDepthWriteEnabledConstName[];
}  // namespace mtl

// For backends that use glslang (the Vulkan shader compiler), i.e. Vulkan and Metal, call these to
// initialize and finalize glslang itself.  This can be called independently from Initialize() and
// Finalize().
void InitializeGlslang();
void FinalizeGlslang();

}  // namespace sh

#endif  // GLSLANG_SHADERLANG_H_