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