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