Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 1332 insertions, 0 deletions

diff --git a/gfx/angle/checkout/include/GLSLANG/ShaderLang.h b/gfx/angle/checkout/include/GLSLANG/ShaderLang.h
new file mode 100644
index 0000000000..d55e7ebce3
--- /dev/null
+++ b/gfx/angle/checkout/include/GLSLANG/ShaderLang.h
@@ -0,0 +1,1001 @@
+//
+// 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;
+};
+
+//
+// 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_
diff --git a/gfx/angle/checkout/include/GLSLANG/ShaderVars.h b/gfx/angle/checkout/include/GLSLANG/ShaderVars.h
new file mode 100644
index 0000000000..4b76d33af2
--- /dev/null
+++ b/gfx/angle/checkout/include/GLSLANG/ShaderVars.h
@@ -0,0 +1,331 @@
+//
+// Copyright 2013 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.
+//
+// ShaderVars.h:
+//  Types to represent GL variables (varyings, uniforms, etc)
+//
+
+#ifndef GLSLANG_SHADERVARS_H_
+#define GLSLANG_SHADERVARS_H_
+
+#include <algorithm>
+#include <array>
+#include <string>
+#include <vector>
+
+namespace sh
+{
+// GLenum alias
+typedef unsigned int GLenum;
+
+// Varying interpolation qualifier, see section 4.3.9 of the ESSL 3.00.4 spec
+enum InterpolationType
+{
+    INTERPOLATION_SMOOTH,
+    INTERPOLATION_CENTROID,
+    INTERPOLATION_SAMPLE,
+    INTERPOLATION_FLAT,
+    INTERPOLATION_NOPERSPECTIVE
+};
+
+const char *InterpolationTypeToString(InterpolationType type);
+
+// Validate link & SSO consistency of interpolation qualifiers
+bool InterpolationTypesMatch(InterpolationType a, InterpolationType b);
+
+// Uniform block layout qualifier, see section 4.3.8.3 of the ESSL 3.00.4 spec
+enum BlockLayoutType
+{
+    BLOCKLAYOUT_STANDARD,
+    BLOCKLAYOUT_STD140 = BLOCKLAYOUT_STANDARD,
+    BLOCKLAYOUT_STD430,  // Shader storage block layout qualifier
+    BLOCKLAYOUT_PACKED,
+    BLOCKLAYOUT_SHARED
+};
+
+const char *BlockLayoutTypeToString(BlockLayoutType type);
+
+// Interface Blocks, see section 4.3.9 of the ESSL 3.10 spec
+enum class BlockType
+{
+    BLOCK_UNIFORM,
+    BLOCK_BUFFER,
+};
+
+const char *BlockTypeToString(BlockType type);
+
+// Base class for all variables defined in shaders, including Varyings, Uniforms, etc
+// Note: we must override the copy constructor and assignment operator so we can
+// work around excessive GCC binary bloating:
+// See https://code.google.com/p/angleproject/issues/detail?id=697
+struct ShaderVariable
+{
+    ShaderVariable();
+    ShaderVariable(GLenum typeIn);
+    ShaderVariable(GLenum typeIn, unsigned int arraySizeIn);
+    ~ShaderVariable();
+    ShaderVariable(const ShaderVariable &other);
+    ShaderVariable &operator=(const ShaderVariable &other);
+    bool operator==(const ShaderVariable &other) const;
+    bool operator!=(const ShaderVariable &other) const { return !operator==(other); }
+
+    bool isArrayOfArrays() const { return arraySizes.size() >= 2u; }
+    bool isArray() const { return !arraySizes.empty(); }
+    unsigned int getArraySizeProduct() const;
+    // Return the inner array size product.
+    // For example, if there's a variable declared as size 3 array of size 4 array of size 5 array
+    // of int:
+    //   int a[3][4][5];
+    // then getInnerArraySizeProduct of a would be 4*5.
+    unsigned int getInnerArraySizeProduct() const;
+
+    // Array size 0 means not an array when passed to or returned from these functions.
+    // Note that setArraySize() is deprecated and should not be used inside ANGLE.
+    unsigned int getOutermostArraySize() const { return isArray() ? arraySizes.back() : 0; }
+    void setArraySize(unsigned int size);
+
+    // Turn this ShaderVariable from an array into a specific element in that array. Will update
+    // flattenedOffsetInParentArrays.
+    void indexIntoArray(unsigned int arrayIndex);
+
+    // Get the nth nested array size from the top. Caller is responsible for range checking
+    // arrayNestingIndex.
+    unsigned int getNestedArraySize(unsigned int arrayNestingIndex) const;
+
+    // This function should only be used with variables that are of a basic type or an array of a
+    // basic type. Shader interface variables that are enumerated according to rules in GLES 3.1
+    // spec section 7.3.1.1 page 77 are fine. For those variables the return value should match the
+    // ARRAY_SIZE value that can be queried through the API.
+    unsigned int getBasicTypeElementCount() const;
+
+    unsigned int getExternalSize() const;
+
+    bool isStruct() const { return !fields.empty(); }
+    const std::string &getStructName() const { return structOrBlockName; }
+    void setStructName(const std::string &newName) { structOrBlockName = newName; }
+
+    // All of the shader's variables are described using nested data
+    // structures. This is needed in order to disambiguate similar looking
+    // types, such as two structs containing the same fields, but in
+    // different orders. "findInfoByMappedName" provides an easy query for
+    // users to dive into the data structure and fetch the unique variable
+    // instance corresponding to a dereferencing chain of the top-level
+    // variable.
+    // Given a mapped name like 'a[0].b.c[0]', return the ShaderVariable
+    // that defines 'c' in |leafVar|, and the original name 'A[0].B.C[0]'
+    // in |originalName|, based on the assumption that |this| defines 'a'.
+    // If no match is found, return false.
+    bool findInfoByMappedName(const std::string &mappedFullName,
+                              const ShaderVariable **leafVar,
+                              std::string *originalFullName) const;
+
+    // Find the child field which matches 'fullName' == var.name + "." + field.name.
+    // Return nullptr if not found.
+    const sh::ShaderVariable *findField(const std::string &fullName, uint32_t *fieldIndexOut) const;
+
+    bool isBuiltIn() const;
+    bool isEmulatedBuiltIn() const;
+
+    // Offset of this variable in parent arrays. In case the parent is an array of arrays, the
+    // offset is outerArrayElement * innerArraySize + innerArrayElement.
+    // For example, if there's a variable declared as size 3 array of size 4 array of int:
+    //   int a[3][4];
+    // then the flattenedOffsetInParentArrays of a[2] would be 2.
+    // and flattenedOffsetInParentArrays of a[2][1] would be 2*4 + 1 = 9.
+    int parentArrayIndex() const
+    {
+        return hasParentArrayIndex() ? flattenedOffsetInParentArrays : 0;
+    }
+
+    int getFlattenedOffsetInParentArrays() const { return flattenedOffsetInParentArrays; }
+    void setParentArrayIndex(int indexIn) { flattenedOffsetInParentArrays = indexIn; }
+
+    bool hasParentArrayIndex() const { return flattenedOffsetInParentArrays != -1; }
+
+    void resetEffectiveLocation();
+    void updateEffectiveLocation(const sh::ShaderVariable &parent);
+
+    // Decide whether two uniforms are the same at shader link time,
+    // assuming they are from consecutive shader stages.
+    // GLSL ES Spec 3.00.3, section 4.3.5.
+    // GLSL ES Spec 3.10.4, section 4.4.5
+    bool isSameUniformAtLinkTime(const ShaderVariable &other) const;
+
+    // InterfaceBlockField
+    // Decide whether two InterfaceBlock fields are the same at shader
+    // link time, assuming they are from consecutive shader stages.
+    // See GLSL ES Spec 3.00.3, sec 4.3.7.
+    bool isSameInterfaceBlockFieldAtLinkTime(const ShaderVariable &other) const;
+
+    // Decide whether two varyings are the same at shader link time,
+    // assuming they are from consecutive shader stages.
+    // Invariance needs to match only in ESSL1. Relevant spec sections:
+    // GLSL ES 3.00.4, sections 4.6.1 and 4.3.9.
+    // GLSL ES 1.00.17, section 4.6.4.
+    bool isSameVaryingAtLinkTime(const ShaderVariable &other, int shaderVersion) const;
+    // Deprecated version of isSameVaryingAtLinkTime, which assumes ESSL1.
+    bool isSameVaryingAtLinkTime(const ShaderVariable &other) const;
+
+    // Shader I/O blocks may match by block name or instance, based on whether both stages have an
+    // instance name or not.
+    bool isSameNameAtLinkTime(const ShaderVariable &other) const;
+
+    // NOTE: When adding new members, the following functions also need to be updated:
+    // gl::WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var)
+    // gl::LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var)
+
+    GLenum type;
+    GLenum precision;
+    std::string name;
+    std::string mappedName;
+
+    // Used to make an array type. Outermost array size is stored at the end of the vector.
+    std::vector<unsigned int> arraySizes;
+
+    // Static use means that the variable is accessed somewhere in the shader source.
+    bool staticUse;
+    // A variable is active unless the compiler determined that it is not accessed by the shader.
+    // All active variables are statically used, but not all statically used variables are
+    // necessarily active. GLES 3.0.5 section 2.12.6. GLES 3.1 section 7.3.1.
+    bool active;
+    std::vector<ShaderVariable> fields;
+    // structOrBlockName is used for:
+    // - varyings of struct type, in which case it contains the struct name.
+    // - shader I/O blocks, in which case it contains the block name.
+    std::string structOrBlockName;
+    std::string mappedStructOrBlockName;
+
+    // Only applies to interface block fields. Kept here for simplicity.
+    bool isRowMajorLayout;
+
+    // VariableWithLocation
+    int location;
+
+    // The location of inputs or outputs without location layout quailifer will be updated to '-1'.
+    // GLES Spec 3.1, Section 7.3. PROGRAM OBJECTS
+    // Not all active variables are assigned valid locations;
+    // the following variables will have an effective location of -1:
+    bool hasImplicitLocation;
+
+    // Uniform
+    int binding;
+    GLenum imageUnitFormat;
+    int offset;
+    bool rasterOrdered;
+    bool readonly;
+    bool writeonly;
+
+    // From EXT_shader_framebuffer_fetch / KHR_blend_equation_advanced
+    bool isFragmentInOut;
+
+    // OutputVariable
+    // From EXT_blend_func_extended.
+    int index;
+
+    // From EXT_YUV_target
+    bool yuv;
+
+    // Varying
+    InterpolationType interpolation;
+    bool isInvariant;
+    bool isShaderIOBlock;
+    bool isPatch;
+
+    // If the variable is a sampler that has ever been statically used with texelFetch
+    bool texelFetchStaticUse;
+
+  protected:
+    bool isSameVariableAtLinkTime(const ShaderVariable &other,
+                                  bool matchPrecision,
+                                  bool matchName) const;
+
+    // NOTE: When adding new members, the following functions also need to be updated:
+    // gl::WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var)
+    // gl::LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var)
+
+    int flattenedOffsetInParentArrays;
+};
+
+// TODO: anglebug.com/3899
+// For backwards compatibility for other codebases (e.g., chromium/src/gpu/command_buffer/service)
+using Uniform             = ShaderVariable;
+using Attribute           = ShaderVariable;
+using OutputVariable      = ShaderVariable;
+using InterfaceBlockField = ShaderVariable;
+using Varying             = ShaderVariable;
+
+struct InterfaceBlock
+{
+    InterfaceBlock();
+    ~InterfaceBlock();
+    InterfaceBlock(const InterfaceBlock &other);
+    InterfaceBlock &operator=(const InterfaceBlock &other);
+
+    // Fields from blocks with non-empty instance names are prefixed with the block name.
+    std::string fieldPrefix() const;
+    std::string fieldMappedPrefix() const;
+
+    // Decide whether two interface blocks are the same at shader link time.
+    bool isSameInterfaceBlockAtLinkTime(const InterfaceBlock &other) const;
+
+    bool isBuiltIn() const;
+
+    bool isArray() const { return arraySize > 0; }
+    unsigned int elementCount() const { return std::max(1u, arraySize); }
+
+    std::string name;
+    std::string mappedName;
+    std::string instanceName;
+    unsigned int arraySize;
+    BlockLayoutType layout;
+
+    // Deprecated. Matrix packing should only be queried from individual fields of the block.
+    // TODO(oetuaho): Remove this once it is no longer used in Chromium.
+    bool isRowMajorLayout;
+
+    int binding;
+    bool staticUse;
+    bool active;
+    BlockType blockType;
+    std::vector<ShaderVariable> fields;
+};
+
+struct WorkGroupSize
+{
+    // Must have a trivial default constructor since it is used in YYSTYPE.
+    inline WorkGroupSize() = default;
+    inline explicit constexpr WorkGroupSize(int initialSize);
+
+    void fill(int fillValue);
+    void setLocalSize(int localSizeX, int localSizeY, int localSizeZ);
+
+    int &operator[](size_t index);
+    int operator[](size_t index) const;
+    size_t size() const;
+
+    // Checks whether two work group size declarations match.
+    // Two work group size declarations are the same if the explicitly specified elements are the
+    // same or if one of them is specified as one and the other one is not specified
+    bool isWorkGroupSizeMatching(const WorkGroupSize &right) const;
+
+    // Checks whether any of the values are set.
+    bool isAnyValueSet() const;
+
+    // Checks whether all of the values are set.
+    bool isDeclared() const;
+
+    // Checks whether either all of the values are set, or none of them are.
+    bool isLocalSizeValid() const;
+
+    int localSizeQualifiers[3];
+};
+
+inline constexpr WorkGroupSize::WorkGroupSize(int initialSize)
+    : localSizeQualifiers{initialSize, initialSize, initialSize}
+{}
+
+}  // namespace sh
+
+#endif  // GLSLANG_SHADERVARS_H_