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 }
  31
  32 #include "ralloc.h"
  33 #include "ast.h"
  34 #include "glsl_parser_extras.h"
  35 #include "glsl_parser.h"
  36 #include "ir_optimization.h"
  37 #include "loop_analysis.h"
  38
  39 _mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *ctx,
  40                                                GLenum target, void *mem_ctx)
  41 {
  42    switch (target) {
  43    case GL_VERTEX_SHADER:   this->target = vertex_shader; break;
  44    case GL_FRAGMENT_SHADER: this->target = fragment_shader; break;
  45    case GL_GEOMETRY_SHADER: this->target = geometry_shader; break;
  46    }
  47
  48    this->scanner = NULL;
  49    this->translation_unit.make_empty();
  50    this->symbols = new(mem_ctx) glsl_symbol_table;
  51    this->info_log = ralloc_strdup(mem_ctx, "");
  52    this->error = false;
  53    this->loop_or_switch_nesting = NULL;
  54
  55    this->num_builtins_to_link = 0;
  56
  57    /* Set default language version and extensions */
  58    this->language_version = 110;
  59    this->es_shader = false;
  60    this->ARB_texture_rectangle_enable = true;
  61
  62    /* OpenGL ES 2.0 has different defaults from desktop GL. */
  63    if (ctx->API == API_OPENGLES2) {
  64       this->language_version = 100;
  65       this->es_shader = true;
  66       this->ARB_texture_rectangle_enable = false;
  67    }
  68
  69    this->extensions = &ctx->Extensions;
  70
  71    this->Const.MaxLights = ctx->Const.MaxLights;
  72    this->Const.MaxClipPlanes = ctx->Const.MaxClipPlanes;
  73    this->Const.MaxTextureUnits = ctx->Const.MaxTextureUnits;
  74    this->Const.MaxTextureCoords = ctx->Const.MaxTextureCoordUnits;
  75    this->Const.MaxVertexAttribs = ctx->Const.VertexProgram.MaxAttribs;
  76    this->Const.MaxVertexUniformComponents = ctx->Const.VertexProgram.MaxUniformComponents;
  77    this->Const.MaxVaryingFloats = ctx->Const.MaxVarying * 4;
  78    this->Const.MaxVertexTextureImageUnits = ctx->Const.MaxVertexTextureImageUnits;
  79    this->Const.MaxCombinedTextureImageUnits = ctx->Const.MaxCombinedTextureImageUnits;
  80    this->Const.MaxTextureImageUnits = ctx->Const.MaxTextureImageUnits;
  81    this->Const.MaxFragmentUniformComponents = ctx->Const.FragmentProgram.MaxUniformComponents;
  82
  83    this->Const.MaxDrawBuffers = ctx->Const.MaxDrawBuffers;
  84
  85    /* Note: Once the OpenGL 3.0 'forward compatible' context or the OpenGL 3.2
  86     * Core context is supported, this logic will need change.  Older versions of
  87     * GLSL are no longer supported outside the compatibility contexts of 3.x.
  88     */
  89    this->Const.GLSL_100ES = (ctx->API == API_OPENGLES2)
  90       || ctx->Extensions.ARB_ES2_compatibility;
  91    this->Const.GLSL_110 = (ctx->API == API_OPENGL);
  92    this->Const.GLSL_120 = (ctx->API == API_OPENGL)
  93       && (ctx->Const.GLSLVersion >= 120);
  94    this->Const.GLSL_130 = (ctx->API == API_OPENGL)
  95       && (ctx->Const.GLSLVersion >= 130);
  96
  97    const unsigned lowest_version =
  98       (ctx->API == API_OPENGLES2) || ctx->Extensions.ARB_ES2_compatibility
  99       ? 100 : 110;
 100    const unsigned highest_version =
 101       (ctx->API == API_OPENGL) ? ctx->Const.GLSLVersion : 100;
 102    char *supported = ralloc_strdup(this, "");
 103
 104    for (unsigned ver = lowest_version; ver <= highest_version; ver += 10) {
 105       const char *const prefix = (ver == lowest_version)
 106          ? ""
 107          : ((ver == highest_version) ? ", and " : ", ");
 108
 109       ralloc_asprintf_append(& supported, "%s%d.%02d%s",
 110                              prefix,
 111                              ver / 100, ver % 100,
 112                              (ver == 100) ? " ES" : "");
 113    }
 114
 115    this->supported_version_string = supported;
 116 }
 117
 118 const char *
 119 _mesa_glsl_shader_target_name(enum _mesa_glsl_parser_targets target)
 120 {
 121    switch (target) {
 122    case vertex_shader:   return "vertex";
 123    case fragment_shader: return "fragment";
 124    case geometry_shader: return "geometry";
 125    }
 126
 127    assert(!"Should not get here.");
 128    return "unknown";
 129 }
 130
 131
 132 void
 133 _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state,
 134                  const char *fmt, ...)
 135 {
 136    va_list ap;
 137
 138    state->error = true;
 139
 140    assert(state->info_log != NULL);
 141    ralloc_asprintf_append(&state->info_log, "%u:%u(%u): error: ",
 142                                             locp->source,
 143                                             locp->first_line,
 144                                             locp->first_column);
 145    va_start(ap, fmt);
 146    ralloc_vasprintf_append(&state->info_log, fmt, ap);
 147    va_end(ap);
 148    ralloc_strcat(&state->info_log, "\n");
 149 }
 150
 151
 152 void
 153 _mesa_glsl_warning(const YYLTYPE *locp, _mesa_glsl_parse_state *state,
 154                    const char *fmt, ...)
 155 {
 156    va_list ap;
 157
 158    assert(state->info_log != NULL);
 159    ralloc_asprintf_append(&state->info_log, "%u:%u(%u): warning: ",
 160                                             locp->source,
 161                                             locp->first_line,
 162                                             locp->first_column);
 163    va_start(ap, fmt);
 164    ralloc_vasprintf_append(&state->info_log, fmt, ap);
 165    va_end(ap);
 166    ralloc_strcat(&state->info_log, "\n");
 167 }
 168
 169
 170 /**
 171  * Enum representing the possible behaviors that can be specified in
 172  * an #extension directive.
 173  */
 174 enum ext_behavior {
 175    extension_disable,
 176    extension_enable,
 177    extension_require,
 178    extension_warn
 179 };
 180
 181 /**
 182  * Element type for _mesa_glsl_supported_extensions
 183  */
 184 struct _mesa_glsl_extension {
 185    /**
 186     * Name of the extension when referred to in a GLSL extension
 187     * statement
 188     */
 189    const char *name;
 190
 191    /** True if this extension is available to vertex shaders */
 192    bool avail_in_VS;
 193
 194    /** True if this extension is available to geometry shaders */
 195    bool avail_in_GS;
 196
 197    /** True if this extension is available to fragment shaders */
 198    bool avail_in_FS;
 199
 200    /** True if this extension is available to desktop GL shaders */
 201    bool avail_in_GL;
 202
 203    /** True if this extension is available to GLES shaders */
 204    bool avail_in_ES;
 205
 206    /**
 207     * Flag in the gl_extensions struct indicating whether this
 208     * extension is supported by the driver, or
 209     * &gl_extensions::dummy_true if supported by all drivers.
 210     *
 211     * Note: the type (GLboolean gl_extensions::*) is a "pointer to
 212     * member" type, the type-safe alternative to the "offsetof" macro.
 213     * In a nutshell:
 214     *
 215     * - foo bar::* p declares p to be an "offset" to a field of type
 216     *   foo that exists within struct bar
 217     * - &bar::baz computes the "offset" of field baz within struct bar
 218     * - x.*p accesses the field of x that exists at "offset" p
 219     * - x->*p is equivalent to (*x).*p
 220     */
 221    const GLboolean gl_extensions::* supported_flag;
 222
 223    /**
 224     * Flag in the _mesa_glsl_parse_state struct that should be set
 225     * when this extension is enabled.
 226     *
 227     * See note in _mesa_glsl_extension::supported_flag about "pointer
 228     * to member" types.
 229     */
 230    bool _mesa_glsl_parse_state::* enable_flag;
 231
 232    /**
 233     * Flag in the _mesa_glsl_parse_state struct that should be set
 234     * when the shader requests "warn" behavior for this extension.
 235     *
 236     * See note in _mesa_glsl_extension::supported_flag about "pointer
 237     * to member" types.
 238     */
 239    bool _mesa_glsl_parse_state::* warn_flag;
 240
 241
 242    bool compatible_with_state(const _mesa_glsl_parse_state *state) const;
 243    void set_flags(_mesa_glsl_parse_state *state, ext_behavior behavior) const;
 244 };
 245
 246 #define EXT(NAME, VS, GS, FS, GL, ES, SUPPORTED_FLAG)                   \
 247    { "GL_" #NAME, VS, GS, FS, GL, ES, &gl_extensions::SUPPORTED_FLAG,   \
 248          &_mesa_glsl_parse_state::NAME##_enable,                        \
 249          &_mesa_glsl_parse_state::NAME##_warn }
 250
 251 /**
 252  * Table of extensions that can be enabled/disabled within a shader,
 253  * and the conditions under which they are supported.
 254  */
 255 static const _mesa_glsl_extension _mesa_glsl_supported_extensions[] = {
 256    /*                                  target availability  API availability */
 257    /* name                             VS     GS     FS     GL     ES         supported flag */
 258    EXT(ARB_conservative_depth,         true,  false, true,  true,  false,     AMD_conservative_depth),
 259    EXT(ARB_draw_buffers,               false, false, true,  true,  false,     dummy_true),
 260    EXT(ARB_draw_instanced,             true,  false, false, true,  false,     ARB_draw_instanced),
 261    EXT(ARB_explicit_attrib_location,   true,  false, true,  true,  false,     ARB_explicit_attrib_location),
 262    EXT(ARB_fragment_coord_conventions, true,  false, true,  true,  false,     ARB_fragment_coord_conventions),
 263    EXT(ARB_texture_rectangle,          true,  false, true,  true,  false,     dummy_true),
 264    EXT(EXT_texture_array,              true,  false, true,  true,  false,     EXT_texture_array),
 265    EXT(ARB_shader_texture_lod,         true,  false, true,  true,  false,     ARB_shader_texture_lod),
 266    EXT(ARB_shader_stencil_export,      false, false, true,  true,  false,     ARB_shader_stencil_export),
 267    EXT(AMD_conservative_depth,         true,  false, true,  true,  false,     AMD_conservative_depth),
 268    EXT(AMD_shader_stencil_export,      false, false, true,  true,  false,     ARB_shader_stencil_export),
 269    EXT(OES_texture_3D,                 true,  false, true,  false, true,      EXT_texture3D),
 270 };
 271
 272 #undef EXT
 273
 274
 275 /**
 276  * Determine whether a given extension is compatible with the target,
 277  * API, and extension information in the current parser state.
 278  */
 279 bool _mesa_glsl_extension::compatible_with_state(const _mesa_glsl_parse_state *
 280                                                  state) const
 281 {
 282    /* Check that this extension matches the type of shader we are
 283     * compiling to.
 284     */
 285    switch (state->target) {
 286    case vertex_shader:
 287       if (!this->avail_in_VS) {
 288          return false;
 289       }
 290       break;
 291    case geometry_shader:
 292       if (!this->avail_in_GS) {
 293          return false;
 294       }
 295       break;
 296    case fragment_shader:
 297       if (!this->avail_in_FS) {
 298          return false;
 299       }
 300       break;
 301    default:
 302       assert (!"Unrecognized shader target");
 303       return false;
 304    }
 305
 306    /* Check that this extension matches whether we are compiling
 307     * for desktop GL or GLES.
 308     */
 309    if (state->es_shader) {
 310       if (!this->avail_in_ES) return false;
 311    } else {
 312       if (!this->avail_in_GL) return false;
 313    }
 314
 315    /* Check that this extension is supported by the OpenGL
 316     * implementation.
 317     *
 318     * Note: the ->* operator indexes into state->extensions by the
 319     * offset this->supported_flag.  See
 320     * _mesa_glsl_extension::supported_flag for more info.
 321     */
 322    return state->extensions->*(this->supported_flag);
 323 }
 324
 325 /**
 326  * Set the appropriate flags in the parser state to establish the
 327  * given behavior for this extension.
 328  */
 329 void _mesa_glsl_extension::set_flags(_mesa_glsl_parse_state *state,
 330                                      ext_behavior behavior) const
 331 {
 332    /* Note: the ->* operator indexes into state by the
 333     * offsets this->enable_flag and this->warn_flag.  See
 334     * _mesa_glsl_extension::supported_flag for more info.
 335     */
 336    state->*(this->enable_flag) = (behavior != extension_disable);
 337    state->*(this->warn_flag)   = (behavior == extension_warn);
 338 }
 339
 340 /**
 341  * Find an extension by name in _mesa_glsl_supported_extensions.  If
 342  * the name is not found, return NULL.
 343  */
 344 static const _mesa_glsl_extension *find_extension(const char *name)
 345 {
 346    for (unsigned i = 0; i < Elements(_mesa_glsl_supported_extensions); ++i) {
 347       if (strcmp(name, _mesa_glsl_supported_extensions[i].name) == 0) {
 348          return &_mesa_glsl_supported_extensions[i];
 349       }
 350    }
 351    return NULL;
 352 }
 353
 354
 355 bool
 356 _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
 357                              const char *behavior_string, YYLTYPE *behavior_locp,
 358                              _mesa_glsl_parse_state *state)
 359 {
 360    ext_behavior behavior;
 361    if (strcmp(behavior_string, "warn") == 0) {
 362       behavior = extension_warn;
 363    } else if (strcmp(behavior_string, "require") == 0) {
 364       behavior = extension_require;
 365    } else if (strcmp(behavior_string, "enable") == 0) {
 366       behavior = extension_enable;
 367    } else if (strcmp(behavior_string, "disable") == 0) {
 368       behavior = extension_disable;
 369    } else {
 370       _mesa_glsl_error(behavior_locp, state,
 371                        "Unknown extension behavior `%s'",
 372                        behavior_string);
 373       return false;
 374    }
 375
 376    if (strcmp(name, "all") == 0) {
 377       if ((behavior == extension_enable) || (behavior == extension_require)) {
 378          _mesa_glsl_error(name_locp, state, "Cannot %s all extensions",
 379                           (behavior == extension_enable)
 380                           ? "enable" : "require");
 381          return false;
 382       } else {
 383          for (unsigned i = 0;
 384               i < Elements(_mesa_glsl_supported_extensions); ++i) {
 385             const _mesa_glsl_extension *extension
 386                = &_mesa_glsl_supported_extensions[i];
 387             if (extension->compatible_with_state(state)) {
 388                _mesa_glsl_supported_extensions[i].set_flags(state, behavior);
 389             }
 390          }
 391       }
 392    } else {
 393       const _mesa_glsl_extension *extension = find_extension(name);
 394       if (extension && extension->compatible_with_state(state)) {
 395          extension->set_flags(state, behavior);
 396       } else {
 397          static const char *const fmt = "extension `%s' unsupported in %s shader";
 398
 399          if (behavior == extension_require) {
 400             _mesa_glsl_error(name_locp, state, fmt,
 401                              name, _mesa_glsl_shader_target_name(state->target));
 402             return false;
 403          } else {
 404             _mesa_glsl_warning(name_locp, state, fmt,
 405                                name, _mesa_glsl_shader_target_name(state->target));
 406          }
 407       }
 408    }
 409
 410    return true;
 411 }
 412
 413 void
 414 _mesa_ast_type_qualifier_print(const struct ast_type_qualifier *q)
 415 {
 416    if (q->flags.q.constant)
 417       printf("const ");
 418
 419    if (q->flags.q.invariant)
 420       printf("invariant ");
 421
 422    if (q->flags.q.attribute)
 423       printf("attribute ");
 424
 425    if (q->flags.q.varying)
 426       printf("varying ");
 427
 428    if (q->flags.q.in && q->flags.q.out)
 429       printf("inout ");
 430    else {
 431       if (q->flags.q.in)
 432          printf("in ");
 433
 434       if (q->flags.q.out)
 435          printf("out ");
 436    }
 437
 438    if (q->flags.q.centroid)
 439       printf("centroid ");
 440    if (q->flags.q.uniform)
 441       printf("uniform ");
 442    if (q->flags.q.smooth)
 443       printf("smooth ");
 444    if (q->flags.q.flat)
 445       printf("flat ");
 446    if (q->flags.q.noperspective)
 447       printf("noperspective ");
 448 }
 449
 450
 451 void
 452 ast_node::print(void) const
 453 {
 454    printf("unhandled node ");
 455 }
 456
 457
 458 ast_node::ast_node(void)
 459 {
 460    this->location.source = 0;
 461    this->location.line = 0;
 462    this->location.column = 0;
 463 }
 464
 465
 466 static void
 467 ast_opt_array_size_print(bool is_array, const ast_expression *array_size)
 468 {
 469    if (is_array) {
 470       printf("[ ");
 471
 472       if (array_size)
 473          array_size->print();
 474
 475       printf("] ");
 476    }
 477 }
 478
 479
 480 void
 481 ast_compound_statement::print(void) const
 482 {
 483    printf("{\n");
 484
 485    foreach_list_const(n, &this->statements) {
 486       ast_node *ast = exec_node_data(ast_node, n, link);
 487       ast->print();
 488    }
 489
 490    printf("}\n");
 491 }
 492
 493
 494 ast_compound_statement::ast_compound_statement(int new_scope,
 495                                                ast_node *statements)
 496 {
 497    this->new_scope = new_scope;
 498
 499    if (statements != NULL) {
 500       this->statements.push_degenerate_list_at_head(&statements->link);
 501    }
 502 }
 503
 504
 505 void
 506 ast_expression::print(void) const
 507 {
 508    switch (oper) {
 509    case ast_assign:
 510    case ast_mul_assign:
 511    case ast_div_assign:
 512    case ast_mod_assign:
 513    case ast_add_assign:
 514    case ast_sub_assign:
 515    case ast_ls_assign:
 516    case ast_rs_assign:
 517    case ast_and_assign:
 518    case ast_xor_assign:
 519    case ast_or_assign:
 520       subexpressions[0]->print();
 521       printf("%s ", operator_string(oper));
 522       subexpressions[1]->print();
 523       break;
 524
 525    case ast_field_selection:
 526       subexpressions[0]->print();
 527       printf(". %s ", primary_expression.identifier);
 528       break;
 529
 530    case ast_plus:
 531    case ast_neg:
 532    case ast_bit_not:
 533    case ast_logic_not:
 534    case ast_pre_inc:
 535    case ast_pre_dec:
 536       printf("%s ", operator_string(oper));
 537       subexpressions[0]->print();
 538       break;
 539
 540    case ast_post_inc:
 541    case ast_post_dec:
 542       subexpressions[0]->print();
 543       printf("%s ", operator_string(oper));
 544       break;
 545
 546    case ast_conditional:
 547       subexpressions[0]->print();
 548       printf("? ");
 549       subexpressions[1]->print();
 550       printf(": ");
 551       subexpressions[2]->print();
 552       break;
 553
 554    case ast_array_index:
 555       subexpressions[0]->print();
 556       printf("[ ");
 557       subexpressions[1]->print();
 558       printf("] ");
 559       break;
 560
 561    case ast_function_call: {
 562       subexpressions[0]->print();
 563       printf("( ");
 564
 565       foreach_list_const (n, &this->expressions) {
 566          if (n != this->expressions.get_head())
 567             printf(", ");
 568
 569          ast_node *ast = exec_node_data(ast_node, n, link);
 570          ast->print();
 571       }
 572
 573       printf(") ");
 574       break;
 575    }
 576
 577    case ast_identifier:
 578       printf("%s ", primary_expression.identifier);
 579       break;
 580
 581    case ast_int_constant:
 582       printf("%d ", primary_expression.int_constant);
 583       break;
 584
 585    case ast_uint_constant:
 586       printf("%u ", primary_expression.uint_constant);
 587       break;
 588
 589    case ast_float_constant:
 590       printf("%f ", primary_expression.float_constant);
 591       break;
 592
 593    case ast_bool_constant:
 594       printf("%s ",
 595              primary_expression.bool_constant
 596              ? "true" : "false");
 597       break;
 598
 599    case ast_sequence: {
 600       printf("( ");
 601       foreach_list_const(n, & this->expressions) {
 602          if (n != this->expressions.get_head())
 603             printf(", ");
 604
 605          ast_node *ast = exec_node_data(ast_node, n, link);
 606          ast->print();
 607       }
 608       printf(") ");
 609       break;
 610    }
 611
 612    default:
 613       assert(0);
 614       break;
 615    }
 616 }
 617
 618 ast_expression::ast_expression(int oper,
 619                                ast_expression *ex0,
 620                                ast_expression *ex1,
 621                                ast_expression *ex2)
 622 {
 623    this->oper = ast_operators(oper);
 624    this->subexpressions[0] = ex0;
 625    this->subexpressions[1] = ex1;
 626    this->subexpressions[2] = ex2;
 627 }
 628
 629
 630 void
 631 ast_expression_statement::print(void) const
 632 {
 633    if (expression)
 634       expression->print();
 635
 636    printf("; ");
 637 }
 638
 639
 640 ast_expression_statement::ast_expression_statement(ast_expression *ex) :
 641    expression(ex)
 642 {
 643    /* empty */
 644 }
 645
 646
 647 void
 648 ast_function::print(void) const
 649 {
 650    return_type->print();
 651    printf(" %s (", identifier);
 652
 653    foreach_list_const(n, & this->parameters) {
 654       ast_node *ast = exec_node_data(ast_node, n, link);
 655       ast->print();
 656    }
 657
 658    printf(")");
 659 }
 660
 661
 662 ast_function::ast_function(void)
 663    : is_definition(false), signature(NULL)
 664 {
 665    /* empty */
 666 }
 667
 668
 669 void
 670 ast_fully_specified_type::print(void) const
 671 {
 672    _mesa_ast_type_qualifier_print(& qualifier);
 673    specifier->print();
 674 }
 675
 676
 677 void
 678 ast_parameter_declarator::print(void) const
 679 {
 680    type->print();
 681    if (identifier)
 682       printf("%s ", identifier);
 683    ast_opt_array_size_print(is_array, array_size);
 684 }
 685
 686
 687 void
 688 ast_function_definition::print(void) const
 689 {
 690    prototype->print();
 691    body->print();
 692 }
 693
 694
 695 void
 696 ast_declaration::print(void) const
 697 {
 698    printf("%s ", identifier);
 699    ast_opt_array_size_print(is_array, array_size);
 700
 701    if (initializer) {
 702       printf("= ");
 703       initializer->print();
 704    }
 705 }
 706
 707
 708 ast_declaration::ast_declaration(char *identifier, int is_array,
 709                                  ast_expression *array_size,
 710                                  ast_expression *initializer)
 711 {
 712    this->identifier = identifier;
 713    this->is_array = is_array;
 714    this->array_size = array_size;
 715    this->initializer = initializer;
 716 }
 717
 718
 719 void
 720 ast_declarator_list::print(void) const
 721 {
 722    assert(type || invariant);
 723
 724    if (type)
 725       type->print();
 726    else
 727       printf("invariant ");
 728
 729    foreach_list_const (ptr, & this->declarations) {
 730       if (ptr != this->declarations.get_head())
 731          printf(", ");
 732
 733       ast_node *ast = exec_node_data(ast_node, ptr, link);
 734       ast->print();
 735    }
 736
 737    printf("; ");
 738 }
 739
 740
 741 ast_declarator_list::ast_declarator_list(ast_fully_specified_type *type)
 742 {
 743    this->type = type;
 744    this->invariant = false;
 745 }
 746
 747 void
 748 ast_jump_statement::print(void) const
 749 {
 750    switch (mode) {
 751    case ast_continue:
 752       printf("continue; ");
 753       break;
 754    case ast_break:
 755       printf("break; ");
 756       break;
 757    case ast_return:
 758       printf("return ");
 759       if (opt_return_value)
 760          opt_return_value->print();
 761
 762       printf("; ");
 763       break;
 764    case ast_discard:
 765       printf("discard; ");
 766       break;
 767    }
 768 }
 769
 770
 771 ast_jump_statement::ast_jump_statement(int mode, ast_expression *return_value)
 772 {
 773    this->mode = ast_jump_modes(mode);
 774
 775    if (mode == ast_return)
 776       opt_return_value = return_value;
 777 }
 778
 779
 780 void
 781 ast_selection_statement::print(void) const
 782 {
 783    printf("if ( ");
 784    condition->print();
 785    printf(") ");
 786
 787    then_statement->print();
 788
 789    if (else_statement) {
 790       printf("else ");
 791       else_statement->print();
 792    }
 793
 794 }
 795
 796
 797 ast_selection_statement::ast_selection_statement(ast_expression *condition,
 798                                                  ast_node *then_statement,
 799                                                  ast_node *else_statement)
 800 {
 801    this->condition = condition;
 802    this->then_statement = then_statement;
 803    this->else_statement = else_statement;
 804 }
 805
 806
 807 void
 808 ast_iteration_statement::print(void) const
 809 {
 810    switch (mode) {
 811    case ast_for:
 812       printf("for( ");
 813       if (init_statement)
 814          init_statement->print();
 815       printf("; ");
 816
 817       if (condition)
 818          condition->print();
 819       printf("; ");
 820
 821       if (rest_expression)
 822          rest_expression->print();
 823       printf(") ");
 824
 825       body->print();
 826       break;
 827
 828    case ast_while:
 829       printf("while ( ");
 830       if (condition)
 831          condition->print();
 832       printf(") ");
 833       body->print();
 834       break;
 835
 836    case ast_do_while:
 837       printf("do ");
 838       body->print();
 839       printf("while ( ");
 840       if (condition)
 841          condition->print();
 842       printf("); ");
 843       break;
 844    }
 845 }
 846
 847
 848 ast_iteration_statement::ast_iteration_statement(int mode,
 849                                                  ast_node *init,
 850                                                  ast_node *condition,
 851                                                  ast_expression *rest_expression,
 852                                                  ast_node *body)
 853 {
 854    this->mode = ast_iteration_modes(mode);
 855    this->init_statement = init;
 856    this->condition = condition;
 857    this->rest_expression = rest_expression;
 858    this->body = body;
 859 }
 860
 861
 862 void
 863 ast_struct_specifier::print(void) const
 864 {
 865    printf("struct %s { ", name);
 866    foreach_list_const(n, &this->declarations) {
 867       ast_node *ast = exec_node_data(ast_node, n, link);
 868       ast->print();
 869    }
 870    printf("} ");
 871 }
 872
 873
 874 ast_struct_specifier::ast_struct_specifier(char *identifier,
 875                                            ast_node *declarator_list)
 876 {
 877    if (identifier == NULL) {
 878       static unsigned anon_count = 1;
 879       identifier = ralloc_asprintf(this, "#anon_struct_%04x", anon_count);
 880       anon_count++;
 881    }
 882    name = identifier;
 883    this->declarations.push_degenerate_list_at_head(&declarator_list->link);
 884 }
 885
 886 bool
 887 do_common_optimization(exec_list *ir, bool linked, unsigned max_unroll_iterations)
 888 {
 889    GLboolean progress = GL_FALSE;
 890
 891    progress = lower_instructions(ir, SUB_TO_ADD_NEG) || progress;
 892
 893    if (linked) {
 894       progress = do_function_inlining(ir) || progress;
 895       progress = do_dead_functions(ir) || progress;
 896       progress = do_structure_splitting(ir) || progress;
 897    }
 898    progress = do_if_simplification(ir) || progress;
 899    progress = do_discard_simplification(ir) || progress;
 900    progress = do_copy_propagation(ir) || progress;
 901    progress = do_copy_propagation_elements(ir) || progress;
 902    if (linked)
 903       progress = do_dead_code(ir) || progress;
 904    else
 905       progress = do_dead_code_unlinked(ir) || progress;
 906    progress = do_dead_code_local(ir) || progress;
 907    progress = do_tree_grafting(ir) || progress;
 908    progress = do_constant_propagation(ir) || progress;
 909    if (linked)
 910       progress = do_constant_variable(ir) || progress;
 911    else
 912       progress = do_constant_variable_unlinked(ir) || progress;
 913    progress = do_constant_folding(ir) || progress;
 914    progress = do_algebraic(ir) || progress;
 915    progress = do_lower_jumps(ir) || progress;
 916    progress = do_vec_index_to_swizzle(ir) || progress;
 917    progress = do_swizzle_swizzle(ir) || progress;
 918    progress = do_noop_swizzle(ir) || progress;
 919
 920    progress = optimize_redundant_jumps(ir) || progress;
 921
 922    loop_state *ls = analyze_loop_variables(ir);
 923    if (ls->loop_found) {
 924       progress = set_loop_controls(ir, ls) || progress;
 925       progress = unroll_loops(ir, ls, max_unroll_iterations) || progress;
 926    }
 927    delete ls;
 928
 929    return progress;
 930 }
 931
 932 extern "C" {
 933
 934 /**
 935  * To be called at GL teardown time, this frees compiler datastructures.
 936  *
 937  * After calling this, any previously compiled shaders and shader
 938  * programs would be invalid.  So this should happen at approximately
 939  * program exit.
 940  */
 941 void
 942 _mesa_destroy_shader_compiler(void)
 943 {
 944    _mesa_destroy_shader_compiler_caches();
 945
 946    _mesa_glsl_release_types();
 947 }
 948
 949 /**
 950  * Releases compiler caches to trade off performance for memory.
 951  *
 952  * Intended to be used with glReleaseShaderCompiler().
 953  */
 954 void
 955 _mesa_destroy_shader_compiler_caches(void)
 956 {
 957    _mesa_glsl_release_functions();
 958 }
 959
 960 }