projects / mesa.git / blob
? search:


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