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