projects / mesa.git / blob
? search:


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