1/* 2 * Copyright © 2008, 2009 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23#include <inttypes.h> /* for PRIx64 macro */ 24#include <stdio.h> 25#include <stdarg.h> 26#include <string.h> 27#include <assert.h> 28 29#include "main/context.h" 30#include "main/debug_output.h" 31#include "main/formats.h" 32#include "main/shaderobj.h" 33#include "util/u_atomic.h" /* for p_atomic_cmpxchg */ 34#include "util/ralloc.h" 35#include "util/disk_cache.h" 36#include "util/mesa-sha1.h" 37#include "ast.h" 38#include "glsl_parser_extras.h" 39#include "glsl_parser.h" 40#include "ir_optimization.h" 41#include "loop_analysis.h" 42#include "builtin_functions.h" 43 44/** 45 * Format a short human-readable description of the given GLSL version. 46 */ 47const char * 48glsl_compute_version_string(void *mem_ctx, bool is_es, unsigned version) 49{ 50 return ralloc_asprintf(mem_ctx, "GLSL%s %d.%02d", is_es ? " ES" : "", 51 version / 100, version % 100); 52} 53 54 55static const unsigned known_desktop_glsl_versions[] = 56 { 110, 120, 130, 140, 150, 330, 400, 410, 420, 430, 440, 450, 460 }; 57static const unsigned known_desktop_gl_versions[] = 58 { 20, 21, 30, 31, 32, 33, 40, 41, 42, 43, 44, 45, 46 }; 59 60 61_mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx, 62 gl_shader_stage stage, 63 void *mem_ctx) 64 : ctx(_ctx), cs_input_local_size_specified(false), cs_input_local_size(), 65 switch_state(), warnings_enabled(true) 66{ 67 assert(stage < MESA_SHADER_STAGES); 68 this->stage = stage; 69 70 this->scanner = NULL; 71 this->translation_unit.make_empty(); 72 this->symbols = new(mem_ctx) glsl_symbol_table; 73 74 this->linalloc = linear_alloc_parent(this, 0); 75 76 this->info_log = ralloc_strdup(mem_ctx, ""); 77 this->error = false; 78 this->loop_nesting_ast = NULL; 79 80 this->uses_builtin_functions = false; 81 82 /* Set default language version and extensions */ 83 this->language_version = 110; 84 this->forced_language_version = ctx->Const.ForceGLSLVersion; 85 if (ctx->Const.GLSLZeroInit == 1) { 86 this->zero_init = (1u << ir_var_auto) | (1u << ir_var_temporary) | (1u << ir_var_shader_out); 87 } else if (ctx->Const.GLSLZeroInit == 2) { 88 this->zero_init = (1u << ir_var_auto) | (1u << ir_var_temporary) | (1u << ir_var_function_out); 89 } else { 90 this->zero_init = 0; 91 } 92 this->gl_version = 20; 93 this->compat_shader = true; 94 this->es_shader = false; 95 this->ARB_texture_rectangle_enable = true; 96 97 /* OpenGL ES 2.0 has different defaults from desktop GL. */ 98 if (ctx->API == API_OPENGLES2) { 99 this->language_version = 100; 100 this->es_shader = true; 101 this->ARB_texture_rectangle_enable = false; 102 } 103 104 this->extensions = &ctx->Extensions; 105 106 this->Const.MaxLights = ctx->Const.MaxLights; 107 this->Const.MaxClipPlanes = ctx->Const.MaxClipPlanes; 108 this->Const.MaxTextureUnits = ctx->Const.MaxTextureUnits; 109 this->Const.MaxTextureCoords = ctx->Const.MaxTextureCoordUnits; 110 this->Const.MaxVertexAttribs = ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs; 111 this->Const.MaxVertexUniformComponents = ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents; 112 this->Const.MaxVertexTextureImageUnits = ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits; 113 this->Const.MaxCombinedTextureImageUnits = ctx->Const.MaxCombinedTextureImageUnits; 114 this->Const.MaxTextureImageUnits = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits; 115 this->Const.MaxFragmentUniformComponents = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents; 116 this->Const.MinProgramTexelOffset = ctx->Const.MinProgramTexelOffset; 117 this->Const.MaxProgramTexelOffset = ctx->Const.MaxProgramTexelOffset; 118 119 this->Const.MaxDrawBuffers = ctx->Const.MaxDrawBuffers; 120 121 this->Const.MaxDualSourceDrawBuffers = ctx->Const.MaxDualSourceDrawBuffers; 122 123 /* 1.50 constants */ 124 this->Const.MaxVertexOutputComponents = ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents; 125 this->Const.MaxGeometryInputComponents = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxInputComponents; 126 this->Const.MaxGeometryOutputComponents = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxOutputComponents; 127 this->Const.MaxGeometryShaderInvocations = ctx->Const.MaxGeometryShaderInvocations; 128 this->Const.MaxFragmentInputComponents = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents; 129 this->Const.MaxGeometryTextureImageUnits = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits; 130 this->Const.MaxGeometryOutputVertices = ctx->Const.MaxGeometryOutputVertices; 131 this->Const.MaxGeometryTotalOutputComponents = ctx->Const.MaxGeometryTotalOutputComponents; 132 this->Const.MaxGeometryUniformComponents = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxUniformComponents; 133 134 this->Const.MaxVertexAtomicCounters = ctx->Const.Program[MESA_SHADER_VERTEX].MaxAtomicCounters; 135 this->Const.MaxTessControlAtomicCounters = ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxAtomicCounters; 136 this->Const.MaxTessEvaluationAtomicCounters = ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxAtomicCounters; 137 this->Const.MaxGeometryAtomicCounters = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxAtomicCounters; 138 this->Const.MaxFragmentAtomicCounters = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAtomicCounters; 139 this->Const.MaxComputeAtomicCounters = ctx->Const.Program[MESA_SHADER_COMPUTE].MaxAtomicCounters; 140 this->Const.MaxCombinedAtomicCounters = ctx->Const.MaxCombinedAtomicCounters; 141 this->Const.MaxAtomicBufferBindings = ctx->Const.MaxAtomicBufferBindings; 142 this->Const.MaxVertexAtomicCounterBuffers = 143 ctx->Const.Program[MESA_SHADER_VERTEX].MaxAtomicBuffers; 144 this->Const.MaxTessControlAtomicCounterBuffers = 145 ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxAtomicBuffers; 146 this->Const.MaxTessEvaluationAtomicCounterBuffers = 147 ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxAtomicBuffers; 148 this->Const.MaxGeometryAtomicCounterBuffers = 149 ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxAtomicBuffers; 150 this->Const.MaxFragmentAtomicCounterBuffers = 151 ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAtomicBuffers; 152 this->Const.MaxComputeAtomicCounterBuffers = 153 ctx->Const.Program[MESA_SHADER_COMPUTE].MaxAtomicBuffers; 154 this->Const.MaxCombinedAtomicCounterBuffers = 155 ctx->Const.MaxCombinedAtomicBuffers; 156 this->Const.MaxAtomicCounterBufferSize = 157 ctx->Const.MaxAtomicBufferSize; 158 159 /* ARB_enhanced_layouts constants */ 160 this->Const.MaxTransformFeedbackBuffers = ctx->Const.MaxTransformFeedbackBuffers; 161 this->Const.MaxTransformFeedbackInterleavedComponents = ctx->Const.MaxTransformFeedbackInterleavedComponents; 162 163 /* Compute shader constants */ 164 for (unsigned i = 0; i < ARRAY_SIZE(this->Const.MaxComputeWorkGroupCount); i++) 165 this->Const.MaxComputeWorkGroupCount[i] = ctx->Const.MaxComputeWorkGroupCount[i]; 166 for (unsigned i = 0; i < ARRAY_SIZE(this->Const.MaxComputeWorkGroupSize); i++) 167 this->Const.MaxComputeWorkGroupSize[i] = ctx->Const.MaxComputeWorkGroupSize[i]; 168 169 this->Const.MaxComputeTextureImageUnits = ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits; 170 this->Const.MaxComputeUniformComponents = ctx->Const.Program[MESA_SHADER_COMPUTE].MaxUniformComponents; 171 172 this->Const.MaxImageUnits = ctx->Const.MaxImageUnits; 173 this->Const.MaxCombinedShaderOutputResources = ctx->Const.MaxCombinedShaderOutputResources; 174 this->Const.MaxImageSamples = ctx->Const.MaxImageSamples; 175 this->Const.MaxVertexImageUniforms = ctx->Const.Program[MESA_SHADER_VERTEX].MaxImageUniforms; 176 this->Const.MaxTessControlImageUniforms = ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxImageUniforms; 177 this->Const.MaxTessEvaluationImageUniforms = ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxImageUniforms; 178 this->Const.MaxGeometryImageUniforms = ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxImageUniforms; 179 this->Const.MaxFragmentImageUniforms = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxImageUniforms; 180 this->Const.MaxComputeImageUniforms = ctx->Const.Program[MESA_SHADER_COMPUTE].MaxImageUniforms; 181 this->Const.MaxCombinedImageUniforms = ctx->Const.MaxCombinedImageUniforms; 182 183 /* ARB_viewport_array */ 184 this->Const.MaxViewports = ctx->Const.MaxViewports; 185 186 /* tessellation shader constants */ 187 this->Const.MaxPatchVertices = ctx->Const.MaxPatchVertices; 188 this->Const.MaxTessGenLevel = ctx->Const.MaxTessGenLevel; 189 this->Const.MaxTessControlInputComponents = ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxInputComponents; 190 this->Const.MaxTessControlOutputComponents = ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxOutputComponents; 191 this->Const.MaxTessControlTextureImageUnits = ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits; 192 this->Const.MaxTessEvaluationInputComponents = ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxInputComponents; 193 this->Const.MaxTessEvaluationOutputComponents = ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxOutputComponents; 194 this->Const.MaxTessEvaluationTextureImageUnits = ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits; 195 this->Const.MaxTessPatchComponents = ctx->Const.MaxTessPatchComponents; 196 this->Const.MaxTessControlTotalOutputComponents = ctx->Const.MaxTessControlTotalOutputComponents; 197 this->Const.MaxTessControlUniformComponents = ctx->Const.Program[MESA_SHADER_TESS_CTRL].MaxUniformComponents; 198 this->Const.MaxTessEvaluationUniformComponents = ctx->Const.Program[MESA_SHADER_TESS_EVAL].MaxUniformComponents; 199 200 /* GL 4.5 / OES_sample_variables */ 201 this->Const.MaxSamples = ctx->Const.MaxSamples; 202 203 this->current_function = NULL; 204 this->toplevel_ir = NULL; 205 this->found_return = false; 206 this->found_begin_interlock = false; 207 this->found_end_interlock = false; 208 this->all_invariant = false; 209 this->user_structures = NULL; 210 this->num_user_structures = 0; 211 this->num_subroutines = 0; 212 this->subroutines = NULL; 213 this->num_subroutine_types = 0; 214 this->subroutine_types = NULL; 215 216 /* supported_versions should be large enough to support the known desktop 217 * GLSL versions plus 4 GLES versions (ES 1.00, ES 3.00, ES 3.10, ES 3.20) 218 */ 219 STATIC_ASSERT((ARRAY_SIZE(known_desktop_glsl_versions) + 4) == 220 ARRAY_SIZE(this->supported_versions)); 221 222 /* Populate the list of supported GLSL versions */ 223 /* FINISHME: Once the OpenGL 3.0 'forward compatible' context or 224 * the OpenGL 3.2 Core context is supported, this logic will need 225 * change. Older versions of GLSL are no longer supported 226 * outside the compatibility contexts of 3.x. 227 */ 228 this->num_supported_versions = 0; 229 if (_mesa_is_desktop_gl(ctx)) { 230 for (unsigned i = 0; i < ARRAY_SIZE(known_desktop_glsl_versions); i++) { 231 if (known_desktop_glsl_versions[i] <= ctx->Const.GLSLVersion) { 232 this->supported_versions[this->num_supported_versions].ver 233 = known_desktop_glsl_versions[i]; 234 this->supported_versions[this->num_supported_versions].gl_ver 235 = known_desktop_gl_versions[i]; 236 this->supported_versions[this->num_supported_versions].es = false; 237 this->num_supported_versions++; 238 } 239 } 240 } 241 if (ctx->API == API_OPENGLES2 || ctx->Extensions.ARB_ES2_compatibility) { 242 this->supported_versions[this->num_supported_versions].ver = 100; 243 this->supported_versions[this->num_supported_versions].gl_ver = 20; 244 this->supported_versions[this->num_supported_versions].es = true; 245 this->num_supported_versions++; 246 } 247 if (_mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility) { 248 this->supported_versions[this->num_supported_versions].ver = 300; 249 this->supported_versions[this->num_supported_versions].gl_ver = 30; 250 this->supported_versions[this->num_supported_versions].es = true; 251 this->num_supported_versions++; 252 } 253 if (_mesa_is_gles31(ctx) || ctx->Extensions.ARB_ES3_1_compatibility) { 254 this->supported_versions[this->num_supported_versions].ver = 310; 255 this->supported_versions[this->num_supported_versions].gl_ver = 31; 256 this->supported_versions[this->num_supported_versions].es = true; 257 this->num_supported_versions++; 258 } 259 if ((ctx->API == API_OPENGLES2 && ctx->Version >= 32) || 260 ctx->Extensions.ARB_ES3_2_compatibility) { 261 this->supported_versions[this->num_supported_versions].ver = 320; 262 this->supported_versions[this->num_supported_versions].gl_ver = 32; 263 this->supported_versions[this->num_supported_versions].es = true; 264 this->num_supported_versions++; 265 } 266 267 /* Create a string for use in error messages to tell the user which GLSL 268 * versions are supported. 269 */ 270 char *supported = ralloc_strdup(this, ""); 271 for (unsigned i = 0; i < this->num_supported_versions; i++) { 272 unsigned ver = this->supported_versions[i].ver; 273 const char *const prefix = (i == 0) 274 ? "" 275 : ((i == this->num_supported_versions - 1) ? ", and " : ", "); 276 const char *const suffix = (this->supported_versions[i].es) ? " ES" : ""; 277 278 ralloc_asprintf_append(& supported, "%s%u.%02u%s", 279 prefix, 280 ver / 100, ver % 100, 281 suffix); 282 } 283 284 this->supported_version_string = supported; 285 286 if (ctx->Const.ForceGLSLExtensionsWarn) 287 _mesa_glsl_process_extension("all", NULL, "warn", NULL, this); 288 289 this->default_uniform_qualifier = new(this) ast_type_qualifier(); 290 this->default_uniform_qualifier->flags.q.shared = 1; 291 this->default_uniform_qualifier->flags.q.column_major = 1; 292 293 this->default_shader_storage_qualifier = new(this) ast_type_qualifier(); 294 this->default_shader_storage_qualifier->flags.q.shared = 1; 295 this->default_shader_storage_qualifier->flags.q.column_major = 1; 296 297 this->fs_uses_gl_fragcoord = false; 298 this->fs_redeclares_gl_fragcoord = false; 299 this->fs_origin_upper_left = false; 300 this->fs_pixel_center_integer = false; 301 this->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers = false; 302 303 this->gs_input_prim_type_specified = false; 304 this->tcs_output_vertices_specified = false; 305 this->gs_input_size = 0; 306 this->in_qualifier = new(this) ast_type_qualifier(); 307 this->out_qualifier = new(this) ast_type_qualifier(); 308 this->fs_early_fragment_tests = false; 309 this->fs_inner_coverage = false; 310 this->fs_post_depth_coverage = false; 311 this->fs_pixel_interlock_ordered = false; 312 this->fs_pixel_interlock_unordered = false; 313 this->fs_sample_interlock_ordered = false; 314 this->fs_sample_interlock_unordered = false; 315 this->fs_blend_support = 0; 316 memset(this->atomic_counter_offsets, 0, 317 sizeof(this->atomic_counter_offsets)); 318 this->allow_extension_directive_midshader = 319 ctx->Const.AllowGLSLExtensionDirectiveMidShader; 320 this->allow_glsl_120_subset_in_110 = 321 ctx->Const.AllowGLSL120SubsetIn110; 322 this->allow_builtin_variable_redeclaration = 323 ctx->Const.AllowGLSLBuiltinVariableRedeclaration; 324 this->ignore_write_to_readonly_var = 325 ctx->Const.GLSLIgnoreWriteToReadonlyVar; 326 327 this->cs_input_local_size_variable_specified = false; 328 329 /* ARB_bindless_texture */ 330 this->bindless_sampler_specified = false; 331 this->bindless_image_specified = false; 332 this->bound_sampler_specified = false; 333 this->bound_image_specified = false; 334 335 this->language_version = this->forced_language_version ? 336 this->forced_language_version : this->language_version; 337 set_valid_gl_and_glsl_versions(NULL); 338} 339 340/** 341 * Determine whether the current GLSL version is sufficiently high to support 342 * a certain feature, and generate an error message if it isn't. 343 * 344 * \param required_glsl_version and \c required_glsl_es_version are 345 * interpreted as they are in _mesa_glsl_parse_state::is_version(). 346 * 347 * \param locp is the parser location where the error should be reported. 348 * 349 * \param fmt (and additional arguments) constitute a printf-style error 350 * message to report if the version check fails. Information about the 351 * current and required GLSL versions will be appended. So, for example, if 352 * the GLSL version being compiled is 1.20, and check_version(130, 300, locp, 353 * "foo unsupported") is called, the error message will be "foo unsupported in 354 * GLSL 1.20 (GLSL 1.30 or GLSL 3.00 ES required)". 355 */ 356bool 357_mesa_glsl_parse_state::check_version(unsigned required_glsl_version, 358 unsigned required_glsl_es_version, 359 YYLTYPE *locp, const char *fmt, ...) 360{ 361 if (this->is_version(required_glsl_version, required_glsl_es_version)) 362 return true; 363 364 va_list args; 365 va_start(args, fmt); 366 char *problem = ralloc_vasprintf(this, fmt, args); 367 va_end(args); 368 const char *glsl_version_string 369 = glsl_compute_version_string(this, false, required_glsl_version); 370 const char *glsl_es_version_string 371 = glsl_compute_version_string(this, true, required_glsl_es_version); 372 const char *requirement_string = ""; 373 if (required_glsl_version && required_glsl_es_version) { 374 requirement_string = ralloc_asprintf(this, " (%s or %s required)", 375 glsl_version_string, 376 glsl_es_version_string); 377 } else if (required_glsl_version) { 378 requirement_string = ralloc_asprintf(this, " (%s required)", 379 glsl_version_string); 380 } else if (required_glsl_es_version) { 381 requirement_string = ralloc_asprintf(this, " (%s required)", 382 glsl_es_version_string); 383 } 384 _mesa_glsl_error(locp, this, "%s in %s%s", 385 problem, this->get_version_string(), 386 requirement_string); 387 388 return false; 389} 390 391/** 392 * This makes sure any GLSL versions defined or overridden are valid. If not it 393 * sets a valid value. 394 */ 395void 396_mesa_glsl_parse_state::set_valid_gl_and_glsl_versions(YYLTYPE *locp) 397{ 398 bool supported = false; 399 for (unsigned i = 0; i < this->num_supported_versions; i++) { 400 if (this->supported_versions[i].ver == this->language_version 401 && this->supported_versions[i].es == this->es_shader) { 402 this->gl_version = this->supported_versions[i].gl_ver; 403 supported = true; 404 break; 405 } 406 } 407 408 if (!supported) { 409 if (locp) { 410 _mesa_glsl_error(locp, this, "%s is not supported. " 411 "Supported versions are: %s", 412 this->get_version_string(), 413 this->supported_version_string); 414 } 415 416 /* On exit, the language_version must be set to a valid value. 417 * Later calls to _mesa_glsl_initialize_types will misbehave if 418 * the version is invalid. 419 */ 420 switch (this->ctx->API) { 421 case API_OPENGL_COMPAT: 422 case API_OPENGL_CORE: 423 this->language_version = this->ctx->Const.GLSLVersion; 424 break; 425 426 case API_OPENGLES: 427 FALLTHROUGH; 428 429 case API_OPENGLES2: 430 this->language_version = 100; 431 break; 432 } 433 } 434} 435 436/** 437 * Process a GLSL #version directive. 438 * 439 * \param version is the integer that follows the #version token. 440 * 441 * \param ident is a string identifier that follows the integer, if any is 442 * present. Otherwise NULL. 443 */ 444void 445_mesa_glsl_parse_state::process_version_directive(YYLTYPE *locp, int version, 446 const char *ident) 447{ 448 bool es_token_present = false; 449 bool compat_token_present = false; 450 if (ident) { 451 if (strcmp(ident, "es") == 0) { 452 es_token_present = true; 453 } else if (version >= 150) { 454 if (strcmp(ident, "core") == 0) { 455 /* Accept the token. There's no need to record that this is 456 * a core profile shader since that's the only profile we support. 457 */ 458 } else if (strcmp(ident, "compatibility") == 0) { 459 compat_token_present = true; 460 461 if (this->ctx->API != API_OPENGL_COMPAT) { 462 _mesa_glsl_error(locp, this, 463 "the compatibility profile is not supported"); 464 } 465 } else { 466 _mesa_glsl_error(locp, this, 467 "\"%s\" is not a valid shading language profile; " 468 "if present, it must be \"core\"", ident); 469 } 470 } else { 471 _mesa_glsl_error(locp, this, 472 "illegal text following version number"); 473 } 474 } 475 476 this->es_shader = es_token_present; 477 if (version == 100) { 478 if (es_token_present) { 479 _mesa_glsl_error(locp, this, 480 "GLSL 1.00 ES should be selected using " 481 "`#version 100'"); 482 } else { 483 this->es_shader = true; 484 } 485 } 486 487 if (this->es_shader) { 488 this->ARB_texture_rectangle_enable = false; 489 } 490 491 if (this->forced_language_version) 492 this->language_version = this->forced_language_version; 493 else 494 this->language_version = version; 495 496 this->compat_shader = compat_token_present || 497 (this->ctx->API == API_OPENGL_COMPAT && 498 this->language_version == 140) || 499 (!this->es_shader && this->language_version < 140); 500 501 set_valid_gl_and_glsl_versions(locp); 502} 503 504 505/* This helper function will append the given message to the shader's 506 info log and report it via GL_ARB_debug_output. Per that extension, 507 'type' is one of the enum values classifying the message, and 508 'id' is the implementation-defined ID of the given message. */ 509static void 510_mesa_glsl_msg(const YYLTYPE *locp, _mesa_glsl_parse_state *state, 511 GLenum type, const char *fmt, va_list ap) 512{ 513 bool error = (type == MESA_DEBUG_TYPE_ERROR); 514 GLuint msg_id = 0; 515 516 assert(state->info_log != NULL); 517 518 /* Get the offset that the new message will be written to. */ 519 int msg_offset = strlen(state->info_log); 520 521 if (locp->path) { 522 ralloc_asprintf_append(&state->info_log, "\"%s\"", locp->path); 523 } else { 524 ralloc_asprintf_append(&state->info_log, "%u", locp->source); 525 } 526 ralloc_asprintf_append(&state->info_log, ":%u(%u): %s: ", 527 locp->first_line, locp->first_column, 528 error ? "error" : "warning"); 529 530 ralloc_vasprintf_append(&state->info_log, fmt, ap); 531 532 const char *const msg = &state->info_log[msg_offset]; 533 struct gl_context *ctx = state->ctx; 534 535 /* Report the error via GL_ARB_debug_output. */ 536 _mesa_shader_debug(ctx, type, &msg_id, msg); 537 538 ralloc_strcat(&state->info_log, "\n"); 539} 540 541void 542_mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state, 543 const char *fmt, ...) 544{ 545 va_list ap; 546 547 state->error = true; 548 549 va_start(ap, fmt); 550 _mesa_glsl_msg(locp, state, MESA_DEBUG_TYPE_ERROR, fmt, ap); 551 va_end(ap); 552} 553 554 555void 556_mesa_glsl_warning(const YYLTYPE *locp, _mesa_glsl_parse_state *state, 557 const char *fmt, ...) 558{ 559 if (state->warnings_enabled) { 560 va_list ap; 561 562 va_start(ap, fmt); 563 _mesa_glsl_msg(locp, state, MESA_DEBUG_TYPE_OTHER, fmt, ap); 564 va_end(ap); 565 } 566} 567 568 569/** 570 * Enum representing the possible behaviors that can be specified in 571 * an #extension directive. 572 */ 573enum ext_behavior { 574 extension_disable, 575 extension_enable, 576 extension_require, 577 extension_warn 578}; 579 580/** 581 * Element type for _mesa_glsl_supported_extensions 582 */ 583struct _mesa_glsl_extension { 584 /** 585 * Name of the extension when referred to in a GLSL extension 586 * statement 587 */ 588 const char *name; 589 590 /** 591 * Whether this extension is a part of AEP 592 */ 593 bool aep; 594 595 /** 596 * Predicate that checks whether the relevant extension is available for 597 * this context. 598 */ 599 bool (*available_pred)(const struct gl_context *, 600 gl_api api, uint8_t version); 601 602 /** 603 * Flag in the _mesa_glsl_parse_state struct that should be set 604 * when this extension is enabled. 605 * 606 * See note in _mesa_glsl_extension::supported_flag about "pointer 607 * to member" types. 608 */ 609 bool _mesa_glsl_parse_state::* enable_flag; 610 611 /** 612 * Flag in the _mesa_glsl_parse_state struct that should be set 613 * when the shader requests "warn" behavior for this extension. 614 * 615 * See note in _mesa_glsl_extension::supported_flag about "pointer 616 * to member" types. 617 */ 618 bool _mesa_glsl_parse_state::* warn_flag; 619 620 621 bool compatible_with_state(const _mesa_glsl_parse_state *state, 622 gl_api api, uint8_t gl_version) const; 623 void set_flags(_mesa_glsl_parse_state *state, ext_behavior behavior) const; 624}; 625 626/** Checks if the context supports a user-facing extension */ 627#define EXT(name_str, driver_cap, ...) \ 628static UNUSED bool \ 629has_##name_str(const struct gl_context *ctx, gl_api api, uint8_t version) \ 630{ \ 631 return ctx->Extensions.driver_cap && (version >= \ 632 _mesa_extension_table[MESA_EXTENSION_##name_str].version[api]); \ 633} 634#include "main/extensions_table.h" 635#undef EXT 636 637#define EXT(NAME) \ 638 { "GL_" #NAME, false, has_##NAME, \ 639 &_mesa_glsl_parse_state::NAME##_enable, \ 640 &_mesa_glsl_parse_state::NAME##_warn } 641 642#define EXT_AEP(NAME) \ 643 { "GL_" #NAME, true, has_##NAME, \ 644 &_mesa_glsl_parse_state::NAME##_enable, \ 645 &_mesa_glsl_parse_state::NAME##_warn } 646 647/** 648 * Table of extensions that can be enabled/disabled within a shader, 649 * and the conditions under which they are supported. 650 */ 651static const _mesa_glsl_extension _mesa_glsl_supported_extensions[] = { 652 /* ARB extensions go here, sorted alphabetically. 653 */ 654 EXT(ARB_ES3_1_compatibility), 655 EXT(ARB_ES3_2_compatibility), 656 EXT(ARB_arrays_of_arrays), 657 EXT(ARB_bindless_texture), 658 EXT(ARB_compatibility), 659 EXT(ARB_compute_shader), 660 EXT(ARB_compute_variable_group_size), 661 EXT(ARB_conservative_depth), 662 EXT(ARB_cull_distance), 663 EXT(ARB_derivative_control), 664 EXT(ARB_draw_buffers), 665 EXT(ARB_draw_instanced), 666 EXT(ARB_enhanced_layouts), 667 EXT(ARB_explicit_attrib_location), 668 EXT(ARB_explicit_uniform_location), 669 EXT(ARB_fragment_coord_conventions), 670 EXT(ARB_fragment_layer_viewport), 671 EXT(ARB_fragment_shader_interlock), 672 EXT(ARB_gpu_shader5), 673 EXT(ARB_gpu_shader_fp64), 674 EXT(ARB_gpu_shader_int64), 675 EXT(ARB_post_depth_coverage), 676 EXT(ARB_sample_shading), 677 EXT(ARB_separate_shader_objects), 678 EXT(ARB_shader_atomic_counter_ops), 679 EXT(ARB_shader_atomic_counters), 680 EXT(ARB_shader_ballot), 681 EXT(ARB_shader_bit_encoding), 682 EXT(ARB_shader_clock), 683 EXT(ARB_shader_draw_parameters), 684 EXT(ARB_shader_group_vote), 685 EXT(ARB_shader_image_load_store), 686 EXT(ARB_shader_image_size), 687 EXT(ARB_shader_precision), 688 EXT(ARB_shader_stencil_export), 689 EXT(ARB_shader_storage_buffer_object), 690 EXT(ARB_shader_subroutine), 691 EXT(ARB_shader_texture_image_samples), 692 EXT(ARB_shader_texture_lod), 693 EXT(ARB_shader_viewport_layer_array), 694 EXT(ARB_shading_language_420pack), 695 EXT(ARB_shading_language_include), 696 EXT(ARB_shading_language_packing), 697 EXT(ARB_tessellation_shader), 698 EXT(ARB_texture_cube_map_array), 699 EXT(ARB_texture_gather), 700 EXT(ARB_texture_multisample), 701 EXT(ARB_texture_query_levels), 702 EXT(ARB_texture_query_lod), 703 EXT(ARB_texture_rectangle), 704 EXT(ARB_uniform_buffer_object), 705 EXT(ARB_vertex_attrib_64bit), 706 EXT(ARB_viewport_array), 707 708 /* KHR extensions go here, sorted alphabetically. 709 */ 710 EXT_AEP(KHR_blend_equation_advanced), 711 712 /* OES extensions go here, sorted alphabetically. 713 */ 714 EXT(OES_EGL_image_external), 715 EXT(OES_EGL_image_external_essl3), 716 EXT(OES_geometry_point_size), 717 EXT(OES_geometry_shader), 718 EXT(OES_gpu_shader5), 719 EXT(OES_primitive_bounding_box), 720 EXT_AEP(OES_sample_variables), 721 EXT_AEP(OES_shader_image_atomic), 722 EXT(OES_shader_io_blocks), 723 EXT_AEP(OES_shader_multisample_interpolation), 724 EXT(OES_standard_derivatives), 725 EXT(OES_tessellation_point_size), 726 EXT(OES_tessellation_shader), 727 EXT(OES_texture_3D), 728 EXT(OES_texture_buffer), 729 EXT(OES_texture_cube_map_array), 730 EXT_AEP(OES_texture_storage_multisample_2d_array), 731 EXT(OES_viewport_array), 732 733 /* All other extensions go here, sorted alphabetically. 734 */ 735 EXT(AMD_conservative_depth), 736 EXT(AMD_gpu_shader_int64), 737 EXT(AMD_shader_stencil_export), 738 EXT(AMD_shader_trinary_minmax), 739 EXT(AMD_texture_texture4), 740 EXT(AMD_vertex_shader_layer), 741 EXT(AMD_vertex_shader_viewport_index), 742 EXT(ANDROID_extension_pack_es31a), 743 EXT(EXT_blend_func_extended), 744 EXT(EXT_demote_to_helper_invocation), 745 EXT(EXT_frag_depth), 746 EXT(EXT_draw_buffers), 747 EXT(EXT_draw_instanced), 748 EXT(EXT_clip_cull_distance), 749 EXT(EXT_geometry_point_size), 750 EXT_AEP(EXT_geometry_shader), 751 EXT(EXT_gpu_shader4), 752 EXT_AEP(EXT_gpu_shader5), 753 EXT_AEP(EXT_primitive_bounding_box), 754 EXT(EXT_separate_shader_objects), 755 EXT(EXT_shader_framebuffer_fetch), 756 EXT(EXT_shader_framebuffer_fetch_non_coherent), 757 EXT(EXT_shader_group_vote), 758 EXT(EXT_shader_image_load_formatted), 759 EXT(EXT_shader_image_load_store), 760 EXT(EXT_shader_implicit_conversions), 761 EXT(EXT_shader_integer_mix), 762 EXT_AEP(EXT_shader_io_blocks), 763 EXT(EXT_shader_samples_identical), 764 EXT(EXT_tessellation_point_size), 765 EXT_AEP(EXT_tessellation_shader), 766 EXT(EXT_texture_array), 767 EXT_AEP(EXT_texture_buffer), 768 EXT_AEP(EXT_texture_cube_map_array), 769 EXT(EXT_texture_query_lod), 770 EXT(EXT_texture_shadow_lod), 771 EXT(INTEL_conservative_rasterization), 772 EXT(INTEL_shader_atomic_float_minmax), 773 EXT(INTEL_shader_integer_functions2), 774 EXT(MESA_shader_integer_functions), 775 EXT(NV_compute_shader_derivatives), 776 EXT(NV_fragment_shader_interlock), 777 EXT(NV_image_formats), 778 EXT(NV_shader_atomic_float), 779 EXT(NV_shader_atomic_int64), 780 EXT(NV_viewport_array2), 781}; 782 783#undef EXT 784 785 786/** 787 * Determine whether a given extension is compatible with the target, 788 * API, and extension information in the current parser state. 789 */ 790bool _mesa_glsl_extension::compatible_with_state( 791 const _mesa_glsl_parse_state *state, gl_api api, uint8_t gl_version) const 792{ 793 return this->available_pred(state->ctx, api, gl_version); 794} 795 796/** 797 * Set the appropriate flags in the parser state to establish the 798 * given behavior for this extension. 799 */ 800void _mesa_glsl_extension::set_flags(_mesa_glsl_parse_state *state, 801 ext_behavior behavior) const 802{ 803 /* Note: the ->* operator indexes into state by the 804 * offsets this->enable_flag and this->warn_flag. See 805 * _mesa_glsl_extension::supported_flag for more info. 806 */ 807 state->*(this->enable_flag) = (behavior != extension_disable); 808 state->*(this->warn_flag) = (behavior == extension_warn); 809} 810 811/** 812 * Find an extension by name in _mesa_glsl_supported_extensions. If 813 * the name is not found, return NULL. 814 */ 815static const _mesa_glsl_extension *find_extension(const char *name) 816{ 817 for (unsigned i = 0; i < ARRAY_SIZE(_mesa_glsl_supported_extensions); ++i) { 818 if (strcmp(name, _mesa_glsl_supported_extensions[i].name) == 0) { 819 return &_mesa_glsl_supported_extensions[i]; 820 } 821 } 822 return NULL; 823} 824 825bool 826_mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp, 827 const char *behavior_string, YYLTYPE *behavior_locp, 828 _mesa_glsl_parse_state *state) 829{ 830 uint8_t gl_version = state->ctx->Extensions.Version; 831 gl_api api = state->ctx->API; 832 ext_behavior behavior; 833 if (strcmp(behavior_string, "warn") == 0) { 834 behavior = extension_warn; 835 } else if (strcmp(behavior_string, "require") == 0) { 836 behavior = extension_require; 837 } else if (strcmp(behavior_string, "enable") == 0) { 838 behavior = extension_enable; 839 } else if (strcmp(behavior_string, "disable") == 0) { 840 behavior = extension_disable; 841 } else { 842 _mesa_glsl_error(behavior_locp, state, 843 "unknown extension behavior `%s'", 844 behavior_string); 845 return false; 846 } 847 848 /* If we're in a desktop context but with an ES shader, use an ES API enum 849 * to verify extension availability. 850 */ 851 if (state->es_shader && api != API_OPENGLES2) 852 api = API_OPENGLES2; 853 /* Use the language-version derived GL version to extension checks, unless 854 * we're using meta, which sets the version to the max. 855 */ 856 if (gl_version != 0xff) 857 gl_version = state->gl_version; 858 859 if (strcmp(name, "all") == 0) { 860 if ((behavior == extension_enable) || (behavior == extension_require)) { 861 _mesa_glsl_error(name_locp, state, "cannot %s all extensions", 862 (behavior == extension_enable) 863 ? "enable" : "require"); 864 return false; 865 } else { 866 for (unsigned i = 0; 867 i < ARRAY_SIZE(_mesa_glsl_supported_extensions); ++i) { 868 const _mesa_glsl_extension *extension 869 = &_mesa_glsl_supported_extensions[i]; 870 if (extension->compatible_with_state(state, api, gl_version)) { 871 _mesa_glsl_supported_extensions[i].set_flags(state, behavior); 872 } 873 } 874 } 875 } else { 876 const _mesa_glsl_extension *extension = find_extension(name); 877 if (extension && extension->compatible_with_state(state, api, gl_version)) { 878 extension->set_flags(state, behavior); 879 if (extension->available_pred == has_ANDROID_extension_pack_es31a) { 880 for (unsigned i = 0; 881 i < ARRAY_SIZE(_mesa_glsl_supported_extensions); ++i) { 882 const _mesa_glsl_extension *extension = 883 &_mesa_glsl_supported_extensions[i]; 884 885 if (!extension->aep) 886 continue; 887 /* AEP should not be enabled if all of the sub-extensions can't 888 * also be enabled. This is not the proper layer to do such 889 * error-checking though. 890 */ 891 assert(extension->compatible_with_state(state, api, gl_version)); 892 extension->set_flags(state, behavior); 893 } 894 } 895 } else { 896 static const char fmt[] = "extension `%s' unsupported in %s shader"; 897 898 if (behavior == extension_require) { 899 _mesa_glsl_error(name_locp, state, fmt, 900 name, _mesa_shader_stage_to_string(state->stage)); 901 return false; 902 } else { 903 _mesa_glsl_warning(name_locp, state, fmt, 904 name, _mesa_shader_stage_to_string(state->stage)); 905 } 906 } 907 } 908 909 return true; 910} 911 912 913/** 914 * Recurses through <type> and <expr> if <expr> is an aggregate initializer 915 * and sets <expr>'s <constructor_type> field to <type>. Gives later functions 916 * (process_array_constructor, et al) sufficient information to do type 917 * checking. 918 * 919 * Operates on assignments involving an aggregate initializer. E.g., 920 * 921 * vec4 pos = {1.0, -1.0, 0.0, 1.0}; 922 * 923 * or more ridiculously, 924 * 925 * struct S { 926 * vec4 v[2]; 927 * }; 928 * 929 * struct { 930 * S a[2], b; 931 * int c; 932 * } aggregate = { 933 * { 934 * { 935 * { 936 * {1.0, 2.0, 3.0, 4.0}, // a[0].v[0] 937 * {5.0, 6.0, 7.0, 8.0} // a[0].v[1] 938 * } // a[0].v 939 * }, // a[0] 940 * { 941 * { 942 * {1.0, 2.0, 3.0, 4.0}, // a[1].v[0] 943 * {5.0, 6.0, 7.0, 8.0} // a[1].v[1] 944 * } // a[1].v 945 * } // a[1] 946 * }, // a 947 * { 948 * { 949 * {1.0, 2.0, 3.0, 4.0}, // b.v[0] 950 * {5.0, 6.0, 7.0, 8.0} // b.v[1] 951 * } // b.v 952 * }, // b 953 * 4 // c 954 * }; 955 * 956 * This pass is necessary because the right-hand side of <type> e = { ... } 957 * doesn't contain sufficient information to determine if the types match. 958 */ 959void 960_mesa_ast_set_aggregate_type(const glsl_type *type, 961 ast_expression *expr) 962{ 963 ast_aggregate_initializer *ai = (ast_aggregate_initializer *)expr; 964 ai->constructor_type = type; 965 966 /* If the aggregate is an array, recursively set its elements' types. */ 967 if (type->is_array()) { 968 /* Each array element has the type type->fields.array. 969 * 970 * E.g., if <type> if struct S[2] we want to set each element's type to 971 * struct S. 972 */ 973 for (exec_node *expr_node = ai->expressions.get_head_raw(); 974 !expr_node->is_tail_sentinel(); 975 expr_node = expr_node->next) { 976 ast_expression *expr = exec_node_data(ast_expression, expr_node, 977 link); 978 979 if (expr->oper == ast_aggregate) 980 _mesa_ast_set_aggregate_type(type->fields.array, expr); 981 } 982 983 /* If the aggregate is a struct, recursively set its fields' types. */ 984 } else if (type->is_struct()) { 985 exec_node *expr_node = ai->expressions.get_head_raw(); 986 987 /* Iterate through the struct's fields. */ 988 for (unsigned i = 0; !expr_node->is_tail_sentinel() && i < type->length; 989 i++, expr_node = expr_node->next) { 990 ast_expression *expr = exec_node_data(ast_expression, expr_node, 991 link); 992 993 if (expr->oper == ast_aggregate) { 994 _mesa_ast_set_aggregate_type(type->fields.structure[i].type, expr); 995 } 996 } 997 /* If the aggregate is a matrix, set its columns' types. */ 998 } else if (type->is_matrix()) { 999 for (exec_node *expr_node = ai->expressions.get_head_raw(); 1000 !expr_node->is_tail_sentinel(); 1001 expr_node = expr_node->next) { 1002 ast_expression *expr = exec_node_data(ast_expression, expr_node, 1003 link); 1004 1005 if (expr->oper == ast_aggregate) 1006 _mesa_ast_set_aggregate_type(type->column_type(), expr); 1007 } 1008 } 1009} 1010 1011void 1012_mesa_ast_process_interface_block(YYLTYPE *locp, 1013 _mesa_glsl_parse_state *state, 1014 ast_interface_block *const block, 1015 const struct ast_type_qualifier &q) 1016{ 1017 if (q.flags.q.buffer) { 1018 if (!state->has_shader_storage_buffer_objects()) { 1019 _mesa_glsl_error(locp, state, 1020 "#version 430 / GL_ARB_shader_storage_buffer_object " 1021 "required for defining shader storage blocks"); 1022 } else if (state->ARB_shader_storage_buffer_object_warn) { 1023 _mesa_glsl_warning(locp, state, 1024 "#version 430 / GL_ARB_shader_storage_buffer_object " 1025 "required for defining shader storage blocks"); 1026 } 1027 } else if (q.flags.q.uniform) { 1028 if (!state->has_uniform_buffer_objects()) { 1029 _mesa_glsl_error(locp, state, 1030 "#version 140 / GL_ARB_uniform_buffer_object " 1031 "required for defining uniform blocks"); 1032 } else if (state->ARB_uniform_buffer_object_warn) { 1033 _mesa_glsl_warning(locp, state, 1034 "#version 140 / GL_ARB_uniform_buffer_object " 1035 "required for defining uniform blocks"); 1036 } 1037 } else { 1038 if (!state->has_shader_io_blocks()) { 1039 if (state->es_shader) { 1040 _mesa_glsl_error(locp, state, 1041 "GL_OES_shader_io_blocks or #version 320 " 1042 "required for using interface blocks"); 1043 } else { 1044 _mesa_glsl_error(locp, state, 1045 "#version 150 required for using " 1046 "interface blocks"); 1047 } 1048 } 1049 } 1050 1051 /* From the GLSL 1.50.11 spec, section 4.3.7 ("Interface Blocks"): 1052 * "It is illegal to have an input block in a vertex shader 1053 * or an output block in a fragment shader" 1054 */ 1055 if ((state->stage == MESA_SHADER_VERTEX) && q.flags.q.in) { 1056 _mesa_glsl_error(locp, state, 1057 "`in' interface block is not allowed for " 1058 "a vertex shader"); 1059 } else if ((state->stage == MESA_SHADER_FRAGMENT) && q.flags.q.out) { 1060 _mesa_glsl_error(locp, state, 1061 "`out' interface block is not allowed for " 1062 "a fragment shader"); 1063 } 1064 1065 /* Since block arrays require names, and both features are added in 1066 * the same language versions, we don't have to explicitly 1067 * version-check both things. 1068 */ 1069 if (block->instance_name != NULL) { 1070 state->check_version(150, 300, locp, "interface blocks with " 1071 "an instance name are not allowed"); 1072 } 1073 1074 ast_type_qualifier::bitset_t interface_type_mask; 1075 struct ast_type_qualifier temp_type_qualifier; 1076 1077 /* Get a bitmask containing only the in/out/uniform/buffer 1078 * flags, allowing us to ignore other irrelevant flags like 1079 * interpolation qualifiers. 1080 */ 1081 temp_type_qualifier.flags.i = 0; 1082 temp_type_qualifier.flags.q.uniform = true; 1083 temp_type_qualifier.flags.q.in = true; 1084 temp_type_qualifier.flags.q.out = true; 1085 temp_type_qualifier.flags.q.buffer = true; 1086 temp_type_qualifier.flags.q.patch = true; 1087 interface_type_mask = temp_type_qualifier.flags.i; 1088 1089 /* Get the block's interface qualifier. The interface_qualifier 1090 * production rule guarantees that only one bit will be set (and 1091 * it will be in/out/uniform). 1092 */ 1093 ast_type_qualifier::bitset_t block_interface_qualifier = q.flags.i; 1094 1095 block->default_layout.flags.i |= block_interface_qualifier; 1096 1097 if (state->stage == MESA_SHADER_GEOMETRY && 1098 state->has_explicit_attrib_stream() && 1099 block->default_layout.flags.q.out) { 1100 /* Assign global layout's stream value. */ 1101 block->default_layout.flags.q.stream = 1; 1102 block->default_layout.flags.q.explicit_stream = 0; 1103 block->default_layout.stream = state->out_qualifier->stream; 1104 } 1105 1106 if (state->has_enhanced_layouts() && block->default_layout.flags.q.out) { 1107 /* Assign global layout's xfb_buffer value. */ 1108 block->default_layout.flags.q.xfb_buffer = 1; 1109 block->default_layout.flags.q.explicit_xfb_buffer = 0; 1110 block->default_layout.xfb_buffer = state->out_qualifier->xfb_buffer; 1111 } 1112 1113 foreach_list_typed (ast_declarator_list, member, link, &block->declarations) { 1114 ast_type_qualifier& qualifier = member->type->qualifier; 1115 if ((qualifier.flags.i & interface_type_mask) == 0) { 1116 /* GLSLangSpec.1.50.11, 4.3.7 (Interface Blocks): 1117 * "If no optional qualifier is used in a member declaration, the 1118 * qualifier of the variable is just in, out, or uniform as declared 1119 * by interface-qualifier." 1120 */ 1121 qualifier.flags.i |= block_interface_qualifier; 1122 } else if ((qualifier.flags.i & interface_type_mask) != 1123 block_interface_qualifier) { 1124 /* GLSLangSpec.1.50.11, 4.3.7 (Interface Blocks): 1125 * "If optional qualifiers are used, they can include interpolation 1126 * and storage qualifiers and they must declare an input, output, 1127 * or uniform variable consistent with the interface qualifier of 1128 * the block." 1129 */ 1130 _mesa_glsl_error(locp, state, 1131 "uniform/in/out qualifier on " 1132 "interface block member does not match " 1133 "the interface block"); 1134 } 1135 1136 if (!(q.flags.q.in || q.flags.q.out) && qualifier.flags.q.invariant) 1137 _mesa_glsl_error(locp, state, 1138 "invariant qualifiers can be used only " 1139 "in interface block members for shader " 1140 "inputs or outputs"); 1141 } 1142} 1143 1144static void 1145_mesa_ast_type_qualifier_print(const struct ast_type_qualifier *q) 1146{ 1147 if (q->is_subroutine_decl()) 1148 printf("subroutine "); 1149 1150 if (q->subroutine_list) { 1151 printf("subroutine ("); 1152 q->subroutine_list->print(); 1153 printf(")"); 1154 } 1155 1156 if (q->flags.q.constant) 1157 printf("const "); 1158 1159 if (q->flags.q.invariant) 1160 printf("invariant "); 1161 1162 if (q->flags.q.attribute) 1163 printf("attribute "); 1164 1165 if (q->flags.q.varying) 1166 printf("varying "); 1167 1168 if (q->flags.q.in && q->flags.q.out) 1169 printf("inout "); 1170 else { 1171 if (q->flags.q.in) 1172 printf("in "); 1173 1174 if (q->flags.q.out) 1175 printf("out "); 1176 } 1177 1178 if (q->flags.q.centroid) 1179 printf("centroid "); 1180 if (q->flags.q.sample) 1181 printf("sample "); 1182 if (q->flags.q.patch) 1183 printf("patch "); 1184 if (q->flags.q.uniform) 1185 printf("uniform "); 1186 if (q->flags.q.buffer) 1187 printf("buffer "); 1188 if (q->flags.q.smooth) 1189 printf("smooth "); 1190 if (q->flags.q.flat) 1191 printf("flat "); 1192 if (q->flags.q.noperspective) 1193 printf("noperspective "); 1194} 1195 1196 1197void 1198ast_node::print(void) const 1199{ 1200 printf("unhandled node "); 1201} 1202 1203 1204ast_node::ast_node(void) 1205{ 1206 this->location.path = NULL; 1207 this->location.source = 0; 1208 this->location.first_line = 0; 1209 this->location.first_column = 0; 1210 this->location.last_line = 0; 1211 this->location.last_column = 0; 1212} 1213 1214 1215static void 1216ast_opt_array_dimensions_print(const ast_array_specifier *array_specifier) 1217{ 1218 if (array_specifier) 1219 array_specifier->print(); 1220} 1221 1222 1223void 1224ast_compound_statement::print(void) const 1225{ 1226 printf("{\n"); 1227 1228 foreach_list_typed(ast_node, ast, link, &this->statements) { 1229 ast->print(); 1230 } 1231 1232 printf("}\n"); 1233} 1234 1235 1236ast_compound_statement::ast_compound_statement(int new_scope, 1237 ast_node *statements) 1238{ 1239 this->new_scope = new_scope; 1240 1241 if (statements != NULL) { 1242 this->statements.push_degenerate_list_at_head(&statements->link); 1243 } 1244} 1245 1246 1247void 1248ast_expression::print(void) const 1249{ 1250 switch (oper) { 1251 case ast_assign: 1252 case ast_mul_assign: 1253 case ast_div_assign: 1254 case ast_mod_assign: 1255 case ast_add_assign: 1256 case ast_sub_assign: 1257 case ast_ls_assign: 1258 case ast_rs_assign: 1259 case ast_and_assign: 1260 case ast_xor_assign: 1261 case ast_or_assign: 1262 subexpressions[0]->print(); 1263 printf("%s ", operator_string(oper)); 1264 subexpressions[1]->print(); 1265 break; 1266 1267 case ast_field_selection: 1268 subexpressions[0]->print(); 1269 printf(". %s ", primary_expression.identifier); 1270 break; 1271 1272 case ast_plus: 1273 case ast_neg: 1274 case ast_bit_not: 1275 case ast_logic_not: 1276 case ast_pre_inc: 1277 case ast_pre_dec: 1278 printf("%s ", operator_string(oper)); 1279 subexpressions[0]->print(); 1280 break; 1281 1282 case ast_post_inc: 1283 case ast_post_dec: 1284 subexpressions[0]->print(); 1285 printf("%s ", operator_string(oper)); 1286 break; 1287 1288 case ast_conditional: 1289 subexpressions[0]->print(); 1290 printf("? "); 1291 subexpressions[1]->print(); 1292 printf(": "); 1293 subexpressions[2]->print(); 1294 break; 1295 1296 case ast_array_index: 1297 subexpressions[0]->print(); 1298 printf("[ "); 1299 subexpressions[1]->print(); 1300 printf("] "); 1301 break; 1302 1303 case ast_function_call: { 1304 subexpressions[0]->print(); 1305 printf("( "); 1306 1307 foreach_list_typed (ast_node, ast, link, &this->expressions) { 1308 if (&ast->link != this->expressions.get_head()) 1309 printf(", "); 1310 1311 ast->print(); 1312 } 1313 1314 printf(") "); 1315 break; 1316 } 1317 1318 case ast_identifier: 1319 printf("%s ", primary_expression.identifier); 1320 break; 1321 1322 case ast_int_constant: 1323 printf("%d ", primary_expression.int_constant); 1324 break; 1325 1326 case ast_uint_constant: 1327 printf("%u ", primary_expression.uint_constant); 1328 break; 1329 1330 case ast_float_constant: 1331 printf("%f ", primary_expression.float_constant); 1332 break; 1333 1334 case ast_double_constant: 1335 printf("%f ", primary_expression.double_constant); 1336 break; 1337 1338 case ast_int64_constant: 1339 printf("%" PRId64 " ", primary_expression.int64_constant); 1340 break; 1341 1342 case ast_uint64_constant: 1343 printf("%" PRIu64 " ", primary_expression.uint64_constant); 1344 break; 1345 1346 case ast_bool_constant: 1347 printf("%s ", 1348 primary_expression.bool_constant 1349 ? "true" : "false"); 1350 break; 1351 1352 case ast_sequence: { 1353 printf("( "); 1354 foreach_list_typed (ast_node, ast, link, & this->expressions) { 1355 if (&ast->link != this->expressions.get_head()) 1356 printf(", "); 1357 1358 ast->print(); 1359 } 1360 printf(") "); 1361 break; 1362 } 1363 1364 case ast_aggregate: { 1365 printf("{ "); 1366 foreach_list_typed (ast_node, ast, link, & this->expressions) { 1367 if (&ast->link != this->expressions.get_head()) 1368 printf(", "); 1369 1370 ast->print(); 1371 } 1372 printf("} "); 1373 break; 1374 } 1375 1376 default: 1377 assert(0); 1378 break; 1379 } 1380} 1381 1382ast_expression::ast_expression(int oper, 1383 ast_expression *ex0, 1384 ast_expression *ex1, 1385 ast_expression *ex2) : 1386 primary_expression() 1387{ 1388 this->oper = ast_operators(oper); 1389 this->subexpressions[0] = ex0; 1390 this->subexpressions[1] = ex1; 1391 this->subexpressions[2] = ex2; 1392 this->non_lvalue_description = NULL; 1393 this->is_lhs = false; 1394} 1395 1396 1397void 1398ast_expression_statement::print(void) const 1399{ 1400 if (expression) 1401 expression->print(); 1402 1403 printf("; "); 1404} 1405 1406 1407ast_expression_statement::ast_expression_statement(ast_expression *ex) : 1408 expression(ex) 1409{ 1410 /* empty */ 1411} 1412 1413 1414void 1415ast_function::print(void) const 1416{ 1417 return_type->print(); 1418 printf(" %s (", identifier); 1419 1420 foreach_list_typed(ast_node, ast, link, & this->parameters) { 1421 ast->print(); 1422 } 1423 1424 printf(")"); 1425} 1426 1427 1428ast_function::ast_function(void) 1429 : return_type(NULL), identifier(NULL), is_definition(false), 1430 signature(NULL) 1431{ 1432 /* empty */ 1433} 1434 1435 1436void 1437ast_fully_specified_type::print(void) const 1438{ 1439 _mesa_ast_type_qualifier_print(& qualifier); 1440 specifier->print(); 1441} 1442 1443 1444void 1445ast_parameter_declarator::print(void) const 1446{ 1447 type->print(); 1448 if (identifier) 1449 printf("%s ", identifier); 1450 ast_opt_array_dimensions_print(array_specifier); 1451} 1452 1453 1454void 1455ast_function_definition::print(void) const 1456{ 1457 prototype->print(); 1458 body->print(); 1459} 1460 1461 1462void 1463ast_declaration::print(void) const 1464{ 1465 printf("%s ", identifier); 1466 ast_opt_array_dimensions_print(array_specifier); 1467 1468 if (initializer) { 1469 printf("= "); 1470 initializer->print(); 1471 } 1472} 1473 1474 1475ast_declaration::ast_declaration(const char *identifier, 1476 ast_array_specifier *array_specifier, 1477 ast_expression *initializer) 1478{ 1479 this->identifier = identifier; 1480 this->array_specifier = array_specifier; 1481 this->initializer = initializer; 1482} 1483 1484 1485void 1486ast_declarator_list::print(void) const 1487{ 1488 assert(type || invariant); 1489 1490 if (type) 1491 type->print(); 1492 else if (invariant) 1493 printf("invariant "); 1494 else 1495 printf("precise "); 1496 1497 foreach_list_typed (ast_node, ast, link, & this->declarations) { 1498 if (&ast->link != this->declarations.get_head()) 1499 printf(", "); 1500 1501 ast->print(); 1502 } 1503 1504 printf("; "); 1505} 1506 1507 1508ast_declarator_list::ast_declarator_list(ast_fully_specified_type *type) 1509{ 1510 this->type = type; 1511 this->invariant = false; 1512 this->precise = false; 1513} 1514 1515void 1516ast_jump_statement::print(void) const 1517{ 1518 switch (mode) { 1519 case ast_continue: 1520 printf("continue; "); 1521 break; 1522 case ast_break: 1523 printf("break; "); 1524 break; 1525 case ast_return: 1526 printf("return "); 1527 if (opt_return_value) 1528 opt_return_value->print(); 1529 1530 printf("; "); 1531 break; 1532 case ast_discard: 1533 printf("discard; "); 1534 break; 1535 } 1536} 1537 1538 1539ast_jump_statement::ast_jump_statement(int mode, ast_expression *return_value) 1540 : opt_return_value(NULL) 1541{ 1542 this->mode = ast_jump_modes(mode); 1543 1544 if (mode == ast_return) 1545 opt_return_value = return_value; 1546} 1547 1548 1549void 1550ast_demote_statement::print(void) const 1551{ 1552 printf("demote; "); 1553} 1554 1555 1556void 1557ast_selection_statement::print(void) const 1558{ 1559 printf("if ( "); 1560 condition->print(); 1561 printf(") "); 1562 1563 then_statement->print(); 1564 1565 if (else_statement) { 1566 printf("else "); 1567 else_statement->print(); 1568 } 1569} 1570 1571 1572ast_selection_statement::ast_selection_statement(ast_expression *condition, 1573 ast_node *then_statement, 1574 ast_node *else_statement) 1575{ 1576 this->condition = condition; 1577 this->then_statement = then_statement; 1578 this->else_statement = else_statement; 1579} 1580 1581 1582void 1583ast_switch_statement::print(void) const 1584{ 1585 printf("switch ( "); 1586 test_expression->print(); 1587 printf(") "); 1588 1589 body->print(); 1590} 1591 1592 1593ast_switch_statement::ast_switch_statement(ast_expression *test_expression, 1594 ast_node *body) 1595{ 1596 this->test_expression = test_expression; 1597 this->body = body; 1598 this->test_val = NULL; 1599} 1600 1601 1602void 1603ast_switch_body::print(void) const 1604{ 1605 printf("{\n"); 1606 if (stmts != NULL) { 1607 stmts->print(); 1608 } 1609 printf("}\n"); 1610} 1611 1612 1613ast_switch_body::ast_switch_body(ast_case_statement_list *stmts) 1614{ 1615 this->stmts = stmts; 1616} 1617 1618 1619void ast_case_label::print(void) const 1620{ 1621 if (test_value != NULL) { 1622 printf("case "); 1623 test_value->print(); 1624 printf(": "); 1625 } else { 1626 printf("default: "); 1627 } 1628} 1629 1630 1631ast_case_label::ast_case_label(ast_expression *test_value) 1632{ 1633 this->test_value = test_value; 1634} 1635 1636 1637void ast_case_label_list::print(void) const 1638{ 1639 foreach_list_typed(ast_node, ast, link, & this->labels) { 1640 ast->print(); 1641 } 1642 printf("\n"); 1643} 1644 1645 1646ast_case_label_list::ast_case_label_list(void) 1647{ 1648} 1649 1650 1651void ast_case_statement::print(void) const 1652{ 1653 labels->print(); 1654 foreach_list_typed(ast_node, ast, link, & this->stmts) { 1655 ast->print(); 1656 printf("\n"); 1657 } 1658} 1659 1660 1661ast_case_statement::ast_case_statement(ast_case_label_list *labels) 1662{ 1663 this->labels = labels; 1664} 1665 1666 1667void ast_case_statement_list::print(void) const 1668{ 1669 foreach_list_typed(ast_node, ast, link, & this->cases) { 1670 ast->print(); 1671 } 1672} 1673 1674 1675ast_case_statement_list::ast_case_statement_list(void) 1676{ 1677} 1678 1679 1680void 1681ast_iteration_statement::print(void) const 1682{ 1683 switch (mode) { 1684 case ast_for: 1685 printf("for( "); 1686 if (init_statement) 1687 init_statement->print(); 1688 printf("; "); 1689 1690 if (condition) 1691 condition->print(); 1692 printf("; "); 1693 1694 if (rest_expression) 1695 rest_expression->print(); 1696 printf(") "); 1697 1698 body->print(); 1699 break; 1700 1701 case ast_while: 1702 printf("while ( "); 1703 if (condition) 1704 condition->print(); 1705 printf(") "); 1706 body->print(); 1707 break; 1708 1709 case ast_do_while: 1710 printf("do "); 1711 body->print(); 1712 printf("while ( "); 1713 if (condition) 1714 condition->print(); 1715 printf("); "); 1716 break; 1717 } 1718} 1719 1720 1721ast_iteration_statement::ast_iteration_statement(int mode, 1722 ast_node *init, 1723 ast_node *condition, 1724 ast_expression *rest_expression, 1725 ast_node *body) 1726{ 1727 this->mode = ast_iteration_modes(mode); 1728 this->init_statement = init; 1729 this->condition = condition; 1730 this->rest_expression = rest_expression; 1731 this->body = body; 1732} 1733 1734 1735void 1736ast_struct_specifier::print(void) const 1737{ 1738 printf("struct %s { ", name); 1739 foreach_list_typed(ast_node, ast, link, &this->declarations) { 1740 ast->print(); 1741 } 1742 printf("} "); 1743} 1744 1745 1746ast_struct_specifier::ast_struct_specifier(const char *identifier, 1747 ast_declarator_list *declarator_list) 1748 : name(identifier), layout(NULL), declarations(), is_declaration(true), 1749 type(NULL) 1750{ 1751 this->declarations.push_degenerate_list_at_head(&declarator_list->link); 1752} 1753 1754void ast_subroutine_list::print(void) const 1755{ 1756 foreach_list_typed (ast_node, ast, link, & this->declarations) { 1757 if (&ast->link != this->declarations.get_head()) 1758 printf(", "); 1759 ast->print(); 1760 } 1761} 1762 1763static void 1764set_shader_inout_layout(struct gl_shader *shader, 1765 struct _mesa_glsl_parse_state *state) 1766{ 1767 /* Should have been prevented by the parser. */ 1768 if (shader->Stage != MESA_SHADER_GEOMETRY && 1769 shader->Stage != MESA_SHADER_TESS_EVAL && 1770 shader->Stage != MESA_SHADER_COMPUTE) { 1771 assert(!state->in_qualifier->flags.i); 1772 } 1773 1774 if (shader->Stage != MESA_SHADER_COMPUTE) { 1775 /* Should have been prevented by the parser. */ 1776 assert(!state->cs_input_local_size_specified); 1777 assert(!state->cs_input_local_size_variable_specified); 1778 assert(state->cs_derivative_group == DERIVATIVE_GROUP_NONE); 1779 } 1780 1781 if (shader->Stage != MESA_SHADER_FRAGMENT) { 1782 /* Should have been prevented by the parser. */ 1783 assert(!state->fs_uses_gl_fragcoord); 1784 assert(!state->fs_redeclares_gl_fragcoord); 1785 assert(!state->fs_pixel_center_integer); 1786 assert(!state->fs_origin_upper_left); 1787 assert(!state->fs_early_fragment_tests); 1788 assert(!state->fs_inner_coverage); 1789 assert(!state->fs_post_depth_coverage); 1790 assert(!state->fs_pixel_interlock_ordered); 1791 assert(!state->fs_pixel_interlock_unordered); 1792 assert(!state->fs_sample_interlock_ordered); 1793 assert(!state->fs_sample_interlock_unordered); 1794 } 1795 1796 for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) { 1797 if (state->out_qualifier->out_xfb_stride[i]) { 1798 unsigned xfb_stride; 1799 if (state->out_qualifier->out_xfb_stride[i]-> 1800 process_qualifier_constant(state, "xfb_stride", &xfb_stride, 1801 true)) { 1802 shader->TransformFeedbackBufferStride[i] = xfb_stride; 1803 } 1804 } 1805 } 1806 1807 switch (shader->Stage) { 1808 case MESA_SHADER_TESS_CTRL: 1809 shader->info.TessCtrl.VerticesOut = 0; 1810 if (state->tcs_output_vertices_specified) { 1811 unsigned vertices; 1812 if (state->out_qualifier->vertices-> 1813 process_qualifier_constant(state, "vertices", &vertices, 1814 false)) { 1815 1816 YYLTYPE loc = state->out_qualifier->vertices->get_location(); 1817 if (vertices > state->Const.MaxPatchVertices) { 1818 _mesa_glsl_error(&loc, state, "vertices (%d) exceeds " 1819 "GL_MAX_PATCH_VERTICES", vertices); 1820 } 1821 shader->info.TessCtrl.VerticesOut = vertices; 1822 } 1823 } 1824 break; 1825 case MESA_SHADER_TESS_EVAL: 1826 shader->info.TessEval.PrimitiveMode = PRIM_UNKNOWN; 1827 if (state->in_qualifier->flags.q.prim_type) 1828 shader->info.TessEval.PrimitiveMode = state->in_qualifier->prim_type; 1829 1830 shader->info.TessEval.Spacing = TESS_SPACING_UNSPECIFIED; 1831 if (state->in_qualifier->flags.q.vertex_spacing) 1832 shader->info.TessEval.Spacing = state->in_qualifier->vertex_spacing; 1833 1834 shader->info.TessEval.VertexOrder = 0; 1835 if (state->in_qualifier->flags.q.ordering) 1836 shader->info.TessEval.VertexOrder = state->in_qualifier->ordering; 1837 1838 shader->info.TessEval.PointMode = -1; 1839 if (state->in_qualifier->flags.q.point_mode) 1840 shader->info.TessEval.PointMode = state->in_qualifier->point_mode; 1841 break; 1842 case MESA_SHADER_GEOMETRY: 1843 shader->info.Geom.VerticesOut = -1; 1844 if (state->out_qualifier->flags.q.max_vertices) { 1845 unsigned qual_max_vertices; 1846 if (state->out_qualifier->max_vertices-> 1847 process_qualifier_constant(state, "max_vertices", 1848 &qual_max_vertices, true)) { 1849 1850 if (qual_max_vertices > state->Const.MaxGeometryOutputVertices) { 1851 YYLTYPE loc = state->out_qualifier->max_vertices->get_location(); 1852 _mesa_glsl_error(&loc, state, 1853 "maximum output vertices (%d) exceeds " 1854 "GL_MAX_GEOMETRY_OUTPUT_VERTICES", 1855 qual_max_vertices); 1856 } 1857 shader->info.Geom.VerticesOut = qual_max_vertices; 1858 } 1859 } 1860 1861 if (state->gs_input_prim_type_specified) { 1862 shader->info.Geom.InputType = state->in_qualifier->prim_type; 1863 } else { 1864 shader->info.Geom.InputType = PRIM_UNKNOWN; 1865 } 1866 1867 if (state->out_qualifier->flags.q.prim_type) { 1868 shader->info.Geom.OutputType = state->out_qualifier->prim_type; 1869 } else { 1870 shader->info.Geom.OutputType = PRIM_UNKNOWN; 1871 } 1872 1873 shader->info.Geom.Invocations = 0; 1874 if (state->in_qualifier->flags.q.invocations) { 1875 unsigned invocations; 1876 if (state->in_qualifier->invocations-> 1877 process_qualifier_constant(state, "invocations", 1878 &invocations, false)) { 1879 1880 YYLTYPE loc = state->in_qualifier->invocations->get_location(); 1881 if (invocations > state->Const.MaxGeometryShaderInvocations) { 1882 _mesa_glsl_error(&loc, state, 1883 "invocations (%d) exceeds " 1884 "GL_MAX_GEOMETRY_SHADER_INVOCATIONS", 1885 invocations); 1886 } 1887 shader->info.Geom.Invocations = invocations; 1888 } 1889 } 1890 break; 1891 1892 case MESA_SHADER_COMPUTE: 1893 if (state->cs_input_local_size_specified) { 1894 for (int i = 0; i < 3; i++) 1895 shader->info.Comp.LocalSize[i] = state->cs_input_local_size[i]; 1896 } else { 1897 for (int i = 0; i < 3; i++) 1898 shader->info.Comp.LocalSize[i] = 0; 1899 } 1900 1901 shader->info.Comp.LocalSizeVariable = 1902 state->cs_input_local_size_variable_specified; 1903 1904 shader->info.Comp.DerivativeGroup = state->cs_derivative_group; 1905 1906 if (state->NV_compute_shader_derivatives_enable) { 1907 /* We allow multiple cs_input_layout nodes, but do not store them in 1908 * a convenient place, so for now live with an empty location error. 1909 */ 1910 YYLTYPE loc = {0}; 1911 if (shader->info.Comp.DerivativeGroup == DERIVATIVE_GROUP_QUADS) { 1912 if (shader->info.Comp.LocalSize[0] % 2 != 0) { 1913 _mesa_glsl_error(&loc, state, "derivative_group_quadsNV must be used with a " 1914 "local group size whose first dimension " 1915 "is a multiple of 2\n"); 1916 } 1917 if (shader->info.Comp.LocalSize[1] % 2 != 0) { 1918 _mesa_glsl_error(&loc, state, "derivative_group_quadsNV must be used with a " 1919 "local group size whose second dimension " 1920 "is a multiple of 2\n"); 1921 } 1922 } else if (shader->info.Comp.DerivativeGroup == DERIVATIVE_GROUP_LINEAR) { 1923 if ((shader->info.Comp.LocalSize[0] * 1924 shader->info.Comp.LocalSize[1] * 1925 shader->info.Comp.LocalSize[2]) % 4 != 0) { 1926 _mesa_glsl_error(&loc, state, "derivative_group_linearNV must be used with a " 1927 "local group size whose total number of invocations " 1928 "is a multiple of 4\n"); 1929 } 1930 } 1931 } 1932 1933 break; 1934 1935 case MESA_SHADER_FRAGMENT: 1936 shader->redeclares_gl_fragcoord = state->fs_redeclares_gl_fragcoord; 1937 shader->uses_gl_fragcoord = state->fs_uses_gl_fragcoord; 1938 shader->pixel_center_integer = state->fs_pixel_center_integer; 1939 shader->origin_upper_left = state->fs_origin_upper_left; 1940 shader->ARB_fragment_coord_conventions_enable = 1941 state->ARB_fragment_coord_conventions_enable; 1942 shader->EarlyFragmentTests = state->fs_early_fragment_tests; 1943 shader->InnerCoverage = state->fs_inner_coverage; 1944 shader->PostDepthCoverage = state->fs_post_depth_coverage; 1945 shader->PixelInterlockOrdered = state->fs_pixel_interlock_ordered; 1946 shader->PixelInterlockUnordered = state->fs_pixel_interlock_unordered; 1947 shader->SampleInterlockOrdered = state->fs_sample_interlock_ordered; 1948 shader->SampleInterlockUnordered = state->fs_sample_interlock_unordered; 1949 shader->BlendSupport = state->fs_blend_support; 1950 break; 1951 1952 default: 1953 /* Nothing to do. */ 1954 break; 1955 } 1956 1957 shader->bindless_sampler = state->bindless_sampler_specified; 1958 shader->bindless_image = state->bindless_image_specified; 1959 shader->bound_sampler = state->bound_sampler_specified; 1960 shader->bound_image = state->bound_image_specified; 1961 shader->redeclares_gl_layer = state->redeclares_gl_layer; 1962 shader->layer_viewport_relative = state->layer_viewport_relative; 1963} 1964 1965/* src can be NULL if only the symbols found in the exec_list should be 1966 * copied 1967 */ 1968void 1969_mesa_glsl_copy_symbols_from_table(struct exec_list *shader_ir, 1970 struct glsl_symbol_table *src, 1971 struct glsl_symbol_table *dest) 1972{ 1973 foreach_in_list (ir_instruction, ir, shader_ir) { 1974 switch (ir->ir_type) { 1975 case ir_type_function: 1976 dest->add_function((ir_function *) ir); 1977 break; 1978 case ir_type_variable: { 1979 ir_variable *const var = (ir_variable *) ir; 1980 1981 if (var->data.mode != ir_var_temporary) 1982 dest->add_variable(var); 1983 break; 1984 } 1985 default: 1986 break; 1987 } 1988 } 1989 1990 if (src != NULL) { 1991 /* Explicitly copy the gl_PerVertex interface definitions because these 1992 * are needed to check they are the same during the interstage link. 1993 * They can’t necessarily be found via the exec_list because the members 1994 * might not be referenced. The GL spec still requires that they match 1995 * in that case. 1996 */ 1997 const glsl_type *iface = 1998 src->get_interface("gl_PerVertex", ir_var_shader_in); 1999 if (iface) 2000 dest->add_interface(iface->name, iface, ir_var_shader_in); 2001 2002 iface = src->get_interface("gl_PerVertex", ir_var_shader_out); 2003 if (iface) 2004 dest->add_interface(iface->name, iface, ir_var_shader_out); 2005 } 2006} 2007 2008extern "C" { 2009 2010static void 2011assign_subroutine_indexes(struct _mesa_glsl_parse_state *state) 2012{ 2013 int j, k; 2014 int index = 0; 2015 2016 for (j = 0; j < state->num_subroutines; j++) { 2017 while (state->subroutines[j]->subroutine_index == -1) { 2018 for (k = 0; k < state->num_subroutines; k++) { 2019 if (state->subroutines[k]->subroutine_index == index) 2020 break; 2021 else if (k == state->num_subroutines - 1) { 2022 state->subroutines[j]->subroutine_index = index; 2023 } 2024 } 2025 index++; 2026 } 2027 } 2028} 2029 2030static void 2031add_builtin_defines(struct _mesa_glsl_parse_state *state, 2032 void (*add_builtin_define)(struct glcpp_parser *, const char *, int), 2033 struct glcpp_parser *data, 2034 unsigned version, 2035 bool es) 2036{ 2037 unsigned gl_version = state->ctx->Extensions.Version; 2038 gl_api api = state->ctx->API; 2039 2040 if (gl_version != 0xff) { 2041 unsigned i; 2042 for (i = 0; i < state->num_supported_versions; i++) { 2043 if (state->supported_versions[i].ver == version && 2044 state->supported_versions[i].es == es) { 2045 gl_version = state->supported_versions[i].gl_ver; 2046 break; 2047 } 2048 } 2049 2050 if (i == state->num_supported_versions) 2051 return; 2052 } 2053 2054 if (es) 2055 api = API_OPENGLES2; 2056 2057 for (unsigned i = 0; 2058 i < ARRAY_SIZE(_mesa_glsl_supported_extensions); ++i) { 2059 const _mesa_glsl_extension *extension 2060 = &_mesa_glsl_supported_extensions[i]; 2061 if (extension->compatible_with_state(state, api, gl_version)) { 2062 add_builtin_define(data, extension->name, 1); 2063 } 2064 } 2065} 2066 2067/* Implements parsing checks that we can't do during parsing */ 2068static void 2069do_late_parsing_checks(struct _mesa_glsl_parse_state *state) 2070{ 2071 if (state->stage == MESA_SHADER_COMPUTE && !state->has_compute_shader()) { 2072 YYLTYPE loc; 2073 memset(&loc, 0, sizeof(loc)); 2074 _mesa_glsl_error(&loc, state, "Compute shaders require " 2075 "GLSL 4.30 or GLSL ES 3.10"); 2076 } 2077} 2078 2079static void 2080opt_shader_and_create_symbol_table(struct gl_context *ctx, 2081 struct glsl_symbol_table *source_symbols, 2082 struct gl_shader *shader) 2083{ 2084 assert(shader->CompileStatus != COMPILE_FAILURE && 2085 !shader->ir->is_empty()); 2086 2087 struct gl_shader_compiler_options *options = 2088 &ctx->Const.ShaderCompilerOptions[shader->Stage]; 2089 2090 /* Do some optimization at compile time to reduce shader IR size 2091 * and reduce later work if the same shader is linked multiple times 2092 */ 2093 if (ctx->Const.GLSLOptimizeConservatively) { 2094 /* Run it just once. */ 2095 do_common_optimization(shader->ir, false, false, options, 2096 ctx->Const.NativeIntegers); 2097 } else { 2098 /* Repeat it until it stops making changes. */ 2099 while (do_common_optimization(shader->ir, false, false, options, 2100 ctx->Const.NativeIntegers)) 2101 ; 2102 } 2103 2104 validate_ir_tree(shader->ir); 2105 2106 enum ir_variable_mode other; 2107 switch (shader->Stage) { 2108 case MESA_SHADER_VERTEX: 2109 other = ir_var_shader_in; 2110 break; 2111 case MESA_SHADER_FRAGMENT: 2112 other = ir_var_shader_out; 2113 break; 2114 default: 2115 /* Something invalid to ensure optimize_dead_builtin_uniforms 2116 * doesn't remove anything other than uniforms or constants. 2117 */ 2118 other = ir_var_mode_count; 2119 break; 2120 } 2121 2122 optimize_dead_builtin_variables(shader->ir, other); 2123 2124 validate_ir_tree(shader->ir); 2125 2126 /* Retain any live IR, but trash the rest. */ 2127 reparent_ir(shader->ir, shader->ir); 2128 2129 /* Destroy the symbol table. Create a new symbol table that contains only 2130 * the variables and functions that still exist in the IR. The symbol 2131 * table will be used later during linking. 2132 * 2133 * There must NOT be any freed objects still referenced by the symbol 2134 * table. That could cause the linker to dereference freed memory. 2135 * 2136 * We don't have to worry about types or interface-types here because those 2137 * are fly-weights that are looked up by glsl_type. 2138 */ 2139 _mesa_glsl_copy_symbols_from_table(shader->ir, source_symbols, 2140 shader->symbols); 2141} 2142 2143static bool 2144can_skip_compile(struct gl_context *ctx, struct gl_shader *shader, 2145 const char *source, bool force_recompile, 2146 bool source_has_shader_include) 2147{ 2148 if (!force_recompile) { 2149 if (ctx->Cache) { 2150 char buf[41]; 2151 disk_cache_compute_key(ctx->Cache, source, strlen(source), 2152 shader->sha1); 2153 if (disk_cache_has_key(ctx->Cache, shader->sha1)) { 2154 /* We've seen this shader before and know it compiles */ 2155 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 2156 _mesa_sha1_format(buf, shader->sha1); 2157 fprintf(stderr, "deferring compile of shader: %s\n", buf); 2158 } 2159 shader->CompileStatus = COMPILE_SKIPPED; 2160 2161 free((void *)shader->FallbackSource); 2162 2163 /* Copy pre-processed shader include to fallback source otherwise 2164 * we have no guarantee the shader include source tree has not 2165 * changed. 2166 */ 2167 shader->FallbackSource = source_has_shader_include ? 2168 strdup(source) : NULL; 2169 return true; 2170 } 2171 } 2172 } else { 2173 /* We should only ever end up here if a re-compile has been forced by a 2174 * shader cache miss. In which case we can skip the compile if its 2175 * already been done by a previous fallback or the initial compile call. 2176 */ 2177 if (shader->CompileStatus == COMPILE_SUCCESS) 2178 return true; 2179 } 2180 2181 return false; 2182} 2183 2184void 2185_mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *shader, 2186 bool dump_ast, bool dump_hir, bool force_recompile) 2187{ 2188 const char *source = force_recompile && shader->FallbackSource ? 2189 shader->FallbackSource : shader->Source; 2190 2191 /* Note this will be true for shaders the have #include inside comments 2192 * however that should be rare enough not to worry about. 2193 */ 2194 bool source_has_shader_include = 2195 strstr(source, "#include") == NULL ? false : true; 2196 2197 /* If there was no shader include we can check the shader cache and skip 2198 * compilation before we run the preprocessor. We never skip compiling 2199 * shaders that use ARB_shading_language_include because we would need to 2200 * keep duplicate copies of the shader include source tree and paths. 2201 */ 2202 if (!source_has_shader_include && 2203 can_skip_compile(ctx, shader, source, force_recompile, false)) 2204 return; 2205 2206 struct _mesa_glsl_parse_state *state = 2207 new(shader) _mesa_glsl_parse_state(ctx, shader->Stage, shader); 2208 2209 if (ctx->Const.GenerateTemporaryNames) 2210 (void) p_atomic_cmpxchg(&ir_variable::temporaries_allocate_names, 2211 false, true); 2212 2213 if (!source_has_shader_include || !force_recompile) { 2214 state->error = glcpp_preprocess(state, &source, &state->info_log, 2215 add_builtin_defines, state, ctx); 2216 } 2217 2218 /* Now that we have run the preprocessor we can check the shader cache and 2219 * skip compilation if possible for those shaders that contained a shader 2220 * include. 2221 */ 2222 if (source_has_shader_include && 2223 can_skip_compile(ctx, shader, source, force_recompile, true)) 2224 return; 2225 2226 if (!state->error) { 2227 _mesa_glsl_lexer_ctor(state, source); 2228 _mesa_glsl_parse(state); 2229 _mesa_glsl_lexer_dtor(state); 2230 do_late_parsing_checks(state); 2231 } 2232 2233 if (dump_ast) { 2234 foreach_list_typed(ast_node, ast, link, &state->translation_unit) { 2235 ast->print(); 2236 } 2237 printf("\n\n"); 2238 } 2239 2240 ralloc_free(shader->ir); 2241 shader->ir = new(shader) exec_list; 2242 if (!state->error && !state->translation_unit.is_empty()) 2243 _mesa_ast_to_hir(shader->ir, state); 2244 2245 if (!state->error) { 2246 validate_ir_tree(shader->ir); 2247 2248 /* Print out the unoptimized IR. */ 2249 if (dump_hir) { 2250 _mesa_print_ir(stdout, shader->ir, state); 2251 } 2252 } 2253 2254 if (shader->InfoLog) 2255 ralloc_free(shader->InfoLog); 2256 2257 if (!state->error) 2258 set_shader_inout_layout(shader, state); 2259 2260 shader->symbols = new(shader->ir) glsl_symbol_table; 2261 shader->CompileStatus = state->error ? COMPILE_FAILURE : COMPILE_SUCCESS; 2262 shader->InfoLog = state->info_log; 2263 shader->Version = state->language_version; 2264 shader->IsES = state->es_shader; 2265 2266 struct gl_shader_compiler_options *options = 2267 &ctx->Const.ShaderCompilerOptions[shader->Stage]; 2268 2269 if (!state->error && !shader->ir->is_empty()) { 2270 if (state->es_shader && 2271 (options->LowerPrecisionFloat16 || options->LowerPrecisionInt16)) 2272 lower_precision(options, shader->ir); 2273 lower_builtins(shader->ir); 2274 assign_subroutine_indexes(state); 2275 lower_subroutine(shader->ir, state); 2276 opt_shader_and_create_symbol_table(ctx, state->symbols, shader); 2277 } 2278 2279 if (!force_recompile) { 2280 free((void *)shader->FallbackSource); 2281 2282 /* Copy pre-processed shader include to fallback source otherwise we 2283 * have no guarantee the shader include source tree has not changed. 2284 */ 2285 shader->FallbackSource = source_has_shader_include ? 2286 strdup(source) : NULL; 2287 } 2288 2289 delete state->symbols; 2290 ralloc_free(state); 2291 2292 if (ctx->Cache && shader->CompileStatus == COMPILE_SUCCESS) { 2293 char sha1_buf[41]; 2294 disk_cache_put_key(ctx->Cache, shader->sha1); 2295 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 2296 _mesa_sha1_format(sha1_buf, shader->sha1); 2297 fprintf(stderr, "marking shader: %s\n", sha1_buf); 2298 } 2299 } 2300} 2301 2302} /* extern "C" */ 2303/** 2304 * Do the set of common optimizations passes 2305 * 2306 * \param ir List of instructions to be optimized 2307 * \param linked Is the shader linked? This enables 2308 * optimizations passes that remove code at 2309 * global scope and could cause linking to 2310 * fail. 2311 * \param uniform_locations_assigned Have locations already been assigned for 2312 * uniforms? This prevents the declarations 2313 * of unused uniforms from being removed. 2314 * The setting of this flag only matters if 2315 * \c linked is \c true. 2316 * \param options The driver's preferred shader options. 2317 * \param native_integers Selects optimizations that depend on the 2318 * implementations supporting integers 2319 * natively (as opposed to supporting 2320 * integers in floating point registers). 2321 */ 2322bool 2323do_common_optimization(exec_list *ir, bool linked, 2324 bool uniform_locations_assigned, 2325 const struct gl_shader_compiler_options *options, 2326 bool native_integers) 2327{ 2328 const bool debug = false; 2329 bool progress = false; 2330 2331#define OPT(PASS, ...) do { \ 2332 if (debug) { \ 2333 fprintf(stderr, "START GLSL optimization %s\n", #PASS); \ 2334 const bool opt_progress = PASS(__VA_ARGS__); \ 2335 progress = opt_progress || progress; \ 2336 if (opt_progress) \ 2337 _mesa_print_ir(stderr, ir, NULL); \ 2338 fprintf(stderr, "GLSL optimization %s: %s progress\n", \ 2339 #PASS, opt_progress ? "made" : "no"); \ 2340 } else { \ 2341 progress = PASS(__VA_ARGS__) || progress; \ 2342 } \ 2343 } while (false) 2344 2345 OPT(lower_instructions, ir, SUB_TO_ADD_NEG); 2346 2347 if (linked) { 2348 OPT(do_function_inlining, ir); 2349 OPT(do_dead_functions, ir); 2350 OPT(do_structure_splitting, ir); 2351 } 2352 OPT(propagate_invariance, ir); 2353 OPT(do_if_simplification, ir); 2354 OPT(opt_flatten_nested_if_blocks, ir); 2355 OPT(opt_conditional_discard, ir); 2356 OPT(do_copy_propagation_elements, ir); 2357 2358 if (options->OptimizeForAOS && !linked) 2359 OPT(opt_flip_matrices, ir); 2360 2361 if (linked && options->OptimizeForAOS) { 2362 OPT(do_vectorize, ir); 2363 } 2364 2365 if (linked) 2366 OPT(do_dead_code, ir, uniform_locations_assigned); 2367 else 2368 OPT(do_dead_code_unlinked, ir); 2369 OPT(do_dead_code_local, ir); 2370 OPT(do_tree_grafting, ir); 2371 OPT(do_constant_propagation, ir); 2372 if (linked) 2373 OPT(do_constant_variable, ir); 2374 else 2375 OPT(do_constant_variable_unlinked, ir); 2376 OPT(do_constant_folding, ir); 2377 OPT(do_minmax_prune, ir); 2378 OPT(do_rebalance_tree, ir); 2379 OPT(do_algebraic, ir, native_integers, options); 2380 OPT(do_lower_jumps, ir, true, true, options->EmitNoMainReturn, 2381 options->EmitNoCont, options->EmitNoLoops); 2382 OPT(do_vec_index_to_swizzle, ir); 2383 OPT(lower_vector_insert, ir, false); 2384 OPT(optimize_swizzles, ir); 2385 2386 /* Some drivers only call do_common_optimization() once rather than in a 2387 * loop, and split arrays causes each element of a constant array to 2388 * dereference is own copy of the entire array initilizer. This IR is not 2389 * something that can be generated manually in a shader and is not 2390 * accounted for by NIR optimisations, the result is an exponential slow 2391 * down in compilation speed as a constant arrays element count grows. To 2392 * avoid that here we make sure to always clean up the mess split arrays 2393 * causes to constant arrays. 2394 */ 2395 bool array_split = optimize_split_arrays(ir, linked); 2396 if (array_split) 2397 do_constant_propagation(ir); 2398 progress |= array_split; 2399 2400 OPT(optimize_redundant_jumps, ir); 2401 2402 if (options->MaxUnrollIterations) { 2403 loop_state *ls = analyze_loop_variables(ir); 2404 if (ls->loop_found) { 2405 bool loop_progress = unroll_loops(ir, ls, options); 2406 while (loop_progress) { 2407 loop_progress = false; 2408 loop_progress |= do_constant_propagation(ir); 2409 loop_progress |= do_if_simplification(ir); 2410 2411 /* Some drivers only call do_common_optimization() once rather 2412 * than in a loop. So we must call do_lower_jumps() after 2413 * unrolling a loop because for drivers that use LLVM validation 2414 * will fail if a jump is not the last instruction in the block. 2415 * For example the following will fail LLVM validation: 2416 * 2417 * (loop ( 2418 * ... 2419 * break 2420 * (assign (x) (var_ref v124) (expression int + (var_ref v124) 2421 * (constant int (1)) ) ) 2422 * )) 2423 */ 2424 loop_progress |= do_lower_jumps(ir, true, true, 2425 options->EmitNoMainReturn, 2426 options->EmitNoCont, 2427 options->EmitNoLoops); 2428 } 2429 progress |= loop_progress; 2430 } 2431 delete ls; 2432 } 2433 2434 /* If the PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY cap is set, this pass will 2435 * only be called once rather than repeatedly until no further progress is 2436 * made. 2437 * 2438 * If an optimization pass fails to preserve the invariant flag, calling 2439 * the pass only once may result in incorrect code generation. Always call 2440 * propagate_invariance() last to avoid this possibility. 2441 */ 2442 OPT(propagate_invariance, ir); 2443 2444#undef OPT 2445 2446 return progress; 2447} 2448