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