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
 229     extensionBehavior[E_GL_KHR_shader_subgroup_basic]            = EBhDisable;
 230     extensionBehavior[E_GL_KHR_shader_subgroup_vote]             = EBhDisable;
 231     extensionBehavior[E_GL_KHR_shader_subgroup_arithmetic]       = EBhDisable;
 232     extensionBehavior[E_GL_KHR_shader_subgroup_ballot]           = EBhDisable;
 233     extensionBehavior[E_GL_KHR_shader_subgroup_shuffle]          = EBhDisable;
 234     extensionBehavior[E_GL_KHR_shader_subgroup_shuffle_relative] = EBhDisable;
 235     extensionBehavior[E_GL_KHR_shader_subgroup_clustered]        = EBhDisable;
 236     extensionBehavior[E_GL_KHR_shader_subgroup_quad]             = EBhDisable;
 237     extensionBehavior[E_GL_KHR_memory_scope_semantics]           = EBhDisable;
 238
 239     extensionBehavior[E_GL_EXT_shader_atomic_int64]              = EBhDisable;
 240
 241     extensionBehavior[E_GL_EXT_shader_non_constant_global_initializers] = EBhDisable;
 242     extensionBehavior[E_GL_EXT_shader_image_load_formatted]             = EBhDisable;
 243     extensionBehavior[E_GL_EXT_post_depth_coverage]                     = EBhDisable;
 244     extensionBehavior[E_GL_EXT_control_flow_attributes]                 = EBhDisable;
 245     extensionBehavior[E_GL_EXT_nonuniform_qualifier]                    = EBhDisable;
 246     extensionBehavior[E_GL_EXT_samplerless_texture_functions]           = EBhDisable;
 247     extensionBehavior[E_GL_EXT_scalar_block_layout]                     = EBhDisable;
 248     extensionBehavior[E_GL_EXT_fragment_invocation_density]             = EBhDisable;
 249     extensionBehavior[E_GL_EXT_buffer_reference]                        = EBhDisable;
 250     extensionBehavior[E_GL_EXT_buffer_reference2]                       = EBhDisable;
 251     extensionBehavior[E_GL_EXT_buffer_reference_uvec2]                  = EBhDisable;
 252     extensionBehavior[E_GL_EXT_demote_to_helper_invocation]             = EBhDisable;
 253     extensionBehavior[E_GL_EXT_debug_printf]                            = EBhDisable;
 254
 255     extensionBehavior[E_GL_EXT_shader_16bit_storage]                    = EBhDisable;
 256     extensionBehavior[E_GL_EXT_shader_8bit_storage]                     = EBhDisable;
 257     extensionBehavior[E_GL_EXT_subgroup_uniform_control_flow]           = EBhDisable;
 258
 259     // #line and #include
 260     extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive]          = EBhDisable;
 261     extensionBehavior[E_GL_GOOGLE_include_directive]                 = EBhDisable;
 262
 263     extensionBehavior[E_GL_AMD_shader_ballot]                        = EBhDisable;
 264     extensionBehavior[E_GL_AMD_shader_trinary_minmax]                = EBhDisable;
 265     extensionBehavior[E_GL_AMD_shader_explicit_vertex_parameter]     = EBhDisable;
 266     extensionBehavior[E_GL_AMD_gcn_shader]                           = EBhDisable;
 267     extensionBehavior[E_GL_AMD_gpu_shader_half_float]                = EBhDisable;
 268     extensionBehavior[E_GL_AMD_texture_gather_bias_lod]              = EBhDisable;
 269     extensionBehavior[E_GL_AMD_gpu_shader_int16]                     = EBhDisable;
 270     extensionBehavior[E_GL_AMD_shader_image_load_store_lod]          = EBhDisable;
 271     extensionBehavior[E_GL_AMD_shader_fragment_mask]                 = EBhDisable;
 272     extensionBehavior[E_GL_AMD_gpu_shader_half_float_fetch]          = EBhDisable;
 273
 274     extensionBehavior[E_GL_INTEL_shader_integer_functions2]          = EBhDisable;
 275
 276     extensionBehavior[E_GL_NV_sample_mask_override_coverage]         = EBhDisable;
 277     extensionBehavior[E_SPV_NV_geometry_shader_passthrough]          = EBhDisable;
 278     extensionBehavior[E_GL_NV_viewport_array2]                       = EBhDisable;
 279     extensionBehavior[E_GL_NV_stereo_view_rendering]                 = EBhDisable;
 280     extensionBehavior[E_GL_NVX_multiview_per_view_attributes]        = EBhDisable;
 281     extensionBehavior[E_GL_NV_shader_atomic_int64]                   = EBhDisable;
 282     extensionBehavior[E_GL_NV_conservative_raster_underestimation]   = EBhDisable;
 283     extensionBehavior[E_GL_NV_shader_noperspective_interpolation]    = EBhDisable;
 284     extensionBehavior[E_GL_NV_shader_subgroup_partitioned]           = EBhDisable;
 285     extensionBehavior[E_GL_NV_shading_rate_image]                    = EBhDisable;
 286     extensionBehavior[E_GL_NV_ray_tracing]                           = EBhDisable;
 287     extensionBehavior[E_GL_NV_ray_tracing_motion_blur]               = EBhDisable;
 288     extensionBehavior[E_GL_NV_fragment_shader_barycentric]           = EBhDisable;
 289     extensionBehavior[E_GL_NV_compute_shader_derivatives]            = EBhDisable;
 290     extensionBehavior[E_GL_NV_shader_texture_footprint]              = EBhDisable;
 291     extensionBehavior[E_GL_NV_mesh_shader]                           = EBhDisable;
 292
 293     extensionBehavior[E_GL_NV_cooperative_matrix]                    = EBhDisable;
 294     extensionBehavior[E_GL_NV_shader_sm_builtins]                    = EBhDisable;
 295     extensionBehavior[E_GL_NV_integer_cooperative_matrix]            = EBhDisable;
 296
 297     // AEP
 298     extensionBehavior[E_GL_ANDROID_extension_pack_es31a]             = EBhDisable;
 299     extensionBehavior[E_GL_KHR_blend_equation_advanced]              = EBhDisable;
 300     extensionBehavior[E_GL_OES_sample_variables]                     = EBhDisable;
 301     extensionBehavior[E_GL_OES_shader_image_atomic]                  = EBhDisable;
 302     extensionBehavior[E_GL_OES_shader_multisample_interpolation]     = EBhDisable;
 303     extensionBehavior[E_GL_OES_texture_storage_multisample_2d_array] = EBhDisable;
 304     extensionBehavior[E_GL_EXT_geometry_shader]                      = EBhDisable;
 305     extensionBehavior[E_GL_EXT_geometry_point_size]                  = EBhDisable;
 306     extensionBehavior[E_GL_EXT_gpu_shader5]                          = EBhDisable;
 307     extensionBehavior[E_GL_EXT_primitive_bounding_box]               = EBhDisable;
 308     extensionBehavior[E_GL_EXT_shader_io_blocks]                     = EBhDisable;
 309     extensionBehavior[E_GL_EXT_tessellation_shader]                  = EBhDisable;
 310     extensionBehavior[E_GL_EXT_tessellation_point_size]              = EBhDisable;
 311     extensionBehavior[E_GL_EXT_texture_buffer]                       = EBhDisable;
 312     extensionBehavior[E_GL_EXT_texture_cube_map_array]               = EBhDisable;
 313     extensionBehavior[E_GL_EXT_null_initializer]                     = EBhDisable;
 314
 315     // OES matching AEP
 316     extensionBehavior[E_GL_OES_geometry_shader]          = EBhDisable;
 317     extensionBehavior[E_GL_OES_geometry_point_size]      = EBhDisable;
 318     extensionBehavior[E_GL_OES_gpu_shader5]              = EBhDisable;
 319     extensionBehavior[E_GL_OES_primitive_bounding_box]   = EBhDisable;
 320     extensionBehavior[E_GL_OES_shader_io_blocks]         = EBhDisable;
 321     extensionBehavior[E_GL_OES_tessellation_shader]      = EBhDisable;
 322     extensionBehavior[E_GL_OES_tessellation_point_size]  = EBhDisable;
 323     extensionBehavior[E_GL_OES_texture_buffer]           = EBhDisable;
 324     extensionBehavior[E_GL_OES_texture_cube_map_array]   = EBhDisable;
 325     extensionBehavior[E_GL_EXT_shader_integer_mix]       = EBhDisable;
 326
 327     // EXT extensions
 328     extensionBehavior[E_GL_EXT_device_group]                = EBhDisable;
 329     extensionBehavior[E_GL_EXT_multiview]                   = EBhDisable;
 330     extensionBehavior[E_GL_EXT_shader_realtime_clock]       = EBhDisable;
 331     extensionBehavior[E_GL_EXT_ray_tracing]                 = EBhDisable;
 332     extensionBehavior[E_GL_EXT_ray_query]                   = EBhDisable;
 333     extensionBehavior[E_GL_EXT_ray_flags_primitive_culling] = EBhDisable;
 334     extensionBehavior[E_GL_EXT_blend_func_extended]         = EBhDisable;
 335     extensionBehavior[E_GL_EXT_shader_implicit_conversions] = EBhDisable;
 336     extensionBehavior[E_GL_EXT_fragment_shading_rate]       = EBhDisable;
 337     extensionBehavior[E_GL_EXT_shader_image_int64]   = EBhDisable;
 338     extensionBehavior[E_GL_EXT_terminate_invocation]        = EBhDisable;
 339     extensionBehavior[E_GL_EXT_shared_memory_block]         = EBhDisable;
 340     extensionBehavior[E_GL_EXT_spirv_intrinsics]            = EBhDisable;
 341
 342     // OVR extensions
 343     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
 344     extensionBehavior[E_GL_OVR_multiview2]               = EBhDisable;
 345
 346     // explicit types
 347     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types]         = EBhDisable;
 348     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int8]    = EBhDisable;
 349     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int16]   = EBhDisable;
 350     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int32]   = EBhDisable;
 351     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_int64]   = EBhDisable;
 352     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_float16] = EBhDisable;
 353     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_float32] = EBhDisable;
 354     extensionBehavior[E_GL_EXT_shader_explicit_arithmetic_types_float64] = EBhDisable;
 355
 356     // subgroup extended types
 357     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_int8]    = EBhDisable;
 358     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_int16]   = EBhDisable;
 359     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_int64]   = EBhDisable;
 360     extensionBehavior[E_GL_EXT_shader_subgroup_extended_types_float16] = EBhDisable;
 361     extensionBehavior[E_GL_EXT_shader_atomic_float]                    = EBhDisable;
 362     extensionBehavior[E_GL_EXT_shader_atomic_float2]                   = EBhDisable;
 363 }
 364
 365 #endif // GLSLANG_WEB
 366
 367 // Get code that is not part of a shared symbol table, is specific to this shader,
 368 // or needed by the preprocessor (which does not use a shared symbol table).
 369 void TParseVersions::getPreamble(std::string& preamble)
 370 {
 371     if (isEsProfile()) {
 372         preamble =
 373             "#define GL_ES 1\n"
 374             "#define GL_FRAGMENT_PRECISION_HIGH 1\n"
 375 #ifdef GLSLANG_WEB
 376             ;
 377 #else
 378             "#define GL_OES_texture_3D 1\n"
 379             "#define GL_OES_standard_derivatives 1\n"
 380             "#define GL_EXT_frag_depth 1\n"
 381             "#define GL_OES_EGL_image_external 1\n"
 382             "#define GL_OES_EGL_image_external_essl3 1\n"
 383             "#define GL_EXT_YUV_target 1\n"
 384             "#define GL_EXT_shader_texture_lod 1\n"
 385             "#define GL_EXT_shadow_samplers 1\n"
 386             "#define GL_EXT_fragment_shading_rate 1\n"
 387
 388             // AEP
 389             "#define GL_ANDROID_extension_pack_es31a 1\n"
 390             "#define GL_OES_sample_variables 1\n"
 391             "#define GL_OES_shader_image_atomic 1\n"
 392             "#define GL_OES_shader_multisample_interpolation 1\n"
 393             "#define GL_OES_texture_storage_multisample_2d_array 1\n"
 394             "#define GL_EXT_geometry_shader 1\n"
 395             "#define GL_EXT_geometry_point_size 1\n"
 396             "#define GL_EXT_gpu_shader5 1\n"
 397             "#define GL_EXT_primitive_bounding_box 1\n"
 398             "#define GL_EXT_shader_io_blocks 1\n"
 399             "#define GL_EXT_tessellation_shader 1\n"
 400             "#define GL_EXT_tessellation_point_size 1\n"
 401             "#define GL_EXT_texture_buffer 1\n"
 402             "#define GL_EXT_texture_cube_map_array 1\n"
 403             "#define GL_EXT_shader_implicit_conversions 1\n"
 404             "#define GL_EXT_shader_integer_mix 1\n"
 405             "#define GL_EXT_blend_func_extended 1\n"
 406
 407             // OES matching AEP
 408             "#define GL_OES_geometry_shader 1\n"
 409             "#define GL_OES_geometry_point_size 1\n"
 410             "#define GL_OES_gpu_shader5 1\n"
 411             "#define GL_OES_primitive_bounding_box 1\n"
 412             "#define GL_OES_shader_io_blocks 1\n"
 413             "#define GL_OES_tessellation_shader 1\n"
 414             "#define GL_OES_tessellation_point_size 1\n"
 415             "#define GL_OES_texture_buffer 1\n"
 416             "#define GL_OES_texture_cube_map_array 1\n"
 417             "#define GL_EXT_shader_non_constant_global_initializers 1\n"
 418             ;
 419
 420             if (version >= 300) {
 421                 preamble += "#define GL_NV_shader_noperspective_interpolation 1\n";
 422             }
 423             if (version >= 310) {
 424                 preamble += "#define GL_EXT_null_initializer 1\n";
 425                 preamble += "#define GL_EXT_subgroup_uniform_control_flow 1\n";
 426             }
 427
 428     } else { // !isEsProfile()
 429         preamble =
 430             "#define GL_FRAGMENT_PRECISION_HIGH 1\n"
 431             "#define GL_ARB_texture_rectangle 1\n"
 432             "#define GL_ARB_shading_language_420pack 1\n"
 433             "#define GL_ARB_texture_gather 1\n"
 434             "#define GL_ARB_gpu_shader5 1\n"
 435             "#define GL_ARB_separate_shader_objects 1\n"
 436             "#define GL_ARB_compute_shader 1\n"
 437             "#define GL_ARB_tessellation_shader 1\n"
 438             "#define GL_ARB_enhanced_layouts 1\n"
 439             "#define GL_ARB_texture_cube_map_array 1\n"
 440             "#define GL_ARB_texture_multisample 1\n"
 441             "#define GL_ARB_shader_texture_lod 1\n"
 442             "#define GL_ARB_explicit_attrib_location 1\n"
 443             "#define GL_ARB_explicit_uniform_location 1\n"
 444             "#define GL_ARB_shader_image_load_store 1\n"
 445             "#define GL_ARB_shader_atomic_counters 1\n"
 446             "#define GL_ARB_shader_draw_parameters 1\n"
 447             "#define GL_ARB_shader_group_vote 1\n"
 448             "#define GL_ARB_derivative_control 1\n"
 449             "#define GL_ARB_shader_texture_image_samples 1\n"
 450             "#define GL_ARB_viewport_array 1\n"
 451             "#define GL_ARB_gpu_shader_int64 1\n"
 452             "#define GL_ARB_gpu_shader_fp64 1\n"
 453             "#define GL_ARB_shader_ballot 1\n"
 454             "#define GL_ARB_sparse_texture2 1\n"
 455             "#define GL_ARB_sparse_texture_clamp 1\n"
 456             "#define GL_ARB_shader_stencil_export 1\n"
 457             "#define GL_ARB_sample_shading 1\n"
 458             "#define GL_ARB_shader_image_size 1\n"
 459             "#define GL_ARB_shading_language_packing 1\n"
 460 //            "#define GL_ARB_cull_distance 1\n"    // present for 4.5, but need extension control over block members
 461             "#define GL_ARB_post_depth_coverage 1\n"
 462             "#define GL_ARB_fragment_shader_interlock 1\n"
 463             "#define GL_ARB_uniform_buffer_object 1\n"
 464             "#define GL_ARB_shader_bit_encoding 1\n"
 465             "#define GL_ARB_shader_storage_buffer_object 1\n"
 466             "#define GL_ARB_texture_query_lod 1\n"
 467             "#define GL_ARB_vertex_attrib_64bit 1\n"
 468             "#define GL_EXT_shader_non_constant_global_initializers 1\n"
 469             "#define GL_EXT_shader_image_load_formatted 1\n"
 470             "#define GL_EXT_post_depth_coverage 1\n"
 471             "#define GL_EXT_control_flow_attributes 1\n"
 472             "#define GL_EXT_nonuniform_qualifier 1\n"
 473             "#define GL_EXT_shader_16bit_storage 1\n"
 474             "#define GL_EXT_shader_8bit_storage 1\n"
 475             "#define GL_EXT_samplerless_texture_functions 1\n"
 476             "#define GL_EXT_scalar_block_layout 1\n"
 477             "#define GL_EXT_fragment_invocation_density 1\n"
 478             "#define GL_EXT_buffer_reference 1\n"
 479             "#define GL_EXT_buffer_reference2 1\n"
 480             "#define GL_EXT_buffer_reference_uvec2 1\n"
 481             "#define GL_EXT_demote_to_helper_invocation 1\n"
 482             "#define GL_EXT_debug_printf 1\n"
 483             "#define GL_EXT_fragment_shading_rate 1\n"
 484             "#define GL_EXT_shared_memory_block 1\n"
 485
 486             // GL_KHR_shader_subgroup
 487             "#define GL_KHR_shader_subgroup_basic 1\n"
 488             "#define GL_KHR_shader_subgroup_vote 1\n"
 489             "#define GL_KHR_shader_subgroup_arithmetic 1\n"
 490             "#define GL_KHR_shader_subgroup_ballot 1\n"
 491             "#define GL_KHR_shader_subgroup_shuffle 1\n"
 492             "#define GL_KHR_shader_subgroup_shuffle_relative 1\n"
 493             "#define GL_KHR_shader_subgroup_clustered 1\n"
 494             "#define GL_KHR_shader_subgroup_quad 1\n"
 495
 496             "#define GL_EXT_shader_image_int64 1\n"
 497             "#define GL_EXT_shader_atomic_int64 1\n"
 498             "#define GL_EXT_shader_realtime_clock 1\n"
 499             "#define GL_EXT_ray_tracing 1\n"
 500             "#define GL_EXT_ray_query 1\n"
 501             "#define GL_EXT_ray_flags_primitive_culling 1\n"
 502             "#define GL_EXT_spirv_intrinsics 1\n"
 503
 504             "#define GL_AMD_shader_ballot 1\n"
 505             "#define GL_AMD_shader_trinary_minmax 1\n"
 506             "#define GL_AMD_shader_explicit_vertex_parameter 1\n"
 507             "#define GL_AMD_gcn_shader 1\n"
 508             "#define GL_AMD_gpu_shader_half_float 1\n"
 509             "#define GL_AMD_texture_gather_bias_lod 1\n"
 510             "#define GL_AMD_gpu_shader_int16 1\n"
 511             "#define GL_AMD_shader_image_load_store_lod 1\n"
 512             "#define GL_AMD_shader_fragment_mask 1\n"
 513             "#define GL_AMD_gpu_shader_half_float_fetch 1\n"
 514
 515             "#define GL_INTEL_shader_integer_functions2 1\n"
 516
 517             "#define GL_NV_sample_mask_override_coverage 1\n"
 518             "#define GL_NV_geometry_shader_passthrough 1\n"
 519             "#define GL_NV_viewport_array2 1\n"
 520             "#define GL_NV_shader_atomic_int64 1\n"
 521             "#define GL_NV_conservative_raster_underestimation 1\n"
 522             "#define GL_NV_shader_subgroup_partitioned 1\n"
 523             "#define GL_NV_shading_rate_image 1\n"
 524             "#define GL_NV_ray_tracing 1\n"
 525             "#define GL_NV_ray_tracing_motion_blur 1\n"
 526             "#define GL_NV_fragment_shader_barycentric 1\n"
 527             "#define GL_NV_compute_shader_derivatives 1\n"
 528             "#define GL_NV_shader_texture_footprint 1\n"
 529             "#define GL_NV_mesh_shader 1\n"
 530             "#define GL_NV_cooperative_matrix 1\n"
 531             "#define GL_NV_integer_cooperative_matrix 1\n"
 532
 533             "#define GL_EXT_shader_explicit_arithmetic_types 1\n"
 534             "#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"
 535             "#define GL_EXT_shader_explicit_arithmetic_types_int16 1\n"
 536             "#define GL_EXT_shader_explicit_arithmetic_types_int32 1\n"
 537             "#define GL_EXT_shader_explicit_arithmetic_types_int64 1\n"
 538             "#define GL_EXT_shader_explicit_arithmetic_types_float16 1\n"
 539             "#define GL_EXT_shader_explicit_arithmetic_types_float32 1\n"
 540             "#define GL_EXT_shader_explicit_arithmetic_types_float64 1\n"
 541
 542             "#define GL_EXT_shader_subgroup_extended_types_int8 1\n"
 543             "#define GL_EXT_shader_subgroup_extended_types_int16 1\n"
 544             "#define GL_EXT_shader_subgroup_extended_types_int64 1\n"
 545             "#define GL_EXT_shader_subgroup_extended_types_float16 1\n"
 546
 547             "#define GL_EXT_shader_atomic_float 1\n"
 548             "#define GL_EXT_shader_atomic_float2 1\n"
 549             ;
 550
 551         if (version >= 150) {
 552             // define GL_core_profile and GL_compatibility_profile
 553             preamble += "#define GL_core_profile 1\n";
 554
 555             if (profile == ECompatibilityProfile)
 556                 preamble += "#define GL_compatibility_profile 1\n";
 557         }
 558         if (version >= 140) {
 559             preamble += "#define GL_EXT_null_initializer 1\n";
 560             preamble += "#define GL_EXT_subgroup_uniform_control_flow 1\n";
 561         }
 562 #endif // GLSLANG_WEB
 563     }
 564
 565 #ifndef GLSLANG_WEB
 566     if ((!isEsProfile() && version >= 140) ||
 567         (isEsProfile() && version >= 310)) {
 568         preamble +=
 569             "#define GL_EXT_device_group 1\n"
 570             "#define GL_EXT_multiview 1\n"
 571             "#define GL_NV_shader_sm_builtins 1\n"
 572             ;
 573     }
 574
 575     if (version >= 300 /* both ES and non-ES */) {
 576         preamble +=
 577             "#define GL_OVR_multiview 1\n"
 578             "#define GL_OVR_multiview2 1\n"
 579             ;
 580     }
 581
 582     // #line and #include
 583     preamble +=
 584             "#define GL_GOOGLE_cpp_style_line_directive 1\n"
 585             "#define GL_GOOGLE_include_directive 1\n"
 586             "#define GL_KHR_blend_equation_advanced 1\n"
 587             ;
 588
 589     // other general extensions
 590     preamble +=
 591             "#define GL_EXT_terminate_invocation 1\n"
 592             ;
 593 #endif
 594
 595     // #define VULKAN XXXX
 596     const int numberBufSize = 12;
 597     char numberBuf[numberBufSize];
 598     if (spvVersion.vulkanGlsl > 0) {
 599         preamble += "#define VULKAN ";
 600         snprintf(numberBuf, numberBufSize, "%d", spvVersion.vulkanGlsl);
 601         preamble += numberBuf;
 602         preamble += "\n";
 603     }
 604
 605 #ifndef GLSLANG_WEB
 606     // #define GL_SPIRV XXXX
 607     if (spvVersion.openGl > 0) {
 608         preamble += "#define GL_SPIRV ";
 609         snprintf(numberBuf, numberBufSize, "%d", spvVersion.openGl);
 610         preamble += numberBuf;
 611         preamble += "\n";
 612     }
 613 #endif
 614
 615 #ifndef GLSLANG_WEB
 616     // GL_EXT_spirv_intrinsics
 617     if (!isEsProfile()) {
 618         switch (language) {
 619         case EShLangVertex:         preamble += "#define GL_VERTEX_SHADER 1 \n";                    break;
 620         case EShLangTessControl:    preamble += "#define GL_TESSELLATION_CONTROL_SHADER 1 \n";      break;
 621         case EShLangTessEvaluation: preamble += "#define GL_TESSELLATION_EVALUATION_SHADER 1 \n";   break;
 622         case EShLangGeometry:       preamble += "#define GL_GEOMETRY_SHADER 1 \n";                  break;
 623         case EShLangFragment:       preamble += "#define GL_FRAGMENT_SHADER 1 \n";                  break;
 624         case EShLangCompute:        preamble += "#define GL_COMPUTE_SHADER 1 \n";                   break;
 625         case EShLangRayGen:         preamble += "#define GL_RAY_GENERATION_SHADER_EXT 1 \n";        break;
 626         case EShLangIntersect:      preamble += "#define GL_INTERSECTION_SHADER_EXT 1 \n";          break;
 627         case EShLangAnyHit:         preamble += "#define GL_ANY_HIT_SHADER_EXT 1 \n";               break;
 628         case EShLangClosestHit:     preamble += "#define GL_CLOSEST_HIT_SHADER_EXT 1 \n";           break;
 629         case EShLangMiss:           preamble += "#define GL_MISS_SHADER_EXT 1 \n";                  break;
 630         case EShLangCallable:       preamble += "#define GL_CALLABLE_SHADER_EXT 1 \n";              break;
 631         case EShLangTaskNV:         preamble += "#define GL_TASK_SHADER_NV 1 \n";                   break;
 632         case EShLangMeshNV:         preamble += "#define GL_MESH_SHADER_NV 1 \n";                   break;
 633         default:                                                                                    break;
 634         }
 635     }
 636 #endif
 637 }
 638
 639 //
 640 // Map from stage enum to externally readable text name.
 641 //
 642 const char* StageName(EShLanguage stage)
 643 {
 644     switch(stage) {
 645     case EShLangVertex:         return "vertex";
 646     case EShLangFragment:       return "fragment";
 647     case EShLangCompute:        return "compute";
 648 #ifndef GLSLANG_WEB
 649     case EShLangTessControl:    return "tessellation control";
 650     case EShLangTessEvaluation: return "tessellation evaluation";
 651     case EShLangGeometry:       return "geometry";
 652     case EShLangRayGen:         return "ray-generation";
 653     case EShLangIntersect:      return "intersection";
 654     case EShLangAnyHit:         return "any-hit";
 655     case EShLangClosestHit:     return "closest-hit";
 656     case EShLangMiss:           return "miss";
 657     case EShLangCallable:       return "callable";
 658     case EShLangMeshNV:         return "mesh";
 659     case EShLangTaskNV:         return "task";
 660 #endif
 661     default:                    return "unknown stage";
 662     }
 663 }
 664
 665 //
 666 // When to use requireStage()
 667 //
 668 //     If only some stages support a feature.
 669 //
 670 // Operation: If the current stage is not present, give an error message.
 671 //
 672 void TParseVersions::requireStage(const TSourceLoc& loc, EShLanguageMask languageMask, const char* featureDesc)
 673 {
 674     if (((1 << language) & languageMask) == 0)
 675         error(loc, "not supported in this stage:", featureDesc, StageName(language));
 676 }
 677
 678 // If only one stage supports a feature, this can be called.  But, all supporting stages
 679 // must be specified with one call.
 680 void TParseVersions::requireStage(const TSourceLoc& loc, EShLanguage stage, const char* featureDesc)
 681 {
 682     requireStage(loc, static_cast<EShLanguageMask>(1 << stage), featureDesc);
 683 }
 684
 685 #ifndef GLSLANG_WEB
 686 //
 687 // When to use requireProfile():
 688 //
 689 //     Use if only some profiles support a feature.  However, if within a profile the feature
 690 //     is version or extension specific, follow this call with calls to profileRequires().
 691 //
 692 // Operation:  If the current profile is not one of the profileMask,
 693 // give an error message.
 694 //
 695 void TParseVersions::requireProfile(const TSourceLoc& loc, int profileMask, const char* featureDesc)
 696 {
 697     if (! (profile & profileMask))
 698         error(loc, "not supported with this profile:", featureDesc, ProfileName(profile));
 699 }
 700
 701 //
 702 // When to use profileRequires():
 703 //
 704 //     If a set of profiles have the same requirements for what version or extensions
 705 //     are needed to support a feature.
 706 //
 707 //     It must be called for each profile that needs protection.  Use requireProfile() first
 708 //     to reduce that set of profiles.
 709 //
 710 // Operation: Will issue warnings/errors based on the current profile, version, and extension
 711 // behaviors.  It only checks extensions when the current profile is one of the profileMask.
 712 //
 713 // A minVersion of 0 means no version of the profileMask support this in core,
 714 // the extension must be present.
 715 //
 716
 717 // entry point that takes multiple extensions
 718 void TParseVersions::profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, int numExtensions,
 719     const char* const extensions[], const char* featureDesc)
 720 {
 721     if (profile & profileMask) {
 722         bool okay = minVersion > 0 && version >= minVersion;
 723 #ifndef GLSLANG_WEB
 724         for (int i = 0; i < numExtensions; ++i) {
 725             switch (getExtensionBehavior(extensions[i])) {
 726             case EBhWarn:
 727                 infoSink.info.message(EPrefixWarning, ("extension " + TString(extensions[i]) + " is being used for " + featureDesc).c_str(), loc);
 728                 // fall through
 729             case EBhRequire:
 730             case EBhEnable:
 731                 okay = true;
 732                 break;
 733             default: break; // some compilers want this
 734             }
 735         }
 736 #endif
 737         if (! okay)
 738             error(loc, "not supported for this version or the enabled extensions", featureDesc, "");
 739     }
 740 }
 741
 742 // entry point for the above that takes a single extension
 743 void TParseVersions::profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, const char* extension,
 744     const char* featureDesc)
 745 {
 746     profileRequires(loc, profileMask, minVersion, extension ? 1 : 0, &extension, featureDesc);
 747 }
 748
 749 void TParseVersions::unimplemented(const TSourceLoc& loc, const char* featureDesc)
 750 {
 751     error(loc, "feature not yet implemented", featureDesc, "");
 752 }
 753
 754 //
 755 // Within a set of profiles, see if a feature is deprecated and give an error or warning based on whether
 756 // a future compatibility context is being use.
 757 //
 758 void TParseVersions::checkDeprecated(const TSourceLoc& loc, int profileMask, int depVersion, const char* featureDesc)
 759 {
 760     if (profile & profileMask) {
 761         if (version >= depVersion) {
 762             if (forwardCompatible)
 763                 error(loc, "deprecated, may be removed in future release", featureDesc, "");
 764             else if (! suppressWarnings())
 765                 infoSink.info.message(EPrefixWarning, (TString(featureDesc) + " deprecated in version " +
 766                                                        String(depVersion) + "; may be removed in future release").c_str(), loc);
 767         }
 768     }
 769 }
 770
 771 //
 772 // Within a set of profiles, see if a feature has now been removed and if so, give an error.
 773 // The version argument is the first version no longer having the feature.
 774 //
 775 void TParseVersions::requireNotRemoved(const TSourceLoc& loc, int profileMask, int removedVersion, const char* featureDesc)
 776 {
 777     if (profile & profileMask) {
 778         if (version >= removedVersion) {
 779             const int maxSize = 60;
 780             char buf[maxSize];
 781             snprintf(buf, maxSize, "%s profile; removed in version %d", ProfileName(profile), removedVersion);
 782             error(loc, "no longer supported in", featureDesc, buf);
 783         }
 784     }
 785 }
 786
 787 // Returns true if at least one of the extensions in the extensions parameter is requested. Otherwise, returns false.
 788 // Warns appropriately if the requested behavior of an extension is "warn".
 789 bool TParseVersions::checkExtensionsRequested(const TSourceLoc& loc, int numExtensions, const char* const extensions[], const char* featureDesc)
 790 {
 791     // First, see if any of the extensions are enabled
 792     for (int i = 0; i < numExtensions; ++i) {
 793         TExtensionBehavior behavior = getExtensionBehavior(extensions[i]);
 794         if (behavior == EBhEnable || behavior == EBhRequire)
 795             return true;
 796     }
 797
 798     // See if any extensions want to give a warning on use; give warnings for all such extensions
 799     bool warned = false;
 800     for (int i = 0; i < numExtensions; ++i) {
 801         TExtensionBehavior behavior = getExtensionBehavior(extensions[i]);
 802         if (behavior == EBhDisable && relaxedErrors()) {
 803             infoSink.info.message(EPrefixWarning, "The following extension must be enabled to use this feature:", loc);
 804             behavior = EBhWarn;
 805         }
 806         if (behavior == EBhWarn) {
 807             infoSink.info.message(EPrefixWarning, ("extension " + TString(extensions[i]) + " is being used for " + featureDesc).c_str(), loc);
 808             warned = true;
 809         }
 810     }
 811     if (warned)
 812         return true;
 813     return false;
 814 }
 815
 816 //
 817 // Use when there are no profile/version to check, it's just an error if one of the
 818 // extensions is not present.
 819 //
 820 void TParseVersions::requireExtensions(const TSourceLoc& loc, int numExtensions, const char* const extensions[],
 821     const char* featureDesc)
 822 {
 823     if (checkExtensionsRequested(loc, numExtensions, extensions, featureDesc))
 824         return;
 825
 826     // If we get this far, give errors explaining what extensions are needed
 827     if (numExtensions == 1)
 828         error(loc, "required extension not requested:", featureDesc, extensions[0]);
 829     else {
 830         error(loc, "required extension not requested:", featureDesc, "Possible extensions include:");
 831         for (int i = 0; i < numExtensions; ++i)
 832             infoSink.info.message(EPrefixNone, extensions[i]);
 833     }
 834 }
 835
 836 //
 837 // Use by preprocessor when there are no profile/version to check, it's just an error if one of the
 838 // extensions is not present.
 839 //
 840 void TParseVersions::ppRequireExtensions(const TSourceLoc& loc, int numExtensions, const char* const extensions[],
 841     const char* featureDesc)
 842 {
 843     if (checkExtensionsRequested(loc, numExtensions, extensions, featureDesc))
 844         return;
 845
 846     // If we get this far, give errors explaining what extensions are needed
 847     if (numExtensions == 1)
 848         ppError(loc, "required extension not requested:", featureDesc, extensions[0]);
 849     else {
 850         ppError(loc, "required extension not requested:", featureDesc, "Possible extensions include:");
 851         for (int i = 0; i < numExtensions; ++i)
 852             infoSink.info.message(EPrefixNone, extensions[i]);
 853     }
 854 }
 855
 856 TExtensionBehavior TParseVersions::getExtensionBehavior(const char* extension)
 857 {
 858     auto iter = extensionBehavior.find(TString(extension));
 859     if (iter == extensionBehavior.end())
 860         return EBhMissing;
 861     else
 862         return iter->second;
 863 }
 864
 865 // Returns true if the given extension is set to enable, require, or warn.
 866 bool TParseVersions::extensionTurnedOn(const char* const extension)
 867 {
 868       switch (getExtensionBehavior(extension)) {
 869       case EBhEnable:
 870       case EBhRequire:
 871       case EBhWarn:
 872           return true;
 873       default:
 874           break;
 875       }
 876       return false;
 877 }
 878 // See if any of the extensions are set to enable, require, or warn.
 879 bool TParseVersions::extensionsTurnedOn(int numExtensions, const char* const extensions[])
 880 {
 881     for (int i = 0; i < numExtensions; ++i) {
 882         if (extensionTurnedOn(extensions[i]))
 883             return true;
 884     }
 885     return false;
 886 }
 887
 888 //
 889 // Change the current state of an extension's behavior.
 890 //
 891 void TParseVersions::updateExtensionBehavior(int line, const char* extension, const char* behaviorString)
 892 {
 893     // Translate from text string of extension's behavior to an enum.
 894     TExtensionBehavior behavior = EBhDisable;
 895     if (! strcmp("require", behaviorString))
 896         behavior = EBhRequire;
 897     else if (! strcmp("enable", behaviorString))
 898         behavior = EBhEnable;
 899     else if (! strcmp("disable", behaviorString))
 900         behavior = EBhDisable;
 901     else if (! strcmp("warn", behaviorString))
 902         behavior = EBhWarn;
 903     else {
 904         error(getCurrentLoc(), "behavior not supported:", "#extension", behaviorString);
 905         return;
 906     }
 907     bool on = behavior != EBhDisable;
 908
 909     // check if extension is used with correct shader stage
 910     checkExtensionStage(getCurrentLoc(), extension);
 911
 912     // check if extension has additional requirements
 913     extensionRequires(getCurrentLoc(), extension, behaviorString);
 914
 915     // update the requested extension
 916     updateExtensionBehavior(extension, behavior);
 917
 918     // see if need to propagate to implicitly modified things
 919     if (strcmp(extension, "GL_ANDROID_extension_pack_es31a") == 0) {
 920         // to everything in AEP
 921         updateExtensionBehavior(line, "GL_KHR_blend_equation_advanced", behaviorString);
 922         updateExtensionBehavior(line, "GL_OES_sample_variables", behaviorString);
 923         updateExtensionBehavior(line, "GL_OES_shader_image_atomic", behaviorString);
 924         updateExtensionBehavior(line, "GL_OES_shader_multisample_interpolation", behaviorString);
 925         updateExtensionBehavior(line, "GL_OES_texture_storage_multisample_2d_array", behaviorString);
 926         updateExtensionBehavior(line, "GL_EXT_geometry_shader", behaviorString);
 927         updateExtensionBehavior(line, "GL_EXT_gpu_shader5", behaviorString);
 928         updateExtensionBehavior(line, "GL_EXT_primitive_bounding_box", behaviorString);
 929         updateExtensionBehavior(line, "GL_EXT_shader_io_blocks", behaviorString);
 930         updateExtensionBehavior(line, "GL_EXT_tessellation_shader", behaviorString);
 931         updateExtensionBehavior(line, "GL_EXT_texture_buffer", behaviorString);
 932         updateExtensionBehavior(line, "GL_EXT_texture_cube_map_array", behaviorString);
 933     }
 934     // geometry to io_blocks
 935     else if (strcmp(extension, "GL_EXT_geometry_shader") == 0)
 936         updateExtensionBehavior(line, "GL_EXT_shader_io_blocks", behaviorString);
 937     else if (strcmp(extension, "GL_OES_geometry_shader") == 0)
 938         updateExtensionBehavior(line, "GL_OES_shader_io_blocks", behaviorString);
 939     // tessellation to io_blocks
 940     else if (strcmp(extension, "GL_EXT_tessellation_shader") == 0)
 941         updateExtensionBehavior(line, "GL_EXT_shader_io_blocks", behaviorString);
 942     else if (strcmp(extension, "GL_OES_tessellation_shader") == 0)
 943         updateExtensionBehavior(line, "GL_OES_shader_io_blocks", behaviorString);
 944     else if (strcmp(extension, "GL_GOOGLE_include_directive") == 0)
 945         updateExtensionBehavior(line, "GL_GOOGLE_cpp_style_line_directive", behaviorString);
 946     // subgroup_* to subgroup_basic
 947     else if (strcmp(extension, "GL_KHR_shader_subgroup_vote") == 0)
 948         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 949     else if (strcmp(extension, "GL_KHR_shader_subgroup_arithmetic") == 0)
 950         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 951     else if (strcmp(extension, "GL_KHR_shader_subgroup_ballot") == 0)
 952         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 953     else if (strcmp(extension, "GL_KHR_shader_subgroup_shuffle") == 0)
 954         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 955     else if (strcmp(extension, "GL_KHR_shader_subgroup_shuffle_relative") == 0)
 956         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 957     else if (strcmp(extension, "GL_KHR_shader_subgroup_clustered") == 0)
 958         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 959     else if (strcmp(extension, "GL_KHR_shader_subgroup_quad") == 0)
 960         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 961     else if (strcmp(extension, "GL_NV_shader_subgroup_partitioned") == 0)
 962         updateExtensionBehavior(line, "GL_KHR_shader_subgroup_basic", behaviorString);
 963     else if (strcmp(extension, "GL_EXT_buffer_reference2") == 0 ||
 964              strcmp(extension, "GL_EXT_buffer_reference_uvec2") == 0)
 965         updateExtensionBehavior(line, "GL_EXT_buffer_reference", behaviorString);
 966     else if (strcmp(extension, "GL_NV_integer_cooperative_matrix") == 0)
 967         updateExtensionBehavior(line, "GL_NV_cooperative_matrix", behaviorString);
 968     // subgroup extended types to explicit types
 969     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int8") == 0)
 970         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int8", behaviorString);
 971     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int16") == 0)
 972         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int16", behaviorString);
 973     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int64") == 0)
 974         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int64", behaviorString);
 975     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_float16") == 0)
 976         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_float16", behaviorString);
 977
 978     // see if we need to update the numeric features
 979     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types") == 0)
 980         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types, on);
 981     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int8") == 0)
 982         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int8, on);
 983     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int16") == 0)
 984         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int16, on);
 985     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int32") == 0)
 986         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int32, on);
 987     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_int64") == 0)
 988         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_int64, on);
 989     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_float16") == 0)
 990         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_float16, on);
 991     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_float32") == 0)
 992         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_float32, on);
 993     else if (strcmp(extension, "GL_EXT_shader_explicit_arithmetic_types_float64") == 0)
 994         intermediate.updateNumericFeature(TNumericFeatures::shader_explicit_arithmetic_types_float64, on);
 995     else if (strcmp(extension, "GL_EXT_shader_implicit_conversions") == 0)
 996         intermediate.updateNumericFeature(TNumericFeatures::shader_implicit_conversions, on);
 997     else if (strcmp(extension, "GL_ARB_gpu_shader_fp64") == 0)
 998         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_fp64, on);
 999     else if (strcmp(extension, "GL_AMD_gpu_shader_int16") == 0)
1000         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_int16, on);
1001     else if (strcmp(extension, "GL_AMD_gpu_shader_half_float") == 0)
1002         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_half_float, on);
1003 }
1004
1005 void TParseVersions::updateExtensionBehavior(const char* extension, TExtensionBehavior behavior)
1006 {
1007     // Update the current behavior
1008     if (strcmp(extension, "all") == 0) {
1009         // special case for the 'all' extension; apply it to every extension present
1010         if (behavior == EBhRequire || behavior == EBhEnable) {
1011             error(getCurrentLoc(), "extension 'all' cannot have 'require' or 'enable' behavior", "#extension", "");
1012             return;
1013         } else {
1014             for (auto iter = extensionBehavior.begin(); iter != extensionBehavior.end(); ++iter)
1015                 iter->second = behavior;
1016         }
1017     } else {
1018         // Do the update for this single extension
1019         auto iter = extensionBehavior.find(TString(extension));
1020         if (iter == extensionBehavior.end()) {
1021             switch (behavior) {
1022             case EBhRequire:
1023                 error(getCurrentLoc(), "extension not supported:", "#extension", extension);
1024                 break;
1025             case EBhEnable:
1026             case EBhWarn:
1027             case EBhDisable:
1028                 warn(getCurrentLoc(), "extension not supported:", "#extension", extension);
1029                 break;
1030             default:
1031                 assert(0 && "unexpected behavior");
1032             }
1033
1034             return;
1035         } else {
1036             if (iter->second == EBhDisablePartial)
1037                 warn(getCurrentLoc(), "extension is only partially supported:", "#extension", extension);
1038             if (behavior != EBhDisable)
1039                 intermediate.addRequestedExtension(extension);
1040             iter->second = behavior;
1041         }
1042     }
1043 }
1044
1045 // Check if extension is used with correct shader stage.
1046 void TParseVersions::checkExtensionStage(const TSourceLoc& loc, const char * const extension)
1047 {
1048     // GL_NV_mesh_shader extension is only allowed in task/mesh shaders
1049     if (strcmp(extension, "GL_NV_mesh_shader") == 0) {
1050         requireStage(loc, (EShLanguageMask)(EShLangTaskNVMask | EShLangMeshNVMask | EShLangFragmentMask),
1051                      "#extension GL_NV_mesh_shader");
1052         profileRequires(loc, ECoreProfile, 450, 0, "#extension GL_NV_mesh_shader");
1053         profileRequires(loc, EEsProfile, 320, 0, "#extension GL_NV_mesh_shader");
1054     }
1055 }
1056
1057 // Check if extension has additional requirements
1058 void TParseVersions::extensionRequires(const TSourceLoc &loc, const char * const extension, const char *behaviorString)
1059 {
1060     bool isEnabled = false;
1061     if (!strcmp("require", behaviorString))
1062         isEnabled = true;
1063     else if (!strcmp("enable", behaviorString))
1064         isEnabled = true;
1065
1066     if (isEnabled) {
1067         unsigned int minSpvVersion = 0;
1068         auto iter = extensionMinSpv.find(TString(extension));
1069         if (iter != extensionMinSpv.end())
1070             minSpvVersion = iter->second;
1071         requireSpv(loc, extension, minSpvVersion);
1072     }
1073 }
1074
1075 // Call for any operation needing full GLSL integer data-type support.
1076 void TParseVersions::fullIntegerCheck(const TSourceLoc& loc, const char* op)
1077 {
1078     profileRequires(loc, ENoProfile, 130, nullptr, op);
1079     profileRequires(loc, EEsProfile, 300, nullptr, op);
1080 }
1081
1082 // Call for any operation needing GLSL double data-type support.
1083 void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op)
1084 {
1085
1086     //requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1087     if (language == EShLangVertex) {
1088         const char* const f64_Extensions[] = {E_GL_ARB_gpu_shader_fp64, E_GL_ARB_vertex_attrib_64bit};
1089         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, 2, f64_Extensions, op);
1090     } else
1091         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader_fp64, op);
1092 }
1093
1094 // Call for any operation needing GLSL float16 data-type support.
1095 void TParseVersions::float16Check(const TSourceLoc& loc, const char* op, bool builtIn)
1096 {
1097     if (!builtIn) {
1098         const char* const extensions[] = {
1099                                            E_GL_AMD_gpu_shader_half_float,
1100                                            E_GL_EXT_shader_explicit_arithmetic_types,
1101                                            E_GL_EXT_shader_explicit_arithmetic_types_float16};
1102         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1103     }
1104 }
1105
1106 bool TParseVersions::float16Arithmetic()
1107 {
1108     const char* const extensions[] = {
1109                                        E_GL_AMD_gpu_shader_half_float,
1110                                        E_GL_EXT_shader_explicit_arithmetic_types,
1111                                        E_GL_EXT_shader_explicit_arithmetic_types_float16};
1112     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
1113 }
1114
1115 bool TParseVersions::int16Arithmetic()
1116 {
1117     const char* const extensions[] = {
1118                                        E_GL_AMD_gpu_shader_int16,
1119                                        E_GL_EXT_shader_explicit_arithmetic_types,
1120                                        E_GL_EXT_shader_explicit_arithmetic_types_int16};
1121     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
1122 }
1123
1124 bool TParseVersions::int8Arithmetic()
1125 {
1126     const char* const extensions[] = {
1127                                        E_GL_EXT_shader_explicit_arithmetic_types,
1128                                        E_GL_EXT_shader_explicit_arithmetic_types_int8};
1129     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
1130 }
1131
1132 void TParseVersions::requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc)
1133 {
1134     TString combined;
1135     combined = op;
1136     combined += ": ";
1137     combined += featureDesc;
1138
1139     const char* const extensions[] = {
1140                                        E_GL_AMD_gpu_shader_half_float,
1141                                        E_GL_EXT_shader_explicit_arithmetic_types,
1142                                        E_GL_EXT_shader_explicit_arithmetic_types_float16};
1143     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
1144 }
1145
1146 void TParseVersions::requireInt16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc)
1147 {
1148     TString combined;
1149     combined = op;
1150     combined += ": ";
1151     combined += featureDesc;
1152
1153     const char* const extensions[] = {
1154                                        E_GL_AMD_gpu_shader_int16,
1155                                        E_GL_EXT_shader_explicit_arithmetic_types,
1156                                        E_GL_EXT_shader_explicit_arithmetic_types_int16};
1157     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
1158 }
1159
1160 void TParseVersions::requireInt8Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc)
1161 {
1162     TString combined;
1163     combined = op;
1164     combined += ": ";
1165     combined += featureDesc;
1166
1167     const char* const extensions[] = {
1168                                        E_GL_EXT_shader_explicit_arithmetic_types,
1169                                        E_GL_EXT_shader_explicit_arithmetic_types_int8};
1170     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
1171 }
1172
1173 void TParseVersions::float16ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1174 {
1175     if (!builtIn) {
1176         const char* const extensions[] = {
1177                                            E_GL_AMD_gpu_shader_half_float,
1178                                            E_GL_EXT_shader_16bit_storage,
1179                                            E_GL_EXT_shader_explicit_arithmetic_types,
1180                                            E_GL_EXT_shader_explicit_arithmetic_types_float16};
1181         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1182     }
1183 }
1184
1185 // Call for any operation needing GLSL float32 data-type support.
1186 void TParseVersions::explicitFloat32Check(const TSourceLoc& loc, const char* op, bool builtIn)
1187 {
1188     if (!builtIn) {
1189         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1190                                            E_GL_EXT_shader_explicit_arithmetic_types_float32};
1191         requireExtensions(loc, 2, extensions, op);
1192     }
1193 }
1194
1195 // Call for any operation needing GLSL float64 data-type support.
1196 void TParseVersions::explicitFloat64Check(const TSourceLoc& loc, const char* op, bool builtIn)
1197 {
1198     if (!builtIn) {
1199         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1200                                            E_GL_EXT_shader_explicit_arithmetic_types_float64};
1201         requireExtensions(loc, 2, extensions, op);
1202         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1203         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
1204     }
1205 }
1206
1207 // Call for any operation needing GLSL explicit int8 data-type support.
1208 void TParseVersions::explicitInt8Check(const TSourceLoc& loc, const char* op, bool builtIn)
1209 {
1210     if (! builtIn) {
1211         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1212                                            E_GL_EXT_shader_explicit_arithmetic_types_int8};
1213         requireExtensions(loc, 2, extensions, op);
1214     }
1215 }
1216
1217 // Call for any operation needing GLSL float16 opaque-type support
1218 void TParseVersions::float16OpaqueCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1219 {
1220     if (! builtIn) {
1221         requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float_fetch, op);
1222         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1223         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
1224     }
1225 }
1226
1227 // Call for any operation needing GLSL explicit int16 data-type support.
1228 void TParseVersions::explicitInt16Check(const TSourceLoc& loc, const char* op, bool builtIn)
1229 {
1230     if (! builtIn) {
1231         const char* const extensions[] = {
1232                                            E_GL_AMD_gpu_shader_int16,
1233                                            E_GL_EXT_shader_explicit_arithmetic_types,
1234                                            E_GL_EXT_shader_explicit_arithmetic_types_int16};
1235         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1236     }
1237 }
1238
1239 void TParseVersions::int16ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1240 {
1241     if (! builtIn) {
1242         const char* const extensions[] = {
1243                                            E_GL_AMD_gpu_shader_int16,
1244                                            E_GL_EXT_shader_16bit_storage,
1245                                            E_GL_EXT_shader_explicit_arithmetic_types,
1246                                            E_GL_EXT_shader_explicit_arithmetic_types_int16};
1247         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1248     }
1249 }
1250
1251 void TParseVersions::int8ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1252 {
1253     if (! builtIn) {
1254         const char* const extensions[] = {
1255                                            E_GL_EXT_shader_8bit_storage,
1256                                            E_GL_EXT_shader_explicit_arithmetic_types,
1257                                            E_GL_EXT_shader_explicit_arithmetic_types_int8};
1258         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1259     }
1260 }
1261
1262 // Call for any operation needing GLSL explicit int32 data-type support.
1263 void TParseVersions::explicitInt32Check(const TSourceLoc& loc, const char* op, bool builtIn)
1264 {
1265     if (! builtIn) {
1266         const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
1267                                            E_GL_EXT_shader_explicit_arithmetic_types_int32};
1268         requireExtensions(loc, 2, extensions, op);
1269     }
1270 }
1271
1272 // Call for any operation needing GLSL 64-bit integer data-type support.
1273 void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool builtIn)
1274 {
1275     if (! builtIn) {
1276         const char* const extensions[3] = {E_GL_ARB_gpu_shader_int64,
1277                                            E_GL_EXT_shader_explicit_arithmetic_types,
1278                                            E_GL_EXT_shader_explicit_arithmetic_types_int64};
1279         requireExtensions(loc, 3, extensions, op);
1280         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
1281         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
1282     }
1283 }
1284
1285 void TParseVersions::fcoopmatCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1286 {
1287     if (!builtIn) {
1288         const char* const extensions[] = {E_GL_NV_cooperative_matrix};
1289         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1290     }
1291 }
1292
1293 void TParseVersions::intcoopmatCheck(const TSourceLoc& loc, const char* op, bool builtIn)
1294 {
1295     if (!builtIn) {
1296         const char* const extensions[] = {E_GL_NV_integer_cooperative_matrix};
1297         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
1298     }
1299 }
1300 #endif // GLSLANG_WEB
1301 // Call for any operation removed because SPIR-V is in use.
1302 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
1303 {
1304     if (spvVersion.spv != 0)
1305         error(loc, "not allowed when generating SPIR-V", op, "");
1306 }
1307
1308 // Call for any operation removed because Vulkan SPIR-V is being generated.
1309 void TParseVersions::vulkanRemoved(const TSourceLoc& loc, const char* op)
1310 {
1311     if (spvVersion.vulkan > 0 && !spvVersion.vulkanRelaxed)
1312         error(loc, "not allowed when using GLSL for Vulkan", op, "");
1313 }
1314
1315 // Call for any operation that requires Vulkan.
1316 void TParseVersions::requireVulkan(const TSourceLoc& loc, const char* op)
1317 {
1318 #ifndef GLSLANG_WEB
1319     if (spvVersion.vulkan == 0)
1320         error(loc, "only allowed when using GLSL for Vulkan", op, "");
1321 #endif
1322 }
1323
1324 // Call for any operation that requires SPIR-V.
1325 void TParseVersions::requireSpv(const TSourceLoc& loc, const char* op)
1326 {
1327 #ifndef GLSLANG_WEB
1328     if (spvVersion.spv == 0)
1329         error(loc, "only allowed when generating SPIR-V", op, "");
1330 #endif
1331 }
1332 void TParseVersions::requireSpv(const TSourceLoc& loc, const char *op, unsigned int version)
1333 {
1334 #ifndef GLSLANG_WEB
1335     if (spvVersion.spv < version)
1336         error(loc, "not supported for current targeted SPIR-V version", op, "");
1337 #endif
1338 }
1339
1340 } // end namespace glslang