glslang/MachineIndependent/Versions.cpp

   1 //
   2 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
   3 // Copyright (C) 2012-2013 LunarG, Inc.
   4 // Copyright (C) 2017 ARM Limited.
   5 // Copyright (C) 2015-2020 Google, Inc.
   6 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
   7 //
   8 // All rights reserved.
   9 //
  10 // Redistribution and use in source and binary forms, with or without
  11 // modification, are permitted provided that the following conditions
  12 // are met:
  13 //
  14 //    Redistributions of source code must retain the above copyright
  15 //    notice, this list of conditions and the following disclaimer.
  16 //
  17 //    Redistributions in binary form must reproduce the above
  18 //    copyright notice, this list of conditions and the following
  19 //    disclaimer in the documentation and/or other materials provided
  20 //    with the distribution.
  21 //
  22 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
  23 //    contributors may be used to endorse or promote products derived
  24 //    from this software without specific prior written permission.
  25 //
  26 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  29 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  30 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  31 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  32 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  33 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  34 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  36 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37 // POSSIBILITY OF SUCH DAMAGE.
  38 //
  39
  40 //
  41 // Help manage multiple profiles, versions, extensions etc.
  42 //
  43 // These don't return error codes, as the presumption is parsing will
  44 // always continue as if the tested feature were enabled, and thus there
  45 // is no error recovery needed.
  46 //
  47
  48 //
  49 // HOW TO add a feature enabled by an extension.
  50 //
  51 // To add a new hypothetical "Feature F" to the front end, where an extension
  52 // "XXX_extension_X" can be used to enable the feature, do the following.
  53 //
  54 // OVERVIEW: Specific features are what are error-checked for, not
  55 //    extensions:  A specific Feature F might be enabled by an extension, or a
  56 //    particular version in a particular profile, or a stage, or combinations, etc.
  57 //
  58 //    The basic mechanism is to use the following to "declare" all the things that
  59 //    enable/disable Feature F, in a code path that implements Feature F:
  60 //
  61 //        requireProfile()
  62 //        profileRequires()
  63 //        requireStage()
  64 //        checkDeprecated()
  65 //        requireNotRemoved()
  66 //        requireExtensions()
  67 //        extensionRequires()
  68 //
  69 //    Typically, only the first two calls are needed.  They go into a code path that
  70 //    implements Feature F, and will log the proper error/warning messages.  Parsing
  71 //    will then always continue as if the tested feature was enabled.
  72 //
  73 //    There is typically no if-testing or conditional parsing, just insertion of the calls above.
  74 //    However, if symbols specific to the extension are added (step 5), they will
  75 //    only be added under tests that the minimum version and profile are present.
  76 //
  77 // 1) Add a symbol name for the extension string at the bottom of Versions.h:
  78 //
  79 //     const char* const XXX_extension_X = "XXX_extension_X";
  80 //
  81 // 2) Add extension initialization to TParseVersions::initializeExtensionBehavior(),
  82 //    the first function below and optionally a entry to extensionData for additional
  83 //    error checks:
  84 //
  85 //     extensionBehavior[XXX_extension_X] = EBhDisable;
  86 //     (Optional) exts[] = {XXX_extension_X, EShTargetSpv_1_4}
  87 //
  88 // 3) Add any preprocessor directives etc. in the next function, TParseVersions::getPreamble():
  89 //
  90 //           "#define XXX_extension_X 1\n"
  91 //
  92 //    The new-line is important, as that ends preprocess tokens.
  93 //
  94 // 4) Insert a profile check in the feature's path (unless all profiles support the feature,
  95 //    for some version level).  That is, call requireProfile() to constrain the profiles, e.g.:
  96 //
  97 //         // ... in a path specific to Feature F...
  98 //         requireProfile(loc,
  99 //                        ECoreProfile | ECompatibilityProfile,
 100 //                        "Feature F");
 101 //
 102 // 5) For each profile that supports the feature, insert version/extension checks:
 103 //
 104 //    The mostly likely scenario is that Feature F can only be used with a
 105 //    particular profile if XXX_extension_X is present or the version is
 106 //    high enough that the core specification already incorporated it.
 107 //
 108 //        // following the requireProfile() call...
 109 //        profileRequires(loc,
 110 //                        ECoreProfile | ECompatibilityProfile,
 111 //                        420,             // 0 if no version incorporated the feature into the core spec.
 112 //                        XXX_extension_X, // can be a list of extensions that all add the feature
 113 //                        "Feature F Description");
 114 //
 115 //    This allows the feature if either A) one of the extensions is enabled or
 116 //    B) the version is high enough.  If no version yet incorporates the feature
 117 //    into core, pass in 0.
 118 //
 119 //    This can be called multiple times, if different profiles support the
 120 //    feature starting at different version numbers or with different
 121 //    extensions.
 122 //
 123 //    This must be called for each profile allowed by the initial call to requireProfile().
 124 //
 125 //    Profiles are all masks, which can be "or"-ed together.
 126 //
 127 //        ENoProfile
 128 //        ECoreProfile
 129 //        ECompatibilityProfile
 130 //        EEsProfile
 131 //
 132 //    The ENoProfile profile is only for desktop, before profiles showed up in version 150;
 133 //    All other #version with no profile default to either es or core, and so have profiles.
 134 //
 135 //    You can select all but a particular profile using ~.  The following basically means "desktop":
 136 //
 137 //        ~EEsProfile
 138 //
 139 // 6) If built-in symbols are added by the extension, add them in Initialize.cpp:  Their use
 140 //    will be automatically error checked against the extensions enabled at that moment.
 141 //    see the comment at the top of Initialize.cpp for where to put them.  Establish them at
 142 //    the earliest release that supports the extension.  Then, tag them with the
 143 //    set of extensions that both enable them and are necessary, given the version of the symbol
 144 //    table. (There is a different symbol table for each version.)
 145 //
 146 // 7) If the extension has additional requirements like minimum SPIR-V version required, add them
 147 //    to extensionRequires()
 148
 149 #include "parseVersions.h"
 150 #include "localintermediate.h"
 151
 152 namespace glslang {
 153
 154 #ifndef GLSLANG_WEB
 155
 156 //
 157 // Initialize all extensions, almost always to 'disable', as once their features
 158 // are incorporated into a core version, their features are supported through allowing that
 159 // core version, not through a pseudo-enablement of the extension.
 160 //
 161 void TParseVersions::initializeExtensionBehavior()
 162 {
 163     typedef struct {
 164         const char *const extensionName;
 165         EShTargetLanguageVersion minSpvVersion;
 166     } extensionData;
 167
 168     const extensionData exts[] = { {E_GL_EXT_ray_tracing, EShTargetSpv_1_4},
 169                                    {E_GL_NV_ray_tracing_motion_blur, EShTargetSpv_1_4}
 170                                  };
 171
 172     for (size_t ii = 0; ii < sizeof(exts) / sizeof(exts[0]); ii++) {
 173         // Add only extensions which require > spv1.0 to save space in map
 174         if (exts[ii].minSpvVersion > EShTargetSpv_1_0) {
 175             extensionMinSpv[exts[ii].extensionName] = exts[ii].minSpvVersion;
 176         }
 177     }
 178
 179     extensionBehavior[E_GL_OES_texture_3D]                   = EBhDisable;
 180     extensionBehavior[E_GL_OES_standard_derivatives]         = EBhDisable;
 181     extensionBehavior[E_GL_EXT_frag_depth]                   = EBhDisable;
 182     extensionBehavior[E_GL_OES_EGL_image_external]           = EBhDisable;
 183     extensionBehavior[E_GL_OES_EGL_image_external_essl3]     = EBhDisable;
 184     extensionBehavior[E_GL_EXT_YUV_target]                   = EBhDisable;
 185     extensionBehavior[E_GL_EXT_shader_texture_lod]           = EBhDisable;
 186     extensionBehavior[E_GL_EXT_shadow_samplers]              = EBhDisable;
 187     extensionBehavior[E_GL_ARB_texture_rectangle]            = EBhDisable;
 188     extensionBehavior[E_GL_3DL_array_objects]                = EBhDisable;
 189     extensionBehavior[E_GL_ARB_shading_language_420pack]     = EBhDisable;
 190     extensionBehavior[E_GL_ARB_texture_gather]               = EBhDisable;
 191     extensionBehavior[E_GL_ARB_gpu_shader5]                  = EBhDisablePartial;
 192     extensionBehavior[E_GL_ARB_separate_shader_objects]      = EBhDisable;
 193     extensionBehavior[E_GL_ARB_compute_shader]               = EBhDisable;
 194     extensionBehavior[E_GL_ARB_tessellation_shader]          = EBhDisable;
 195     extensionBehavior[E_GL_ARB_enhanced_layouts]             = EBhDisable;
 196     extensionBehavior[E_GL_ARB_texture_cube_map_array]       = EBhDisable;
 197     extensionBehavior[E_GL_ARB_texture_multisample]          = EBhDisable;
 198     extensionBehavior[E_GL_ARB_shader_texture_lod]           = EBhDisable;
 199     extensionBehavior[E_GL_ARB_explicit_attrib_location]     = EBhDisable;
 200     extensionBehavior[E_GL_ARB_explicit_uniform_location]    = EBhDisable;
 201     extensionBehavior[E_GL_ARB_shader_image_load_store]      = EBhDisable;
 202     extensionBehavior[E_GL_ARB_shader_atomic_counters]       = EBhDisable;
 203     extensionBehavior[E_GL_ARB_shader_atomic_counter_ops]    = EBhDisable;
 204     extensionBehavior[E_GL_ARB_shader_draw_parameters]       = EBhDisable;
 205     extensionBehavior[E_GL_ARB_shader_group_vote]            = EBhDisable;
 206     extensionBehavior[E_GL_ARB_derivative_control]           = EBhDisable;
 207     extensionBehavior[E_GL_ARB_shader_texture_image_samples] = EBhDisable;
 208     extensionBehavior[E_GL_ARB_viewport_array]               = EBhDisable;
 209     extensionBehavior[E_GL_ARB_gpu_shader_int64]             = EBhDisable;
 210     extensionBehavior[E_GL_ARB_gpu_shader_fp64]              = EBhDisable;
 211     extensionBehavior[E_GL_ARB_shader_ballot]                = EBhDisable;
 212     extensionBehavior[E_GL_ARB_sparse_texture2]              = EBhDisable;
 213     extensionBehavior[E_GL_ARB_sparse_texture_clamp]         = EBhDisable;
 214     extensionBehavior[E_GL_ARB_shader_stencil_export]        = EBhDisable;
 215 //    extensionBehavior[E_GL_ARB_cull_distance]                = EBhDisable;    // present for 4.5, but need extension control over block members
 216     extensionBehavior[E_GL_ARB_post_depth_coverage]          = EBhDisable;
 217     extensionBehavior[E_GL_ARB_shader_viewport_layer_array]  = EBhDisable;
 218     extensionBehavior[E_GL_ARB_fragment_shader_interlock]    = EBhDisable;
 219     extensionBehavior[E_GL_ARB_shader_clock]                 = EBhDisable;
 220     extensionBehavior[E_GL_ARB_uniform_buffer_object]        = EBhDisable;
 221     extensionBehavior[E_GL_ARB_sample_shading]               = EBhDisable;
 222     extensionBehavior[E_GL_ARB_shader_bit_encoding]          = EBhDisable;
 223     extensionBehavior[E_GL_ARB_shader_image_size]            = EBhDisable;
 224     extensionBehavior[E_GL_ARB_shader_storage_buffer_object] = EBhDisable;
 225     extensionBehavior[E_GL_ARB_shading_language_packing]     = EBhDisable;
 226     extensionBehavior[E_GL_ARB_texture_query_lod]            = EBhDisable;
 227     extensionBehavior[E_GL_ARB_vertex_attrib_64bit]          = EBhDisable;
 228     extensionBehavior[E_GL_ARB_draw_instanced]               = EBhDisable;
 229     extensionBehavior[E_GL_ARB_fragment_coord_conventions]   = EBhDisable;
 230
 231
 232     extensionBehavior[E_GL_KHR_shader_subgroup_basic]            = EBhDisable;
 233     extensionBehavior[E_GL_KHR_shader_subgroup_vote]             = EBhDisable;
 234     extensionBehavior[E_GL_KHR_shader_subgroup_arithmetic]       = EBhDisable;
 235     extensionBehavior[E_GL_KHR_shader_subgroup_ballot]           = EBhDisable;
 236     extensionBehavior[E_GL_KHR_shader_subgroup_shuffle]          = EBhDisable;
 237     extensionBehavior[E_GL_KHR_shader_subgroup_shuffle_relative] = EBhDisable;
 238     extensionBehavior[E_GL_KHR_shader_subgroup_clustered]        = EBhDisable;
 239     extensionBehavior[E_GL_KHR_shader_subgroup_quad]             = EBhDisable;
 240     extensionBehavior[E_GL_KHR_memory_scope_semantics]           = EBhDisable;
 241
 242     extensionBehavior[E_GL_EXT_shader_atomic_int64]              = EBhDisable;
 243
 244     extensionBehavior[E_GL_EXT_shader_non_constant_global_initializers] = EBhDisable;
 245     extensionBehavior[E_GL_EXT_shader_image_load_formatted]             = EBhDisable;
 246     extensionBehavior[E_GL_EXT_post_depth_coverage]                     = EBhDisable;
 247     extensionBehavior[E_GL_EXT_control_flow_attributes]                 = EBhDisable;
 248     extensionBehavior[E_GL_EXT_nonuniform_qualifier]                    = EBhDisable;
 249     extensionBehavior[E_GL_EXT_samplerless_texture_functions]           = EBhDisable;
 250     extensionBehavior[E_GL_EXT_scalar_block_layout]                     = EBhDisable;
 251     extensionBehavior[E_GL_EXT_fragment_invocation_density]             = EBhDisable;
 252     extensionBehavior[E_GL_EXT_buffer_reference]                        = EBhDisable;
 253     extensionBehavior[E_GL_EXT_buffer_reference2]                       = EBhDisable;
 254     extensionBehavior[E_GL_EXT_buffer_reference_uvec2]                  = EBhDisable;
 255     extensionBehavior[E_GL_EXT_demote_to_helper_invocation]             = EBhDisable;
 256     extensionBehavior[E_GL_EXT_debug_printf]                            = EBhDisable;
 257
 258     extensionBehavior[E_GL_EXT_shader_16bit_storage]                    = EBhDisable;
 259     extensionBehavior[E_GL_EXT_shader_8bit_storage]                     = EBhDisable;
 260     extensionBehavior[E_GL_EXT_subgroup_uniform_control_flow]           = EBhDisable;
 261
 262     // #line and #include
 263     extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive]          = EBhDisable;
 264     extensionBehavior[E_GL_GOOGLE_include_directive]                 = EBhDisable;
 265
 266     extensionBehavior[E_GL_AMD_shader_ballot]                        = EBhDisable;
 267     extensionBehavior[E_GL_AMD_shader_trinary_minmax]                = EBhDisable;
 268     extensionBehavior[E_GL_AMD_shader_explicit_vertex_parameter]     = EBhDisable;
 269     extensionBehavior[E_GL_AMD_gcn_shader]                           = EBhDisable;
 270     extensionBehavior[E_GL_AMD_gpu_shader_half_float]                = EBhDisable;
 271     extensionBehavior[E_GL_AMD_texture_gather_bias_lod]              = EBhDisable;
 272     extensionBehavior[E_GL_AMD_gpu_shader_int16]                     = EBhDisable;
 273     extensionBehavior[E_GL_AMD_shader_image_load_store_lod]          = EBhDisable;
 274     extensionBehavior[E_GL_AMD_shader_fragment_mask]                 = EBhDisable;
 275     extensionBehavior[E_GL_AMD_gpu_shader_half_float_fetch]          = EBhDisable;
 276
 277     extensionBehavior[E_GL_INTEL_shader_integer_functions2]          = EBhDisable;
 278
 279     extensionBehavior[E_GL_NV_sample_mask_override_coverage]         = EBhDisable;
 280     extensionBehavior[E_SPV_NV_geometry_shader_passthrough]          = EBhDisable;
 281     extensionBehavior[E_GL_NV_viewport_array2]                       = EBhDisable;
 282     extensionBehavior[E_GL_NV_stereo_view_rendering]                 = EBhDisable;
 283     extensionBehavior[E_GL_NVX_multiview_per_view_attributes]        = EBhDisable;
 284     extensionBehavior[E_GL_NV_shader_atomic_int64]                   = EBhDisable;
 285     extensionBehavior[E_GL_NV_conservative_raster_underestimation]   = EBhDisable;
 286     extensionBehavior[E_GL_NV_shader_noperspective_interpolation]    = EBhDisable;
 287     extensionBehavior[E_GL_NV_shader_subgroup_partitioned]           = EBhDisable;
 288     extensionBehavior[E_GL_NV_shading_rate_image]                    = EBhDisable;
 289     extensionBehavior[E_GL_NV_ray_tracing]                           = EBhDisable;
 290     extensionBehavior[E_GL_NV_ray_tracing_motion_blur]               = EBhDisable;
 291     extensionBehavior[E_GL_NV_fragment_shader_barycentric]           = EBhDisable;
 292     extensionBehavior[E_GL_NV_compute_shader_derivatives]            = EBhDisable;
 293     extensionBehavior[E_GL_NV_shader_texture_footprint]              = EBhDisable;
 294     extensionBehavior[E_GL_NV_mesh_shader]                           = EBhDisable;
 295
 296     extensionBehavior[E_GL_NV_cooperative_matrix]                    = EBhDisable;
 297     extensionBehavior[E_GL_NV_shader_sm_builtins]                    = EBhDisable;
 298     extensionBehavior[E_GL_NV_integer_cooperative_matrix]            = EBhDisable;
 299
 300     // AEP
 301     extensionBehavior[E_GL_ANDROID_extension_pack_es31a]             = EBhDisable;
 302     extensionBehavior[E_GL_KHR_blend_equation_advanced]              = EBhDisable;
 303     extensionBehavior[E_GL_OES_sample_variables]                     = EBhDisable;
 304     extensionBehavior[E_GL_OES_shader_image_atomic]                  = EBhDisable;
 305     extensionBehavior[E_GL_OES_shader_multisample_interpolation]     = EBhDisable;
 306     extensionBehavior[E_GL_OES_texture_storage_multisample_2d_array] = EBhDisable;
 307     extensionBehavior[E_GL_EXT_geometry_shader]                      = EBhDisable;
 308     extensionBehavior[E_GL_EXT_geometry_point_size]                  = EBhDisable;
 309     extensionBehavior[E_GL_EXT_gpu_shader5]                          = EBhDisable;
 310     extensionBehavior[E_GL_EXT_primitive_bounding_box]               = EBhDisable;
 311     extensionBehavior[E_GL_EXT_shader_io_blocks]                     = EBhDisable;
 312     extensionBehavior[E_GL_EXT_tessellation_shader]                  = EBhDisable;
 313     extensionBehavior[E_GL_EXT_tessellation_point_size]              = EBhDisable;
 314     extensionBehavior[E_GL_EXT_texture_buffer]                       = EBhDisable;
 315     extensionBehavior[E_GL_EXT_texture_cube_map_array]               = EBhDisable;
 316     extensionBehavior[E_GL_EXT_null_initializer]                     = EBhDisable;
 317
 318     // OES matching AEP
 319     extensionBehavior[E_GL_OES_geometry_shader]          = EBhDisable;
 320     extensionBehavior[E_GL_OES_geometry_point_size]      = EBhDisable;
 321     extensionBehavior[E_GL_OES_gpu_shader5]              = EBhDisable;
 322     extensionBehavior[E_GL_OES_primitive_bounding_box]   = EBhDisable;
 323     extensionBehavior[E_GL_OES_shader_io_blocks]         = EBhDisable;
 324     extensionBehavior[E_GL_OES_tessellation_shader]      = EBhDisable;
 325     extensionBehavior[E_GL_OES_tessellation_point_size]  = EBhDisable;
 326     extensionBehavior[E_GL_OES_texture_buffer]           = EBhDisable;
 327     extensionBehavior[E_GL_OES_texture_cube_map_array]   = EBhDisable;
 328     extensionBehavior[E_GL_EXT_shader_integer_mix]       = EBhDisable;
 329
 330     // EXT extensions
 331     extensionBehavior[E_GL_EXT_device_group]                = EBhDisable;
 332     extensionBehavior[E_GL_EXT_multiview]                   = EBhDisable;
 333     extensionBehavior[E_GL_EXT_shader_realtime_clock]       = EBhDisable;
 334     extensionBehavior[E_GL_EXT_ray_tracing]                 = EBhDisable;
 335     extensionBehavior[E_GL_EXT_ray_query]                   = EBhDisable;
 336     extensionBehavior[E_GL_EXT_ray_flags_primitive_culling] = EBhDisable;
 337     extensionBehavior[E_GL_EXT_blend_func_extended]         = EBhDisable;
 338     extensionBehavior[E_GL_EXT_shader_implicit_conversions] = EBhDisable;
 339     extensionBehavior[E_GL_EXT_fragment_shading_rate]       = EBhDisable;
 340     extensionBehavior[E_GL_EXT_shader_image_int64]   = EBhDisable;
 341     extensionBehavior[E_GL_EXT_terminate_invocation]        = EBhDisable;
 342     extensionBehavior[E_GL_EXT_shared_memory_block]         = EBhDisable;
 343     extensionBehavior[E_GL_EXT_spirv_intrinsics]            = EBhDisable;
 344
 345     // OVR extensions
 346     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
 347     extensionBehavior[E_GL_OVR_multiview2]               = EBhDisable;
 348
 349     // explicit types
 350     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types]         = EBhDisable;
 351     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int8]    = EBhDisable;
 352     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int16]   = EBhDisable;
 353     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int32]   = EBhDisable;
 354     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int64]   = EBhDisable;
 355     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_float16] = EBhDisable;
 356     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_float32] = EBhDisable;
 357     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_float64] = EBhDisable;
 358
 359     // subgroup extended types
 360     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_int8]    = EBhDisable;
 361     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_int16]   = EBhDisable;
 362     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_int64]   = EBhDisable;
 363     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_float16] = EBhDisable;
 364     extensionBehavior[E_GL_EXT_shader_atomic_float]                    = EBhDisable;
 365     extensionBehavior[E_GL_EXT_shader_atomic_float2]                   = EBhDisable;
 366 }
 367
 368 #endif // GLSLANG_WEB
 369
 370 // Get code that is not part of a shared symbol table, is specific to this shader,
 371 // or needed by the preprocessor (which does not use a shared symbol table).
 372 void TParseVersions::getPreamble(std::string& preamble)
 373 {
 374     if (isEsProfile()) {
 375         preamble =
 376             "#define GL_ES 1\n"
 377             "#define GL_FRAGMENT_PRECISION_HIGH 1\n"
 378 #ifdef GLSLANG_WEB
 379             ;
 380 #else
 381             "#define GL_OES_texture_3D 1\n"
 382             "#define GL_OES_standard_derivatives 1\n"
 383             "#define GL_EXT_frag_depth 1\n"
 384             "#define GL_OES_EGL_image_external 1\n"
 385             "#define GL_OES_EGL_image_external_essl3 1\n"
 386             "#define GL_EXT_YUV_target 1\n"
 387             "#define GL_EXT_shader_texture_lod 1\n"
 388             "#define GL_EXT_shadow_samplers 1\n"
 389             "#define GL_EXT_fragment_shading_rate 1\n"
 390
 391             // AEP
 392             "#define GL_ANDROID_extension_pack_es31a 1\n"
 393             "#define GL_OES_sample_variables 1\n"
 394             "#define GL_OES_shader_image_atomic 1\n"
 395             "#define GL_OES_shader_multisample_interpolation 1\n"
 396             "#define GL_OES_texture_storage_multisample_2d_array 1\n"
 397             "#define GL_EXT_geometry_shader 1\n"
 398             "#define GL_EXT_geometry_point_size 1\n"
 399             "#define GL_EXT_gpu_shader5 1\n"
 400             "#define GL_EXT_primitive_bounding_box 1\n"
 401             "#define GL_EXT_shader_io_blocks 1\n"
 402             "#define GL_EXT_tessellation_shader 1\n"
 403             "#define GL_EXT_tessellation_point_size 1\n"
 404             "#define GL_EXT_texture_buffer 1\n"
 405             "#define GL_EXT_texture_cube_map_array 1\n"
 406             "#define GL_EXT_shader_implicit_conversions 1\n"
 407             "#define GL_EXT_shader_integer_mix 1\n"
 408             "#define GL_EXT_blend_func_extended 1\n"
 409
 410             // OES matching AEP
 411             "#define GL_OES_geometry_shader 1\n"
 412             "#define GL_OES_geometry_point_size 1\n"
 413             "#define GL_OES_gpu_shader5 1\n"
 414             "#define GL_OES_primitive_bounding_box 1\n"
 415             "#define GL_OES_shader_io_blocks 1\n"
 416             "#define GL_OES_tessellation_shader 1\n"
 417             "#define GL_OES_tessellation_point_size 1\n"
 418             "#define GL_OES_texture_buffer 1\n"
 419             "#define GL_OES_texture_cube_map_array 1\n"
 420             "#define GL_EXT_shader_non_constant_global_initializers 1\n"
 421             ;
 422
 423             if (version >= 300) {
 424                 preamble += "#define GL_NV_shader_noperspective_interpolation 1\n";
 425             }
 426             if (version >= 310) {
 427                 preamble += "#define GL_EXT_null_initializer 1\n";
 428                 preamble += "#define GL_EXT_subgroup_uniform_control_flow 1\n";
 429             }
 430
 431     } else { // !isEsProfile()
 432         preamble =
 433             "#define GL_FRAGMENT_PRECISION_HIGH 1\n"
 434             "#define GL_ARB_texture_rectangle 1\n"
 435             "#define GL_ARB_shading_language_420pack 1\n"
 436             "#define GL_ARB_texture_gather 1\n"
 437             "#define GL_ARB_gpu_shader5 1\n"
 438             "#define GL_ARB_separate_shader_objects 1\n"
 439             "#define GL_ARB_compute_shader 1\n"
 440             "#define GL_ARB_tessellation_shader 1\n"
 441             "#define GL_ARB_enhanced_layouts 1\n"
 442             "#define GL_ARB_texture_cube_map_array 1\n"
 443             "#define GL_ARB_texture_multisample 1\n"
 444             "#define GL_ARB_shader_texture_lod 1\n"
 445             "#define GL_ARB_explicit_attrib_location 1\n"
 446             "#define GL_ARB_explicit_uniform_location 1\n"
 447             "#define GL_ARB_shader_image_load_store 1\n"
 448             "#define GL_ARB_shader_atomic_counters 1\n"
 449             "#define GL_ARB_shader_draw_parameters 1\n"
 450             "#define GL_ARB_shader_group_vote 1\n"
 451             "#define GL_ARB_derivative_control 1\n"
 452             "#define GL_ARB_shader_texture_image_samples 1\n"
 453             "#define GL_ARB_viewport_array 1\n"
 454             "#define GL_ARB_gpu_shader_int64 1\n"
 455             "#define GL_ARB_gpu_shader_fp64 1\n"
 456             "#define GL_ARB_shader_ballot 1\n"
 457             "#define GL_ARB_sparse_texture2 1\n"
 458             "#define GL_ARB_sparse_texture_clamp 1\n"
 459             "#define GL_ARB_shader_stencil_export 1\n"
 460             "#define GL_ARB_sample_shading 1\n"
 461             "#define GL_ARB_shader_image_size 1\n"
 462             "#define GL_ARB_shading_language_packing 1\n"
 463 //            "#define GL_ARB_cull_distance 1\n"    // present for 4.5, but need extension control over block members
 464             "#define GL_ARB_post_depth_coverage 1\n"
 465             "#define GL_ARB_fragment_shader_interlock 1\n"
 466             "#define GL_ARB_uniform_buffer_object 1\n"
 467             "#define GL_ARB_shader_bit_encoding 1\n"
 468             "#define GL_ARB_shader_storage_buffer_object 1\n"
 469             "#define GL_ARB_texture_query_lod 1\n"
 470             "#define GL_ARB_vertex_attrib_64bit 1\n"
 471             "#define GL_ARB_draw_instanced 1\n"
 472             "#define GL_ARB_fragment_coord_conventions 1\n"
 473             "#define GL_EXT_shader_non_constant_global_initializers 1\n"
 474             "#define GL_EXT_shader_image_load_formatted 1\n"
 475             "#define GL_EXT_post_depth_coverage 1\n"
 476             "#define GL_EXT_control_flow_attributes 1\n"
 477             "#define GL_EXT_nonuniform_qualifier 1\n"
 478             "#define GL_EXT_shader_16bit_storage 1\n"
 479             "#define GL_EXT_shader_8bit_storage 1\n"
 480             "#define GL_EXT_samplerless_texture_functions 1\n"
 481             "#define GL_EXT_scalar_block_layout 1\n"
 482             "#define GL_EXT_fragment_invocation_density 1\n"
 483             "#define GL_EXT_buffer_reference 1\n"
 484             "#define GL_EXT_buffer_reference2 1\n"
 485             "#define GL_EXT_buffer_reference_uvec2 1\n"
 486             "#define GL_EXT_demote_to_helper_invocation 1\n"
 487             "#define GL_EXT_debug_printf 1\n"
 488             "#define GL_EXT_fragment_shading_rate 1\n"
 489             "#define GL_EXT_shared_memory_block 1\n"
 490             "#define GL_EXT_shader_integer_mix 1\n"
 491
 492             // GL_KHR_shader_subgroup
 493             "#define GL_KHR_shader_subgroup_basic 1\n"
 494             "#define GL_KHR_shader_subgroup_vote 1\n"
 495             "#define GL_KHR_shader_subgroup_arithmetic 1\n"
 496             "#define GL_KHR_shader_subgroup_ballot 1\n"
 497             "#define GL_KHR_shader_subgroup_shuffle 1\n"
 498             "#define GL_KHR_shader_subgroup_shuffle_relative 1\n"
 499             "#define GL_KHR_shader_subgroup_clustered 1\n"
 500             "#define GL_KHR_shader_subgroup_quad 1\n"
 501
 502             "#define GL_EXT_shader_image_int64 1\n"
 503             "#define GL_EXT_shader_atomic_int64 1\n"
 504             "#define GL_EXT_shader_realtime_clock 1\n"
 505             "#define GL_EXT_ray_tracing 1\n"
 506             "#define GL_EXT_ray_query 1\n"
 507             "#define GL_EXT_ray_flags_primitive_culling 1\n"
 508             "#define GL_EXT_spirv_intrinsics 1\n"
 509
 510             "#define GL_AMD_shader_ballot 1\n"
 511             "#define GL_AMD_shader_trinary_minmax 1\n"
 512             "#define GL_AMD_shader_explicit_vertex_parameter 1\n"
 513             "#define GL_AMD_gcn_shader 1\n"
 514             "#define GL_AMD_gpu_shader_half_float 1\n"
 515             "#define GL_AMD_texture_gather_bias_lod 1\n"
 516             "#define GL_AMD_gpu_shader_int16 1\n"
 517             "#define GL_AMD_shader_image_load_store_lod 1\n"
 518             "#define GL_AMD_shader_fragment_mask 1\n"
 519             "#define GL_AMD_gpu_shader_half_float_fetch 1\n"
 520
 521             "#define GL_INTEL_shader_integer_functions2 1\n"
 522
 523             "#define GL_NV_sample_mask_override_coverage 1\n"
 524             "#define GL_NV_geometry_shader_passthrough 1\n"
 525             "#define GL_NV_viewport_array2 1\n"
 526             "#define GL_NV_shader_atomic_int64 1\n"
 527             "#define GL_NV_conservative_raster_underestimation 1\n"
 528             "#define GL_NV_shader_subgroup_partitioned 1\n"
 529             "#define GL_NV_shading_rate_image 1\n"
 530             "#define GL_NV_ray_tracing 1\n"
 531             "#define GL_NV_ray_tracing_motion_blur 1\n"
 532             "#define GL_NV_fragment_shader_barycentric 1\n"
 533             "#define GL_NV_compute_shader_derivatives 1\n"
 534             "#define GL_NV_shader_texture_footprint 1\n"
 535             "#define GL_NV_mesh_shader 1\n"
 536             "#define GL_NV_cooperative_matrix 1\n"
 537             "#define GL_NV_integer_cooperative_matrix 1\n"
 538
 539             "#define GL_EXT_shader_explicit_arithmetic_types 1\n"
 540             "#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"
 541             "#define GL_EXT_shader_explicit_arithmetic_types_int16 1\n"
 542             "#define GL_EXT_shader_explicit_arithmetic_types_int32 1\n"
 543             "#define GL_EXT_shader_explicit_arithmetic_types_int64 1\n"
 544             "#define GL_EXT_shader_explicit_arithmetic_types_float16 1\n"
 545             "#define GL_EXT_shader_explicit_arithmetic_types_float32 1\n"
 546             "#define GL_EXT_shader_explicit_arithmetic_types_float64 1\n"
 547
 548             "#define GL_EXT_shader_subgroup_extended_types_int8 1\n"
 549             "#define GL_EXT_shader_subgroup_extended_types_int16 1\n"
 550             "#define GL_EXT_shader_subgroup_extended_types_int64 1\n"
 551             "#define GL_EXT_shader_subgroup_extended_types_float16 1\n"
 552
 553             "#define GL_EXT_shader_atomic_float 1\n"
 554             "#define GL_EXT_shader_atomic_float2 1\n"
 555             ;
 556
 557         if (version >= 150) {
 558             // define GL_core_profile and GL_compatibility_profile
 559             preamble += "#define GL_core_profile 1\n";
 560
 561             if (profile == ECompatibilityProfile)
 562                 preamble += "#define GL_compatibility_profile 1\n";
 563         }
 564         if (version >= 140) {
 565             preamble += "#define GL_EXT_null_initializer 1\n";
 566             preamble += "#define GL_EXT_subgroup_uniform_control_flow 1\n";
 567         }
 568 #endif // GLSLANG_WEB
 569     }
 570
 571 #ifndef GLSLANG_WEB
 572     if ((!isEsProfile() && version >= 140) ||
 573         (isEsProfile() && version >= 310)) {
 574         preamble +=
 575             "#define GL_EXT_device_group 1\n"
 576             "#define GL_EXT_multiview 1\n"
 577             "#define GL_NV_shader_sm_builtins 1\n"
 578             ;
 579     }
 580
 581     if (version >= 300 /* both ES and non-ES */) {
 582         preamble +=
 583             "#define GL_OVR_multiview 1\n"
 584             "#define GL_OVR_multiview2 1\n"
 585             ;
 586     }
 587
 588     // #line and #include
 589     preamble +=
 590             "#define GL_GOOGLE_cpp_style_line_directive 1\n"
 591             "#define GL_GOOGLE_include_directive 1\n"
 592             "#define GL_KHR_blend_equation_advanced 1\n"
 593             ;
 594
 595     // other general extensions
 596     preamble +=
 597             "#define GL_EXT_terminate_invocation 1\n"
 598             ;
 599 #endif
 600
 601     // #define VULKAN XXXX
 602     const int numberBufSize = 12;
 603     char numberBuf[numberBufSize];
 604     if (spvVersion.vulkanGlsl > 0) {
 605         preamble += "#define VULKAN ";
 606         snprintf(numberBuf, numberBufSize, "%d", spvVersion.vulkanGlsl);
 607         preamble += numberBuf;
 608         preamble += "\n";
 609     }
 610
 611 #ifndef GLSLANG_WEB
 612     // #define GL_SPIRV XXXX
 613     if (spvVersion.openGl > 0) {
 614         preamble += "#define GL_SPIRV ";
 615         snprintf(numberBuf, numberBufSize, "%d", spvVersion.openGl);
 616         preamble += numberBuf;
 617         preamble += "\n";
 618     }
 619 #endif
 620
 621 #ifndef GLSLANG_WEB
 622     // GL_EXT_spirv_intrinsics
 623     if (!isEsProfile()) {
 624         switch (language) {
 625         case EShLangVertex:         preamble += "#define GL_VERTEX_SHADER 1 \n";                    break;
 626         case EShLangTessControl:    preamble += "#define GL_TESSELLATION_CONTROL_SHADER 1 \n";      break;
 627         case EShLangTessEvaluation: preamble += "#define GL_TESSELLATION_EVALUATION_SHADER 1 \n";   break;
 628         case EShLangGeometry:       preamble += "#define GL_GEOMETRY_SHADER 1 \n";                  break;
 629         case EShLangFragment:       preamble += "#define GL_FRAGMENT_SHADER 1 \n";                  break;
 630         case EShLangCompute:        preamble += "#define GL_COMPUTE_SHADER 1 \n";                   break;
 631         case EShLangRayGen:         preamble += "#define GL_RAY_GENERATION_SHADER_EXT 1 \n";        break;
 632         case EShLangIntersect:      preamble += "#define GL_INTERSECTION_SHADER_EXT 1 \n";          break;
 633         case EShLangAnyHit:         preamble += "#define GL_ANY_HIT_SHADER_EXT 1 \n";               break;
 634         case EShLangClosestHit:     preamble += "#define GL_CLOSEST_HIT_SHADER_EXT 1 \n";           break;
 635         case EShLangMiss:           preamble += "#define GL_MISS_SHADER_EXT 1 \n";                  break;
 636         case EShLangCallable:       preamble += "#define GL_CALLABLE_SHADER_EXT 1 \n";              break;
 637         case EShLangTaskNV:         preamble += "#define GL_TASK_SHADER_NV 1 \n";                   break;
 638         case EShLangMeshNV:         preamble += "#define GL_MESH_SHADER_NV 1 \n";                   break;
 639         default:                                                                                    break;
 640         }
 641     }
 642 #endif
 643 }
 644
 645 //
 646 // Map from stage enum to externally readable text name.
 647 //
 648 const char* StageName(EShLanguage stage)
 649 {
 650     switch(stage) {
 651     case EShLangVertex:         return "vertex";
 652     case EShLangFragment:       return "fragment";
 653     case EShLangCompute:        return "compute";
 654 #ifndef GLSLANG_WEB
 655     case EShLangTessControl:    return "tessellation control";
 656     case EShLangTessEvaluation: return "tessellation evaluation";
 657     case EShLangGeometry:       return "geometry";
 658     case EShLangRayGen:         return "ray-generation";
 659     case EShLangIntersect:      return "intersection";
 660     case EShLangAnyHit:         return "any-hit";
 661     case EShLangClosestHit:     return "closest-hit";
 662     case EShLangMiss:           return "miss";
 663     case EShLangCallable:       return "callable";
 664     case EShLangMeshNV:         return "mesh";
 665     case EShLangTaskNV:         return "task";
 666 #endif
 667     default:                    return "unknown stage";
 668     }
 669 }
 670
 671 //
 672 // When to use requireStage()
 673 //
 674 //     If only some stages support a feature.
 675 //
 676 // Operation: If the current stage is not present, give an error message.
 677 //
 678 void TParseVersions::requireStage(const TSourceLoc& loc, EShLanguageMask languageMask, const char* featureDesc)
 679 {
 680     if (((1 << language) & languageMask) == 0)
 681         error(loc, "not supported in this stage:", featureDesc, StageName(language));
 682 }
 683
 684 // If only one stage supports a feature, this can be called.  But, all supporting stages
 685 // must be specified with one call.
 686 void TParseVersions::requireStage(const TSourceLoc& loc, EShLanguage stage, const char* featureDesc)
 687 {
 688     requireStage(loc, static_cast<EShLanguageMask>(1 << stage), featureDesc);
 689 }
 690
 691 #ifndef GLSLANG_WEB
 692 //
 693 // When to use requireProfile():
 694 //
 695 //     Use if only some profiles support a feature.  However, if within a profile the feature
 696 //     is version or extension specific, follow this call with calls to profileRequires().
 697 //
 698 // Operation:  If the current profile is not one of the profileMask,
 699 // give an error message.
 700 //
 701 void TParseVersions::requireProfile(const TSourceLoc& loc, int profileMask, const char* featureDesc)
 702 {
 703     if (! (profile & profileMask))
 704         error(loc, "not supported with this profile:", featureDesc, ProfileName(profile));
 705 }
 706
 707 //
 708 // When to use profileRequires():
 709 //
 710 //     If a set of profiles have the same requirements for what version or extensions
 711 //     are needed to support a feature.
 712 //
 713 //     It must be called for each profile that needs protection.  Use requireProfile() first
 714 //     to reduce that set of profiles.
 715 //
 716 // Operation: Will issue warnings/errors based on the current profile, version, and extension
 717 // behaviors.  It only checks extensions when the current profile is one of the profileMask.
 718 //
 719 // A minVersion of 0 means no version of the profileMask support this in core,
 720 // the extension must be present.
 721 //
 722
 723 // entry point that takes multiple extensions
 724 void TParseVersions::profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, int numExtensions,
 725     const char* const extensions[], const char* featureDesc)
 726 {
 727     if (profile & profileMask) {
 728         bool okay = minVersion > 0 && version >= minVersion;
 729 #ifndef GLSLANG_WEB
 730         for (int i = 0; i < numExtensions; ++i) {
 731             switch (getExtensionBehavior(extensions[i])) {
 732             case EBhWarn:
 733                 infoSink.info.message(EPrefixWarning, ("extension " + TString(extensions[i]) + " is being used for " + featureDesc).c_str(), loc);
 734                 // fall through
 735             case EBhRequire:
 736             case EBhEnable:
 737                 okay = true;
 738                 break;
 739             default: break; // some compilers want this
 740             }
 741         }
 742 #endif
 743         if (! okay)
 744             error(loc, "not supported for this version or the enabled extensions", featureDesc, "");
 745     }
 746 }
 747
 748 // entry point for the above that takes a single extension
 749 void TParseVersions::profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, const char* extension,
 750     const char* featureDesc)
 751 {
 752     profileRequires(loc, profileMask, minVersion, extension ? 1 : 0, &extension, featureDesc);
 753 }
 754
 755 void TParseVersions::unimplemented(const TSourceLoc& loc, const char* featureDesc)
 756 {
 757     error(loc, "feature not yet implemented", featureDesc, "");
 758 }
 759
 760 //
 761 // Within a set of profiles, see if a feature is deprecated and give an error or warning based on whether
 762 // a future compatibility context is being use.
 763 //
 764 void TParseVersions::checkDeprecated(const TSourceLoc& loc, int profileMask, int depVersion, const char* featureDesc)
 765 {
 766     if (profile & profileMask) {
 767         if (version >= depVersion) {
 768             if (forwardCompatible)
 769                 error(loc, "deprecated, may be removed in future release", featureDesc, "");
 770             else if (! suppressWarnings())
 771                 infoSink.info.message(EPrefixWarning, (TString(featureDesc) + " deprecated in version " +
 772                                                        String(depVersion) + "; may be removed in future release").c_str(), loc);
 773         }
 774     }
 775 }
 776
 777 //
 778 // Within a set of profiles, see if a feature has now been removed and if so, give an error.
 779 // The version argument is the first version no longer having the feature.
 780 //
 781 void TParseVersions::requireNotRemoved(const TSourceLoc& loc, int profileMask, int removedVersion, const char* featureDesc)
 782 {
 783     if (profile & profileMask) {
 784         if (version >= removedVersion) {
 785             const int maxSize = 60;
 786             char buf[maxSize];
 787             snprintf(buf, maxSize, "%s profile; removed in version %d", ProfileName(profile), removedVersion);
 788             error(loc, "no longer supported in", featureDesc, buf);
 789         }
 790     }
 791 }
 792
 793 // Returns true if at least one of the extensions in the extensions parameter is requested. Otherwise, returns false.
 794 // Warns appropriately if the requested behavior of an extension is "warn".
 795 bool TParseVersions::checkExtensionsRequested(const TSourceLoc& loc, int numExtensions, const char* const extensions[], const char* featureDesc)
 796 {
 797     // First, see if any of the extensions are enabled
 798     for (int i = 0; i < numExtensions; ++i) {
 799         TExtensionBehavior behavior = getExtensionBehavior(extensions[i]);
 800         if (behavior == EBhEnable || behavior == EBhRequire)
 801             return true;
 802     }
 803
 804     // See if any extensions want to give a warning on use; give warnings for all such extensions
 805     bool warned = false;
 806     for (int i = 0; i < numExtensions; ++i) {
 807         TExtensionBehavior behavior = getExtensionBehavior(extensions[i]);
 808         if (behavior == EBhDisable && relaxedErrors()) {
 809             infoSink.info.message(EPrefixWarning, "The following extension must be enabled to use this feature:", loc);
 810             behavior = EBhWarn;
 811         }
 812         if (behavior == EBhWarn) {
 813             infoSink.info.message(EPrefixWarning, ("extension " + TString(extensions[i]) + " is being used for " + featureDesc).c_str(), loc);
 814             warned = true;
 815         }
 816     }
 817     if (warned)
 818         return true;
 819     return false;
 820 }
 821
 822 //
 823 // Use when there are no profile/version to check, it's just an error if one of the
 824 // extensions is not present.
 825 //
 826 void TParseVersions::requireExtensions(const TSourceLoc& loc, int numExtensions, const char* const extensions[],
 827     const char* featureDesc)
 828 {
 829     if (checkExtensionsRequested(loc, numExtensions, extensions, featureDesc))
 830         return;
 831
 832     // If we get this far, give errors explaining what extensions are needed
 833     if (numExtensions == 1)
 834         error(loc, "required extension not requested:", featureDesc, extensions[0]);
 835     else {
 836         error(loc, "required extension not requested:", featureDesc, "Possible extensions include:");
 837         for (int i = 0; i < numExtensions; ++i)
 838             infoSink.info.message(EPrefixNone, extensions[i]);
 839     }
 840 }
 841
 842 //
 843 // Use by preprocessor when there are no profile/version to check, it's just an error if one of the
 844 // extensions is not present.
 845 //
 846 void TParseVersions::ppRequireExtensions(const TSourceLoc& loc, int numExtensions, const char* const extensions[],
 847     const char* featureDesc)
 848 {
 849     if (checkExtensionsRequested(loc, numExtensions, extensions, featureDesc))
 850         return;
 851
 852     // If we get this far, give errors explaining what extensions are needed
 853     if (numExtensions == 1)
 854         ppError(loc, "required extension not requested:", featureDesc, extensions[0]);
 855     else {
 856         ppError(loc, "required extension not requested:", featureDesc, "Possible extensions include:");
 857         for (int i = 0; i < numExtensions; ++i)
 858             infoSink.info.message(EPrefixNone, extensions[i]);
 859     }
 860 }
 861
 862 TExtensionBehavior TParseVersions::getExtensionBehavior(const char* extension)
 863 {
 864     auto iter = extensionBehavior.find(TString(extension));
 865     if (iter == extensionBehavior.end())
 866         return EBhMissing;
 867     else
 868         return iter->second;
 869 }
 870
 871 // Returns true if the given extension is set to enable, require, or warn.
 872 bool TParseVersions::extensionTurnedOn(const char* const extension)
 873 {
 874       switch (getExtensionBehavior(extension)) {
 875       case EBhEnable:
 876       case EBhRequire:
 877       case EBhWarn:
 878           return true;
 879       default:
 880           break;
 881       }
 882       return false;
 883 }
 884 // See if any of the extensions are set to enable, require, or warn.
 885 bool TParseVersions::extensionsTurnedOn(int numExtensions, const char* const extensions[])
 886 {
 887     for (int i = 0; i < numExtensions; ++i) {
 888         if (extensionTurnedOn(extensions[i]))
 889             return true;
 890     }
 891     return false;
 892 }
 893
 894 //
 895 // Change the current state of an extension's behavior.
 896 //
 897 void TParseVersions::updateExtensionBehavior(int line, const char* extension, const char* behaviorString)
 898 {
 899     // Translate from text string of extension's behavior to an enum.
 900     TExtensionBehavior behavior = EBhDisable;
 901     if (! strcmp("require", behaviorString))
 902         behavior = EBhRequire;
 903     else if (! strcmp("enable", behaviorString))
 904         behavior = EBhEnable;
 905     else if (! strcmp("disable", behaviorString))
 906         behavior = EBhDisable;
 907     else if (! strcmp("warn", behaviorString))
 908         behavior = EBhWarn;
 909     else {
 910         error(getCurrentLoc(), "behavior not supported:", "#extension", behaviorString);
 911         return;
 912     }
 913     bool on = behavior != EBhDisable;
 914
 915     // check if extension is used with correct shader stage
 916     checkExtensionStage(getCurrentLoc(), extension);
 917
 918     // check if extension has additional requirements
 919     extensionRequires(getCurrentLoc(), extension, behaviorString);
 920
 921     // update the requested extension
 922     updateExtensionBehavior(extension, behavior);
 923
 924     // see if need to propagate to implicitly modified things
 925     if (strcmp(extension, "GL_ANDROID_extension_pack_es31a") == 0) {
 926         // to everything in AEP
 927         updateExtensionBehavior(line, "GL_KHR_blend_equation_advanced", behaviorString);
 928         updateExtensionBehavior(line, "GL_OES_sample_variables", behaviorString);
 929         updateExtensionBehavior(line, "GL_OES_shader_image_atomic", behaviorString);
 930         updateExtensionBehavior(line, "GL_OES_shader_multisample_interpolation", behaviorString);
 931         updateExtensionBehavior(line, "GL_OES_texture_storage_multisample_2d_array", behaviorString);
 932         updateExtensionBehavior(line, "GL_EXT_geometry_shader", behaviorString);
 933         updateExtensionBehavior(line, "GL_EXT_gpu_shader5", behaviorString);
 934         updateExtensionBehavior(line, "GL_EXT_primitive_bounding_box", behaviorString);
 935         updateExtensionBehavior(line, "GL_EXT_shader_io_blocks", behaviorString);
 936         updateExtensionBehavior(line, "GL_EXT_tessellation_shader", behaviorString);
 937         updateExtensionBehavior(line, "GL_EXT_texture_buffer", behaviorString);
 938         updateExtensionBehavior(line, "GL_EXT_texture_cube_map_array", behaviorString);
 939     }
 940     // geometry to io_blocks
 941     else if (strcmp(extension, "GL_EXT_geometry_shader") == 0)
 942         updateExtensionBehavior(line, "GL_EXT_shader_io_blocks", behaviorString);
 943     else if (strcmp(extension, "GL_OES_geometry_shader") == 0)
 944         updateExtensionBehavior(line, "GL_OES_shader_io_blocks", behaviorString);
 945     // tessellation to io_blocks
 946     else if (strcmp(extension, "GL_EXT_tessellation_shader") == 0)
 947         updateExtensionBehavior(line, "GL_EXT_shader_io_blocks", behaviorString);
 948     else if (strcmp(extension, "GL_OES_tessellation_shader") == 0)
 949         updateExtensionBehavior(line, "GL_OES_shader_io_blocks", behaviorString);
 950     else if (strcmp(extension, "GL_GOOGLE_include_directive") == 0)
 951         updateExtensionBehavior(line, "GL_GOOGLE_cpp_style_line_directive", behaviorString);
 952     // subgroup_* to subgroup_basic
 953     else if (strcmp(extension, "GL_KHR_shader_subgroup_vote") == 0)
 954         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 955     else if (strcmp(extension, "GL_KHR_shader_subgroup_arithmetic") == 0)
 956         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 957     else if (strcmp(extension, "GL_KHR_shader_subgroup_ballot") == 0)
 958         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 959     else if (strcmp(extension, "GL_KHR_shader_subgroup_shuffle") == 0)
 960         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 961     else if (strcmp(extension, "GL_KHR_shader_subgroup_shuffle_relative") == 0)
 962         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 963     else if (strcmp(extension, "GL_KHR_shader_subgroup_clustered") == 0)
 964         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 965     else if (strcmp(extension, "GL_KHR_shader_subgroup_quad") == 0)
 966         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 967     else if (strcmp(extension, "GL_NV_shader_subgroup_partitioned") == 0)
 968         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 969     else if (strcmp(extension, "GL_EXT_buffer_reference2") == 0 ||
 970              strcmp(extension, "GL_EXT_buffer_reference_uvec2") == 0)
 971         updateExtensionBehavior(line, "GL_EXT_buffer_reference", behaviorString);
 972     else if (strcmp(extension, "GL_NV_integer_cooperative_matrix") == 0)
 973         updateExtensionBehavior(line, "GL_NV_cooperative_matrix", behaviorString);
 974     // subgroup extended types to explicit types
 975     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int8") == 0)
 976         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int8", behaviorString);
 977     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int16") == 0)
 978         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int16", behaviorString);
 979     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int64") == 0)
 980         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int64", behaviorString);
 981     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_float16") == 0)
 982         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_float16", behaviorString);
 983
 984     // see if we need to update the numeric features
 985     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types") == 0)
 986         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types, on);
 987     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int8") == 0)
 988         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int8, on);
 989     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int16") == 0)
 990         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int16, on);
 991     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int32") == 0)
 992         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int32, on);
 993     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int64") == 0)
 994         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int64, on);
 995     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_float16") == 0)
 996         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_float16, on);
 997     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_float32") == 0)
 998         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_float32, on);
 999     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_float64") == 0)
1000         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_float64, on);
1001     else if (strcmp(extension, "GL_EXT_shader_implicit_conversions") == 0)
1002         intermediate.updateNumericFeature(TNumericFeatures::shader_implicit_conversions, on);
1003     else if (strcmp(extension, "GL_ARB_gpu_shader_fp64") == 0)
1004         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_fp64, on);
1005     else if (strcmp(extension, "GL_AMD_gpu_shader_int16") == 0)
1006         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_int16, on);
1007     else if (strcmp(extension, "GL_AMD_gpu_shader_half_float") == 0)
1008         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_half_float, on);
1009 }
1010
1011 void TParseVersions::updateExtensionBehavior(const char* extension, TExtensionBehavior behavior)
1012 {
1013     // Update the current behavior
1014     if (strcmp(extension, "all") == 0) {
1015         // special case for the 'all' extension; apply it to every extension present
1016         if (behavior == EBhRequire || behavior == EBhEnable) {
1017             error(getCurrentLoc(), "extension 'all' cannot have 'require' or 'enable' behavior", "#extension", "");
1018             return;
1019         } else {
1020             for (auto iter = extensionBehavior.begin(); iter != extensionBehavior.end(); ++iter)
1021                 iter->second = behavior;
1022         }
1023     } else {
1024         // Do the update for this single extension
1025         auto iter = extensionBehavior.find(TString(extension));
1026         if (iter == extensionBehavior.end()) {
1027             switch (behavior) {
1028             case EBhRequire:
1029                 error(getCurrentLoc(), "extension not supported:", "#extension", extension);
1030                 break;
1031             case EBhEnable:
1032             case EBhWarn:
1033             case EBhDisable:
1034                 warn(getCurrentLoc(), "extension not supported:", "#extension", extension);
1035                 break;
1036             default:
1037                 assert(0 && "unexpected behavior");
1038             }
1039
1040             return;
1041         } else {
1042             if (iter->second == EBhDisablePartial)
1043                 warn(getCurrentLoc(), "extension is only partially supported:", "#extension", extension);
1044             if (behavior != EBhDisable)
1045                 intermediate.addRequestedExtension(extension);
1046             iter->second = behavior;
1047         }
1048     }
1049 }
1050
1051 // Check if extension is used with correct shader stage.
1052 void TParseVersions::checkExtensionStage(const TSourceLoc& loc, const char * const extension)
1053 {
1054     // GL_NV_mesh_shader extension is only allowed in task/mesh shaders
1055     if (strcmp(extension, "GL_NV_mesh_shader") == 0) {
1056         requireStage(loc, (EShLanguageMask)(EShLangTaskNVMask | EShLangMeshNVMask | EShLangFragmentMask),
1057                      "#extension GL_NV_mesh_shader");
1058         profileRequires(loc, ECoreProfile, 450, 0, "#extension GL_NV_mesh_shader");
1059         profileRequires(loc, EEsProfile, 320, 0, "#extension GL_NV_mesh_shader");
1060     }
1061 }
1062
1063 // Check if extension has additional requirements
1064 void TParseVersions::extensionRequires(const TSourceLoc &loc, const char * const extension, const char *behaviorString)
1065 {
1066     bool isEnabled = false;
1067     if (!strcmp("require", behaviorString))
1068         isEnabled = true;
1069     else if (!strcmp("enable", behaviorString))
1070         isEnabled = true;
1071
1072     if (isEnabled) {
1073         unsigned int minSpvVersion = 0;
1074         auto iter = extensionMinSpv.find(TString(extension));
1075         if (iter != extensionMinSpv.end())
1076             minSpvVersion = iter->second;
1077         requireSpv(loc, extension, minSpvVersion);
1078     }
1079 }
1080
1081 // Call for any operation needing full GLSL integer data-type support.
1082 void TParseVersions::fullIntegerCheck(const TSourceLoc& loc, const char* op)
1083 {
1084     profileRequires(loc, ENoProfile, 130, nullptr, op);
1085     profileRequires(loc, EEsProfile, 300, nullptr, op);
1086 }
1087
1088 // Call for any operation needing GLSL double data-type support.
1089 void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op)
1090 {
1091
1092     //requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1093     if (language == EShLangVertex) {
1094         const char* const f64_Extensions[] = {E_GL_ARB_gpu_shader_fp64, E_GL_ARB_vertex_attrib_64bit};
1095         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, 2, f64_Extensions, op);
1096     } else
1097         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader_fp64, op);
1098 }
1099
1100 // Call for any operation needing GLSL float16 data-type support.
1101 void TParseVersions::float16Check(const TSourceLoc& loc, const char* op, bool builtIn)
1102 {
1103     if (!builtIn) {
1104         const char* const extensions[] = {
1105                                            E_GL_AMD_gpu_shader_half_float,
1106                                            E_GL_EXT_shader_explicit_arithmetic_types,
1107                                            E_GL_EXT_shader_explicit_arithmetic_types_float16};
1108         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1109     }
1110 }
1111
1112 bool TParseVersions::float16Arithmetic()
1113 {
1114     const char* const extensions[] = {
1115                                        E_GL_AMD_gpu_shader_half_float,
1116                                        E_GL_EXT_shader_explicit_arithmetic_types,
1117                                        E_GL_EXT_shader_explicit_arithmetic_types_float16};
1118     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
1119 }
1120
1121 bool TParseVersions::int16Arithmetic()
1122 {
1123     const char* const extensions[] = {
1124                                        E_GL_AMD_gpu_shader_int16,
1125                                        E_GL_EXT_shader_explicit_arithmetic_types,
1126                                        E_GL_EXT_shader_explicit_arithmetic_types_int16};
1127     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
1128 }
1129
1130 bool TParseVersions::int8Arithmetic()
1131 {
1132     const char* const extensions[] = {
1133                                        E_GL_EXT_shader_explicit_arithmetic_types,
1134                                        E_GL_EXT_shader_explicit_arithmetic_types_int8};
1135     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
1136 }
1137
1138 void TParseVersions::requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc)
1139 {
1140     TString combined;
1141     combined = op;
1142     combined += ": ";
1143     combined += featureDesc;
1144
1145     const char* const extensions[] = {
1146                                        E_GL_AMD_gpu_shader_half_float,
1147                                        E_GL_EXT_shader_explicit_arithmetic_types,
1148                                        E_GL_EXT_shader_explicit_arithmetic_types_float16};
1149     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
1150 }
1151
1152 void TParseVersions::requireInt16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc)
1153 {
1154     TString combined;
1155     combined = op;
1156     combined += ": ";
1157     combined += featureDesc;
1158
1159     const char* const extensions[] = {
1160                                        E_GL_AMD_gpu_shader_int16,
1161                                        E_GL_EXT_shader_explicit_arithmetic_types,
1162                                        E_GL_EXT_shader_explicit_arithmetic_types_int16};
1163     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
1164 }
1165
1166 void TParseVersions::requireInt8Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc)
1167 {
1168     TString combined;
1169     combined = op;
1170     combined += ": ";
1171     combined += featureDesc;
1172
1173     const char* const extensions[] = {
1174                                        E_GL_EXT_shader_explicit_arithmetic_types,
1175                                        E_GL_EXT_shader_explicit_arithmetic_types_int8};
1176     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
1177 }
1178
1179 void TParseVersions::float16ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1180 {
1181     if (!builtIn) {
1182         const char* const extensions[] = {
1183                                            E_GL_AMD_gpu_shader_half_float,
1184                                            E_GL_EXT_shader_16bit_storage,
1185                                            E_GL_EXT_shader_explicit_arithmetic_types,
1186                                            E_GL_EXT_shader_explicit_arithmetic_types_float16};
1187         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1188     }
1189 }
1190
1191 // Call for any operation needing GLSL float32 data-type support.
1192 void TParseVersions::explicitFloat32Check(const TSourceLoc& loc, const char* op, bool builtIn)
1193 {
1194     if (!builtIn) {
1195         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1196                                            E_GL_EXT_shader_explicit_arithmetic_types_float32};
1197         requireExtensions(loc, 2, extensions, op);
1198     }
1199 }
1200
1201 // Call for any operation needing GLSL float64 data-type support.
1202 void TParseVersions::explicitFloat64Check(const TSourceLoc& loc, const char* op, bool builtIn)
1203 {
1204     if (!builtIn) {
1205         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1206                                            E_GL_EXT_shader_explicit_arithmetic_types_float64};
1207         requireExtensions(loc, 2, extensions, op);
1208         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1209         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
1210     }
1211 }
1212
1213 // Call for any operation needing GLSL explicit int8 data-type support.
1214 void TParseVersions::explicitInt8Check(const TSourceLoc& loc, const char* op, bool builtIn)
1215 {
1216     if (! builtIn) {
1217         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1218                                            E_GL_EXT_shader_explicit_arithmetic_types_int8};
1219         requireExtensions(loc, 2, extensions, op);
1220     }
1221 }
1222
1223 // Call for any operation needing GLSL float16 opaque-type support
1224 void TParseVersions::float16OpaqueCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1225 {
1226     if (! builtIn) {
1227         requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float_fetch, op);
1228         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1229         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
1230     }
1231 }
1232
1233 // Call for any operation needing GLSL explicit int16 data-type support.
1234 void TParseVersions::explicitInt16Check(const TSourceLoc& loc, const char* op, bool builtIn)
1235 {
1236     if (! builtIn) {
1237         const char* const extensions[] = {
1238                                            E_GL_AMD_gpu_shader_int16,
1239                                            E_GL_EXT_shader_explicit_arithmetic_types,
1240                                            E_GL_EXT_shader_explicit_arithmetic_types_int16};
1241         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1242     }
1243 }
1244
1245 void TParseVersions::int16ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1246 {
1247     if (! builtIn) {
1248         const char* const extensions[] = {
1249                                            E_GL_AMD_gpu_shader_int16,
1250                                            E_GL_EXT_shader_16bit_storage,
1251                                            E_GL_EXT_shader_explicit_arithmetic_types,
1252                                            E_GL_EXT_shader_explicit_arithmetic_types_int16};
1253         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1254     }
1255 }
1256
1257 void TParseVersions::int8ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1258 {
1259     if (! builtIn) {
1260         const char* const extensions[] = {
1261                                            E_GL_EXT_shader_8bit_storage,
1262                                            E_GL_EXT_shader_explicit_arithmetic_types,
1263                                            E_GL_EXT_shader_explicit_arithmetic_types_int8};
1264         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1265     }
1266 }
1267
1268 // Call for any operation needing GLSL explicit int32 data-type support.
1269 void TParseVersions::explicitInt32Check(const TSourceLoc& loc, const char* op, bool builtIn)
1270 {
1271     if (! builtIn) {
1272         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1273                                            E_GL_EXT_shader_explicit_arithmetic_types_int32};
1274         requireExtensions(loc, 2, extensions, op);
1275     }
1276 }
1277
1278 // Call for any operation needing GLSL 64-bit integer data-type support.
1279 void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool builtIn)
1280 {
1281     if (! builtIn) {
1282         const char* const extensions[3] = {E_GL_ARB_gpu_shader_int64,
1283                                            E_GL_EXT_shader_explicit_arithmetic_types,
1284                                            E_GL_EXT_shader_explicit_arithmetic_types_int64};
1285         requireExtensions(loc, 3, extensions, op);
1286         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1287         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
1288     }
1289 }
1290
1291 void TParseVersions::fcoopmatCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1292 {
1293     if (!builtIn) {
1294         const char* const extensions[] = {E_GL_NV_cooperative_matrix};
1295         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1296     }
1297 }
1298
1299 void TParseVersions::intcoopmatCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1300 {
1301     if (!builtIn) {
1302         const char* const extensions[] = {E_GL_NV_integer_cooperative_matrix};
1303         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1304     }
1305 }
1306 #endif // GLSLANG_WEB
1307 // Call for any operation removed because SPIR-V is in use.
1308 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
1309 {
1310     if (spvVersion.spv != 0)
1311         error(loc, "not allowed when generating SPIR-V", op, "");
1312 }
1313
1314 // Call for any operation removed because Vulkan SPIR-V is being generated.
1315 void TParseVersions::vulkanRemoved(const TSourceLoc& loc, const char* op)
1316 {
1317     if (spvVersion.vulkan > 0 && !spvVersion.vulkanRelaxed)
1318         error(loc, "not allowed when using GLSL for Vulkan", op, "");
1319 }
1320
1321 // Call for any operation that requires Vulkan.
1322 void TParseVersions::requireVulkan(const TSourceLoc& loc, const char* op)
1323 {
1324 #ifndef GLSLANG_WEB
1325     if (spvVersion.vulkan == 0)
1326         error(loc, "only allowed when using GLSL for Vulkan", op, "");
1327 #endif
1328 }
1329
1330 // Call for any operation that requires SPIR-V.
1331 void TParseVersions::requireSpv(const TSourceLoc& loc, const char* op)
1332 {
1333 #ifndef GLSLANG_WEB
1334     if (spvVersion.spv == 0)
1335         error(loc, "only allowed when generating SPIR-V", op, "");
1336 #endif
1337 }
1338 void TParseVersions::requireSpv(const TSourceLoc& loc, const char *op, unsigned int version)
1339 {
1340 #ifndef GLSLANG_WEB
1341     if (spvVersion.spv < version)
1342         error(loc, "not supported for current targeted SPIR-V version", op, "");
1343 #endif
1344 }
1345
1346 } // end namespace glslang