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