src/compiler/glsl/glsl_parser_extras.h

   1 /*
   2  * Copyright © 2010 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
  24 #ifndef GLSL_PARSER_EXTRAS_H
  25 #define GLSL_PARSER_EXTRAS_H
  26
  27 /*
  28  * Most of the definitions here only apply to C++
  29  */
  30 #ifdef __cplusplus
  31
  32
  33 #include <stdlib.h>
  34 #include "glsl_symbol_table.h"
  35
  36 /* THIS is a macro defined somewhere deep in the Windows MSVC header files.
  37  * Undefine it here to avoid collision with the lexer's THIS token.
  38  */
  39 #undef THIS
  40
  41 struct gl_context;
  42
  43 struct glsl_switch_state {
  44    /** Temporary variables needed for switch statement. */
  45    ir_variable *test_var;
  46    ir_variable *is_fallthru_var;
  47    class ast_switch_statement *switch_nesting_ast;
  48
  49    /** Used to detect if 'continue' was called inside a switch. */
  50    ir_variable *continue_inside;
  51
  52    /** Used to set condition if 'default' label should be chosen. */
  53    ir_variable *run_default;
  54
  55    /** Table of constant values already used in case labels */
  56    struct hash_table *labels_ht;
  57    class ast_case_label *previous_default;
  58
  59    bool is_switch_innermost; // if switch stmt is closest to break, ...
  60 };
  61
  62 const char *
  63 glsl_compute_version_string(void *mem_ctx, bool is_es, unsigned version);
  64
  65 typedef struct YYLTYPE {
  66    int first_line;
  67    int first_column;
  68    int last_line;
  69    int last_column;
  70    unsigned source;
  71    /* Path for ARB_shading_language_include include source */
  72    char *path;
  73 } YYLTYPE;
  74 # define YYLTYPE_IS_DECLARED 1
  75 # define YYLTYPE_IS_TRIVIAL 1
  76
  77 extern void _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state,
  78                              const char *fmt, ...);
  79
  80
  81 struct _mesa_glsl_parse_state {
  82    _mesa_glsl_parse_state(struct gl_context *_ctx, gl_shader_stage stage,
  83                           void *mem_ctx);
  84
  85    DECLARE_RZALLOC_CXX_OPERATORS(_mesa_glsl_parse_state);
  86
  87    /**
  88     * Generate a string representing the GLSL version currently being compiled
  89     * (useful for error messages).
  90     */
  91    const char *get_version_string()
  92    {
  93       return glsl_compute_version_string(this, this->es_shader,
  94                                          this->language_version);
  95    }
  96
  97    /**
  98     * Determine whether the current GLSL version is sufficiently high to
  99     * support a certain feature.
 100     *
 101     * \param required_glsl_version is the desktop GLSL version that is
 102     * required to support the feature, or 0 if no version of desktop GLSL
 103     * supports the feature.
 104     *
 105     * \param required_glsl_es_version is the GLSL ES version that is required
 106     * to support the feature, or 0 if no version of GLSL ES supports the
 107     * feature.
 108     */
 109    bool is_version(unsigned required_glsl_version,
 110                    unsigned required_glsl_es_version) const
 111    {
 112       unsigned required_version = this->es_shader ?
 113          required_glsl_es_version : required_glsl_version;
 114       unsigned this_version = this->forced_language_version
 115          ? this->forced_language_version : this->language_version;
 116       return required_version != 0
 117          && this_version >= required_version;
 118    }
 119
 120    bool check_version(unsigned required_glsl_version,
 121                       unsigned required_glsl_es_version,
 122                       YYLTYPE *locp, const char *fmt, ...) PRINTFLIKE(5, 6);
 123
 124    bool check_arrays_of_arrays_allowed(YYLTYPE *locp)
 125    {
 126       if (!(ARB_arrays_of_arrays_enable || is_version(430, 310))) {
 127          const char *const requirement = this->es_shader
 128             ? "GLSL ES 3.10"
 129             : "GL_ARB_arrays_of_arrays or GLSL 4.30";
 130          _mesa_glsl_error(locp, this,
 131                           "%s required for defining arrays of arrays.",
 132                           requirement);
 133          return false;
 134       }
 135       return true;
 136    }
 137
 138    bool check_precision_qualifiers_allowed(YYLTYPE *locp)
 139    {
 140       return check_version(130, 100, locp,
 141                            "precision qualifiers are forbidden");
 142    }
 143
 144    bool check_bitwise_operations_allowed(YYLTYPE *locp)
 145    {
 146       return EXT_gpu_shader4_enable ||
 147              check_version(130, 300, locp, "bit-wise operations are forbidden");
 148    }
 149
 150    bool check_explicit_attrib_stream_allowed(YYLTYPE *locp)
 151    {
 152       if (!this->has_explicit_attrib_stream()) {
 153          const char *const requirement = "GL_ARB_gpu_shader5 extension or GLSL 4.00";
 154
 155          _mesa_glsl_error(locp, this, "explicit stream requires %s",
 156                           requirement);
 157          return false;
 158       }
 159
 160       return true;
 161    }
 162
 163    bool check_explicit_attrib_location_allowed(YYLTYPE *locp,
 164                                                const ir_variable *var)
 165    {
 166       if (!this->has_explicit_attrib_location()) {
 167          const char *const requirement = this->es_shader
 168             ? "GLSL ES 3.00"
 169             : "GL_ARB_explicit_attrib_location extension or GLSL 3.30";
 170
 171          _mesa_glsl_error(locp, this, "%s explicit location requires %s",
 172                           mode_string(var), requirement);
 173          return false;
 174       }
 175
 176       return true;
 177    }
 178
 179    bool check_separate_shader_objects_allowed(YYLTYPE *locp,
 180                                               const ir_variable *var)
 181    {
 182       if (!this->has_separate_shader_objects()) {
 183          const char *const requirement = this->es_shader
 184             ? "GL_EXT_separate_shader_objects extension or GLSL ES 3.10"
 185             : "GL_ARB_separate_shader_objects extension or GLSL 4.20";
 186
 187          _mesa_glsl_error(locp, this, "%s explicit location requires %s",
 188                           mode_string(var), requirement);
 189          return false;
 190       }
 191
 192       return true;
 193    }
 194
 195    bool check_explicit_uniform_location_allowed(YYLTYPE *locp,
 196                                                 const ir_variable *)
 197    {
 198       if (!this->has_explicit_attrib_location() ||
 199           !this->has_explicit_uniform_location()) {
 200          const char *const requirement = this->es_shader
 201             ? "GLSL ES 3.10"
 202             : "GL_ARB_explicit_uniform_location and either "
 203               "GL_ARB_explicit_attrib_location or GLSL 3.30.";
 204
 205          _mesa_glsl_error(locp, this,
 206                           "uniform explicit location requires %s",
 207                           requirement);
 208          return false;
 209       }
 210
 211       return true;
 212    }
 213
 214    bool has_atomic_counters() const
 215    {
 216       return ARB_shader_atomic_counters_enable || is_version(420, 310);
 217    }
 218
 219    bool has_enhanced_layouts() const
 220    {
 221       return ARB_enhanced_layouts_enable || is_version(440, 0);
 222    }
 223
 224    bool has_explicit_attrib_stream() const
 225    {
 226       return ARB_gpu_shader5_enable || is_version(400, 0);
 227    }
 228
 229    bool has_explicit_attrib_location() const
 230    {
 231       return ARB_explicit_attrib_location_enable || is_version(330, 300);
 232    }
 233
 234    bool has_explicit_uniform_location() const
 235    {
 236       return ARB_explicit_uniform_location_enable || is_version(430, 310);
 237    }
 238
 239    bool has_uniform_buffer_objects() const
 240    {
 241       return ARB_uniform_buffer_object_enable || is_version(140, 300);
 242    }
 243
 244    bool has_shader_storage_buffer_objects() const
 245    {
 246       return ARB_shader_storage_buffer_object_enable || is_version(430, 310);
 247    }
 248
 249    bool has_separate_shader_objects() const
 250    {
 251       return ARB_separate_shader_objects_enable || is_version(410, 310)
 252          || EXT_separate_shader_objects_enable;
 253    }
 254
 255    bool has_double() const
 256    {
 257       return ARB_gpu_shader_fp64_enable || is_version(400, 0);
 258    }
 259
 260    bool has_int64() const
 261    {
 262       return ARB_gpu_shader_int64_enable ||
 263              AMD_gpu_shader_int64_enable;
 264    }
 265
 266    bool has_420pack() const
 267    {
 268       return ARB_shading_language_420pack_enable || is_version(420, 0);
 269    }
 270
 271    bool has_420pack_or_es31() const
 272    {
 273       return ARB_shading_language_420pack_enable || is_version(420, 310);
 274    }
 275
 276    bool has_compute_shader() const
 277    {
 278       return ARB_compute_shader_enable || is_version(430, 310);
 279    }
 280
 281    bool has_shader_io_blocks() const
 282    {
 283       /* The OES_geometry_shader_specification says:
 284        *
 285        *    "If the OES_geometry_shader extension is enabled, the
 286        *     OES_shader_io_blocks extension is also implicitly enabled."
 287        *
 288        * The OES_tessellation_shader extension has similar wording.
 289        */
 290       return OES_shader_io_blocks_enable ||
 291              EXT_shader_io_blocks_enable ||
 292              OES_geometry_shader_enable ||
 293              EXT_geometry_shader_enable ||
 294              OES_tessellation_shader_enable ||
 295              EXT_tessellation_shader_enable ||
 296
 297              is_version(150, 320);
 298    }
 299
 300    bool has_geometry_shader() const
 301    {
 302       return OES_geometry_shader_enable || EXT_geometry_shader_enable ||
 303              is_version(150, 320);
 304    }
 305
 306    bool has_tessellation_shader() const
 307    {
 308       return ARB_tessellation_shader_enable ||
 309              OES_tessellation_shader_enable ||
 310              EXT_tessellation_shader_enable ||
 311              is_version(400, 320);
 312    }
 313
 314    bool has_clip_distance() const
 315    {
 316       return EXT_clip_cull_distance_enable || is_version(130, 0);
 317    }
 318
 319    bool has_cull_distance() const
 320    {
 321       return EXT_clip_cull_distance_enable ||
 322              ARB_cull_distance_enable ||
 323              is_version(450, 0);
 324    }
 325
 326    bool has_framebuffer_fetch() const
 327    {
 328       return EXT_shader_framebuffer_fetch_enable ||
 329              EXT_shader_framebuffer_fetch_non_coherent_enable;
 330    }
 331
 332    bool has_texture_cube_map_array() const
 333    {
 334       return ARB_texture_cube_map_array_enable ||
 335              EXT_texture_cube_map_array_enable ||
 336              OES_texture_cube_map_array_enable ||
 337              is_version(400, 320);
 338    }
 339
 340    bool has_shader_image_load_store() const
 341    {
 342       return ARB_shader_image_load_store_enable ||
 343              EXT_shader_image_load_store_enable ||
 344              is_version(420, 310);
 345    }
 346
 347    bool has_bindless() const
 348    {
 349       return ARB_bindless_texture_enable;
 350    }
 351
 352    bool has_image_load_formatted() const
 353    {
 354       return EXT_shader_image_load_formatted_enable;
 355    }
 356
 357    bool has_implicit_conversions() const
 358    {
 359       return EXT_shader_implicit_conversions_enable ||
 360              is_version(allow_glsl_120_subset_in_110 ? 110 : 120, 0);
 361    }
 362
 363    bool has_implicit_int_to_uint_conversion() const
 364    {
 365       return ARB_gpu_shader5_enable ||
 366              MESA_shader_integer_functions_enable ||
 367              EXT_shader_implicit_conversions_enable ||
 368              is_version(400, 0);
 369    }
 370
 371    void process_version_directive(YYLTYPE *locp, int version,
 372                                   const char *ident);
 373
 374    struct gl_context *const ctx;
 375    void *scanner;
 376    exec_list translation_unit;
 377    glsl_symbol_table *symbols;
 378
 379    void *linalloc;
 380
 381    unsigned num_supported_versions;
 382    struct {
 383       unsigned ver;
 384       uint8_t gl_ver;
 385       bool es;
 386    } supported_versions[17];
 387
 388    bool es_shader;
 389    bool compat_shader;
 390    unsigned language_version;
 391    unsigned forced_language_version;
 392    /* Bitfield of ir_variable_mode to zero init */
 393    uint32_t zero_init;
 394    unsigned gl_version;
 395    gl_shader_stage stage;
 396
 397    /**
 398     * Default uniform layout qualifiers tracked during parsing.
 399     * Currently affects uniform blocks and uniform buffer variables in
 400     * those blocks.
 401     */
 402    struct ast_type_qualifier *default_uniform_qualifier;
 403
 404    /**
 405     * Default shader storage layout qualifiers tracked during parsing.
 406     * Currently affects shader storage blocks and shader storage buffer
 407     * variables in those blocks.
 408     */
 409    struct ast_type_qualifier *default_shader_storage_qualifier;
 410
 411    /**
 412     * Variables to track different cases if a fragment shader redeclares
 413     * built-in variable gl_FragCoord.
 414     *
 415     * Note: These values are computed at ast_to_hir time rather than at parse
 416     * time.
 417     */
 418    bool fs_redeclares_gl_fragcoord;
 419    bool fs_origin_upper_left;
 420    bool fs_pixel_center_integer;
 421    bool fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
 422
 423    /**
 424     * True if a geometry shader input primitive type or tessellation control
 425     * output vertices were specified using a layout directive.
 426     *
 427     * Note: these values are computed at ast_to_hir time rather than at parse
 428     * time.
 429     */
 430    bool gs_input_prim_type_specified;
 431    bool tcs_output_vertices_specified;
 432
 433    /**
 434     * Input layout qualifiers from GLSL 1.50 (geometry shader controls),
 435     * and GLSL 4.00 (tessellation evaluation shader)
 436     */
 437    struct ast_type_qualifier *in_qualifier;
 438
 439    /**
 440     * True if a compute shader input local size was specified using a layout
 441     * directive.
 442     *
 443     * Note: this value is computed at ast_to_hir time rather than at parse
 444     * time.
 445     */
 446    bool cs_input_local_size_specified;
 447
 448    /**
 449     * If cs_input_local_size_specified is true, the local size that was
 450     * specified.  Otherwise ignored.
 451     */
 452    unsigned cs_input_local_size[3];
 453
 454    /**
 455     * True if a compute shader input local variable size was specified using
 456     * a layout directive as specified by ARB_compute_variable_group_size.
 457     */
 458    bool cs_input_local_size_variable_specified;
 459
 460    /**
 461     * Arrangement of invocations used to calculate derivatives in a compute
 462     * shader.  From NV_compute_shader_derivatives.
 463     */
 464    enum gl_derivative_group cs_derivative_group;
 465
 466    /**
 467     * True if a shader declare bindless_sampler/bindless_image, and
 468     * respectively bound_sampler/bound_image at global scope as specified by
 469     * ARB_bindless_texture.
 470     */
 471    bool bindless_sampler_specified;
 472    bool bindless_image_specified;
 473    bool bound_sampler_specified;
 474    bool bound_image_specified;
 475
 476    /**
 477     * Output layout qualifiers from GLSL 1.50 (geometry shader controls),
 478     * and GLSL 4.00 (tessellation control shader).
 479     */
 480    struct ast_type_qualifier *out_qualifier;
 481
 482    /**
 483     * Printable list of GLSL versions supported by the current context
 484     *
 485     * \note
 486     * This string should probably be generated per-context instead of per
 487     * invokation of the compiler.  This should be changed when the method of
 488     * tracking supported GLSL versions changes.
 489     */
 490    const char *supported_version_string;
 491
 492    /**
 493     * Implementation defined limits that affect built-in variables, etc.
 494     *
 495     * \sa struct gl_constants (in mtypes.h)
 496     */
 497    struct {
 498       /* 1.10 */
 499       unsigned MaxLights;
 500       unsigned MaxClipPlanes;
 501       unsigned MaxTextureUnits;
 502       unsigned MaxTextureCoords;
 503       unsigned MaxVertexAttribs;
 504       unsigned MaxVertexUniformComponents;
 505       unsigned MaxVertexTextureImageUnits;
 506       unsigned MaxCombinedTextureImageUnits;
 507       unsigned MaxTextureImageUnits;
 508       unsigned MaxFragmentUniformComponents;
 509
 510       /* ARB_draw_buffers */
 511       unsigned MaxDrawBuffers;
 512
 513       /* ARB_enhanced_layouts */
 514       unsigned MaxTransformFeedbackBuffers;
 515       unsigned MaxTransformFeedbackInterleavedComponents;
 516
 517       /* ARB_blend_func_extended */
 518       unsigned MaxDualSourceDrawBuffers;
 519
 520       /* 3.00 ES */
 521       int MinProgramTexelOffset;
 522       int MaxProgramTexelOffset;
 523
 524       /* 1.50 */
 525       unsigned MaxVertexOutputComponents;
 526       unsigned MaxGeometryInputComponents;
 527       unsigned MaxGeometryOutputComponents;
 528       unsigned MaxGeometryShaderInvocations;
 529       unsigned MaxFragmentInputComponents;
 530       unsigned MaxGeometryTextureImageUnits;
 531       unsigned MaxGeometryOutputVertices;
 532       unsigned MaxGeometryTotalOutputComponents;
 533       unsigned MaxGeometryUniformComponents;
 534
 535       /* ARB_shader_atomic_counters */
 536       unsigned MaxVertexAtomicCounters;
 537       unsigned MaxTessControlAtomicCounters;
 538       unsigned MaxTessEvaluationAtomicCounters;
 539       unsigned MaxGeometryAtomicCounters;
 540       unsigned MaxFragmentAtomicCounters;
 541       unsigned MaxCombinedAtomicCounters;
 542       unsigned MaxAtomicBufferBindings;
 543
 544       /* These are also atomic counter related, but they weren't added to
 545        * until atomic counters were added to core in GLSL 4.20 and GLSL ES
 546        * 3.10.
 547        */
 548       unsigned MaxVertexAtomicCounterBuffers;
 549       unsigned MaxTessControlAtomicCounterBuffers;
 550       unsigned MaxTessEvaluationAtomicCounterBuffers;
 551       unsigned MaxGeometryAtomicCounterBuffers;
 552       unsigned MaxFragmentAtomicCounterBuffers;
 553       unsigned MaxCombinedAtomicCounterBuffers;
 554       unsigned MaxAtomicCounterBufferSize;
 555
 556       /* ARB_compute_shader */
 557       unsigned MaxComputeAtomicCounterBuffers;
 558       unsigned MaxComputeAtomicCounters;
 559       unsigned MaxComputeImageUniforms;
 560       unsigned MaxComputeTextureImageUnits;
 561       unsigned MaxComputeUniformComponents;
 562       unsigned MaxComputeWorkGroupCount[3];
 563       unsigned MaxComputeWorkGroupSize[3];
 564
 565       /* ARB_shader_image_load_store */
 566       unsigned MaxImageUnits;
 567       unsigned MaxCombinedShaderOutputResources;
 568       unsigned MaxImageSamples;
 569       unsigned MaxVertexImageUniforms;
 570       unsigned MaxTessControlImageUniforms;
 571       unsigned MaxTessEvaluationImageUniforms;
 572       unsigned MaxGeometryImageUniforms;
 573       unsigned MaxFragmentImageUniforms;
 574       unsigned MaxCombinedImageUniforms;
 575
 576       /* ARB_viewport_array */
 577       unsigned MaxViewports;
 578
 579       /* ARB_tessellation_shader */
 580       unsigned MaxPatchVertices;
 581       unsigned MaxTessGenLevel;
 582       unsigned MaxTessControlInputComponents;
 583       unsigned MaxTessControlOutputComponents;
 584       unsigned MaxTessControlTextureImageUnits;
 585       unsigned MaxTessEvaluationInputComponents;
 586       unsigned MaxTessEvaluationOutputComponents;
 587       unsigned MaxTessEvaluationTextureImageUnits;
 588       unsigned MaxTessPatchComponents;
 589       unsigned MaxTessControlTotalOutputComponents;
 590       unsigned MaxTessControlUniformComponents;
 591       unsigned MaxTessEvaluationUniformComponents;
 592
 593       /* GL 4.5 / OES_sample_variables */
 594       unsigned MaxSamples;
 595    } Const;
 596
 597    /**
 598     * During AST to IR conversion, pointer to current IR function
 599     *
 600     * Will be \c NULL whenever the AST to IR conversion is not inside a
 601     * function definition.
 602     */
 603    class ir_function_signature *current_function;
 604
 605    /**
 606     * During AST to IR conversion, pointer to the toplevel IR
 607     * instruction list being generated.
 608     */
 609    exec_list *toplevel_ir;
 610
 611    /** Have we found a return statement in this function? */
 612    bool found_return;
 613
 614    /** Have we found the interlock builtins in this function? */
 615    bool found_begin_interlock;
 616    bool found_end_interlock;
 617
 618    /** Was there an error during compilation? */
 619    bool error;
 620
 621    /**
 622     * Are all shader inputs / outputs invariant?
 623     *
 624     * This is set when the 'STDGL invariant(all)' pragma is used.
 625     */
 626    bool all_invariant;
 627
 628    /** Loop or switch statement containing the current instructions. */
 629    class ast_iteration_statement *loop_nesting_ast;
 630
 631    struct glsl_switch_state switch_state;
 632
 633    /** List of structures defined in user code. */
 634    const glsl_type **user_structures;
 635    unsigned num_user_structures;
 636
 637    char *info_log;
 638
 639    /**
 640     * Are warnings enabled?
 641     *
 642     * Emission of warngins is controlled by '#pragma warning(...)'.
 643     */
 644    bool warnings_enabled;
 645
 646    /**
 647     * \name Enable bits for GLSL extensions
 648     */
 649    /*@{*/
 650    /* ARB extensions go here, sorted alphabetically.
 651     */
 652    bool ARB_ES3_1_compatibility_enable;
 653    bool ARB_ES3_1_compatibility_warn;
 654    bool ARB_ES3_2_compatibility_enable;
 655    bool ARB_ES3_2_compatibility_warn;
 656    bool ARB_arrays_of_arrays_enable;
 657    bool ARB_arrays_of_arrays_warn;
 658    bool ARB_bindless_texture_enable;
 659    bool ARB_bindless_texture_warn;
 660    bool ARB_compatibility_enable;
 661    bool ARB_compatibility_warn;
 662    bool ARB_compute_shader_enable;
 663    bool ARB_compute_shader_warn;
 664    bool ARB_compute_variable_group_size_enable;
 665    bool ARB_compute_variable_group_size_warn;
 666    bool ARB_conservative_depth_enable;
 667    bool ARB_conservative_depth_warn;
 668    bool ARB_cull_distance_enable;
 669    bool ARB_cull_distance_warn;
 670    bool ARB_derivative_control_enable;
 671    bool ARB_derivative_control_warn;
 672    bool ARB_draw_buffers_enable;
 673    bool ARB_draw_buffers_warn;
 674    bool ARB_draw_instanced_enable;
 675    bool ARB_draw_instanced_warn;
 676    bool ARB_enhanced_layouts_enable;
 677    bool ARB_enhanced_layouts_warn;
 678    bool ARB_explicit_attrib_location_enable;
 679    bool ARB_explicit_attrib_location_warn;
 680    bool ARB_explicit_uniform_location_enable;
 681    bool ARB_explicit_uniform_location_warn;
 682    bool ARB_fragment_coord_conventions_enable;
 683    bool ARB_fragment_coord_conventions_warn;
 684    bool ARB_fragment_layer_viewport_enable;
 685    bool ARB_fragment_layer_viewport_warn;
 686    bool ARB_fragment_shader_interlock_enable;
 687    bool ARB_fragment_shader_interlock_warn;
 688    bool ARB_gpu_shader5_enable;
 689    bool ARB_gpu_shader5_warn;
 690    bool ARB_gpu_shader_fp64_enable;
 691    bool ARB_gpu_shader_fp64_warn;
 692    bool ARB_gpu_shader_int64_enable;
 693    bool ARB_gpu_shader_int64_warn;
 694    bool ARB_post_depth_coverage_enable;
 695    bool ARB_post_depth_coverage_warn;
 696    bool ARB_sample_shading_enable;
 697    bool ARB_sample_shading_warn;
 698    bool ARB_separate_shader_objects_enable;
 699    bool ARB_separate_shader_objects_warn;
 700    bool ARB_shader_atomic_counter_ops_enable;
 701    bool ARB_shader_atomic_counter_ops_warn;
 702    bool ARB_shader_atomic_counters_enable;
 703    bool ARB_shader_atomic_counters_warn;
 704    bool ARB_shader_ballot_enable;
 705    bool ARB_shader_ballot_warn;
 706    bool ARB_shader_bit_encoding_enable;
 707    bool ARB_shader_bit_encoding_warn;
 708    bool ARB_shader_clock_enable;
 709    bool ARB_shader_clock_warn;
 710    bool ARB_shader_draw_parameters_enable;
 711    bool ARB_shader_draw_parameters_warn;
 712    bool ARB_shader_group_vote_enable;
 713    bool ARB_shader_group_vote_warn;
 714    bool ARB_shader_image_load_store_enable;
 715    bool ARB_shader_image_load_store_warn;
 716    bool ARB_shader_image_size_enable;
 717    bool ARB_shader_image_size_warn;
 718    bool ARB_shader_precision_enable;
 719    bool ARB_shader_precision_warn;
 720    bool ARB_shader_stencil_export_enable;
 721    bool ARB_shader_stencil_export_warn;
 722    bool ARB_shader_storage_buffer_object_enable;
 723    bool ARB_shader_storage_buffer_object_warn;
 724    bool ARB_shader_subroutine_enable;
 725    bool ARB_shader_subroutine_warn;
 726    bool ARB_shader_texture_image_samples_enable;
 727    bool ARB_shader_texture_image_samples_warn;
 728    bool ARB_shader_texture_lod_enable;
 729    bool ARB_shader_texture_lod_warn;
 730    bool ARB_shader_viewport_layer_array_enable;
 731    bool ARB_shader_viewport_layer_array_warn;
 732    bool ARB_shading_language_420pack_enable;
 733    bool ARB_shading_language_420pack_warn;
 734    bool ARB_shading_language_include_enable;
 735    bool ARB_shading_language_include_warn;
 736    bool ARB_shading_language_packing_enable;
 737    bool ARB_shading_language_packing_warn;
 738    bool ARB_tessellation_shader_enable;
 739    bool ARB_tessellation_shader_warn;
 740    bool ARB_texture_cube_map_array_enable;
 741    bool ARB_texture_cube_map_array_warn;
 742    bool ARB_texture_gather_enable;
 743    bool ARB_texture_gather_warn;
 744    bool ARB_texture_multisample_enable;
 745    bool ARB_texture_multisample_warn;
 746    bool ARB_texture_query_levels_enable;
 747    bool ARB_texture_query_levels_warn;
 748    bool ARB_texture_query_lod_enable;
 749    bool ARB_texture_query_lod_warn;
 750    bool ARB_texture_rectangle_enable;
 751    bool ARB_texture_rectangle_warn;
 752    bool ARB_uniform_buffer_object_enable;
 753    bool ARB_uniform_buffer_object_warn;
 754    bool ARB_vertex_attrib_64bit_enable;
 755    bool ARB_vertex_attrib_64bit_warn;
 756    bool ARB_viewport_array_enable;
 757    bool ARB_viewport_array_warn;
 758
 759    /* KHR extensions go here, sorted alphabetically.
 760     */
 761    bool KHR_blend_equation_advanced_enable;
 762    bool KHR_blend_equation_advanced_warn;
 763
 764    /* OES extensions go here, sorted alphabetically.
 765     */
 766    bool OES_EGL_image_external_enable;
 767    bool OES_EGL_image_external_warn;
 768    bool OES_EGL_image_external_essl3_enable;
 769    bool OES_EGL_image_external_essl3_warn;
 770    bool OES_geometry_point_size_enable;
 771    bool OES_geometry_point_size_warn;
 772    bool OES_geometry_shader_enable;
 773    bool OES_geometry_shader_warn;
 774    bool OES_gpu_shader5_enable;
 775    bool OES_gpu_shader5_warn;
 776    bool OES_primitive_bounding_box_enable;
 777    bool OES_primitive_bounding_box_warn;
 778    bool OES_sample_variables_enable;
 779    bool OES_sample_variables_warn;
 780    bool OES_shader_image_atomic_enable;
 781    bool OES_shader_image_atomic_warn;
 782    bool OES_shader_io_blocks_enable;
 783    bool OES_shader_io_blocks_warn;
 784    bool OES_shader_multisample_interpolation_enable;
 785    bool OES_shader_multisample_interpolation_warn;
 786    bool OES_standard_derivatives_enable;
 787    bool OES_standard_derivatives_warn;
 788    bool OES_tessellation_point_size_enable;
 789    bool OES_tessellation_point_size_warn;
 790    bool OES_tessellation_shader_enable;
 791    bool OES_tessellation_shader_warn;
 792    bool OES_texture_3D_enable;
 793    bool OES_texture_3D_warn;
 794    bool OES_texture_buffer_enable;
 795    bool OES_texture_buffer_warn;
 796    bool OES_texture_cube_map_array_enable;
 797    bool OES_texture_cube_map_array_warn;
 798    bool OES_texture_storage_multisample_2d_array_enable;
 799    bool OES_texture_storage_multisample_2d_array_warn;
 800    bool OES_viewport_array_enable;
 801    bool OES_viewport_array_warn;
 802
 803    /* All other extensions go here, sorted alphabetically.
 804     */
 805    bool AMD_conservative_depth_enable;
 806    bool AMD_conservative_depth_warn;
 807    bool AMD_gpu_shader_int64_enable;
 808    bool AMD_gpu_shader_int64_warn;
 809    bool AMD_shader_stencil_export_enable;
 810    bool AMD_shader_stencil_export_warn;
 811    bool AMD_shader_trinary_minmax_enable;
 812    bool AMD_shader_trinary_minmax_warn;
 813    bool AMD_texture_texture4_enable;
 814    bool AMD_texture_texture4_warn;
 815    bool AMD_vertex_shader_layer_enable;
 816    bool AMD_vertex_shader_layer_warn;
 817    bool AMD_vertex_shader_viewport_index_enable;
 818    bool AMD_vertex_shader_viewport_index_warn;
 819    bool ANDROID_extension_pack_es31a_enable;
 820    bool ANDROID_extension_pack_es31a_warn;
 821    bool EXT_blend_func_extended_enable;
 822    bool EXT_blend_func_extended_warn;
 823    bool EXT_clip_cull_distance_enable;
 824    bool EXT_clip_cull_distance_warn;
 825    bool EXT_demote_to_helper_invocation_enable;
 826    bool EXT_demote_to_helper_invocation_warn;
 827    bool EXT_draw_buffers_enable;
 828    bool EXT_draw_buffers_warn;
 829    bool EXT_draw_instanced_enable;
 830    bool EXT_draw_instanced_warn;
 831    bool EXT_frag_depth_enable;
 832    bool EXT_frag_depth_warn;
 833    bool EXT_geometry_point_size_enable;
 834    bool EXT_geometry_point_size_warn;
 835    bool EXT_geometry_shader_enable;
 836    bool EXT_geometry_shader_warn;
 837    bool EXT_gpu_shader4_enable;
 838    bool EXT_gpu_shader4_warn;
 839    bool EXT_gpu_shader5_enable;
 840    bool EXT_gpu_shader5_warn;
 841    bool EXT_primitive_bounding_box_enable;
 842    bool EXT_primitive_bounding_box_warn;
 843    bool EXT_separate_shader_objects_enable;
 844    bool EXT_separate_shader_objects_warn;
 845    bool EXT_shader_framebuffer_fetch_enable;
 846    bool EXT_shader_framebuffer_fetch_warn;
 847    bool EXT_shader_framebuffer_fetch_non_coherent_enable;
 848    bool EXT_shader_framebuffer_fetch_non_coherent_warn;
 849    bool EXT_shader_group_vote_enable;
 850    bool EXT_shader_group_vote_warn;
 851    bool EXT_shader_image_load_formatted_enable;
 852    bool EXT_shader_image_load_formatted_warn;
 853    bool EXT_shader_image_load_store_enable;
 854    bool EXT_shader_image_load_store_warn;
 855    bool EXT_shader_implicit_conversions_enable;
 856    bool EXT_shader_implicit_conversions_warn;
 857    bool EXT_shader_integer_mix_enable;
 858    bool EXT_shader_integer_mix_warn;
 859    bool EXT_shader_io_blocks_enable;
 860    bool EXT_shader_io_blocks_warn;
 861    bool EXT_shader_samples_identical_enable;
 862    bool EXT_shader_samples_identical_warn;
 863    bool EXT_tessellation_point_size_enable;
 864    bool EXT_tessellation_point_size_warn;
 865    bool EXT_tessellation_shader_enable;
 866    bool EXT_tessellation_shader_warn;
 867    bool EXT_texture_array_enable;
 868    bool EXT_texture_array_warn;
 869    bool EXT_texture_buffer_enable;
 870    bool EXT_texture_buffer_warn;
 871    bool EXT_texture_cube_map_array_enable;
 872    bool EXT_texture_cube_map_array_warn;
 873    bool EXT_texture_query_lod_enable;
 874    bool EXT_texture_query_lod_warn;
 875    bool EXT_texture_shadow_lod_enable;
 876    bool EXT_texture_shadow_lod_warn;
 877    bool INTEL_conservative_rasterization_enable;
 878    bool INTEL_conservative_rasterization_warn;
 879    bool INTEL_shader_atomic_float_minmax_enable;
 880    bool INTEL_shader_atomic_float_minmax_warn;
 881    bool INTEL_shader_integer_functions2_enable;
 882    bool INTEL_shader_integer_functions2_warn;
 883    bool MESA_shader_integer_functions_enable;
 884    bool MESA_shader_integer_functions_warn;
 885    bool NV_compute_shader_derivatives_enable;
 886    bool NV_compute_shader_derivatives_warn;
 887    bool NV_fragment_shader_interlock_enable;
 888    bool NV_fragment_shader_interlock_warn;
 889    bool NV_image_formats_enable;
 890    bool NV_image_formats_warn;
 891    bool NV_shader_atomic_float_enable;
 892    bool NV_shader_atomic_float_warn;
 893    bool NV_viewport_array2_enable;
 894    bool NV_viewport_array2_warn;
 895    /*@}*/
 896
 897    /** Extensions supported by the OpenGL implementation. */
 898    const struct gl_extensions *extensions;
 899
 900    bool uses_builtin_functions;
 901    bool fs_uses_gl_fragcoord;
 902
 903    /**
 904     * For geometry shaders, size of the most recently seen input declaration
 905     * that was a sized array, or 0 if no sized input array declarations have
 906     * been seen.
 907     *
 908     * Unused for other shader types.
 909     */
 910    unsigned gs_input_size;
 911
 912    bool fs_early_fragment_tests;
 913
 914    bool fs_inner_coverage;
 915
 916    bool fs_post_depth_coverage;
 917
 918    bool fs_pixel_interlock_ordered;
 919    bool fs_pixel_interlock_unordered;
 920    bool fs_sample_interlock_ordered;
 921    bool fs_sample_interlock_unordered;
 922
 923    unsigned fs_blend_support;
 924
 925    /**
 926     * For tessellation control shaders, size of the most recently seen output
 927     * declaration that was a sized array, or 0 if no sized output array
 928     * declarations have been seen.
 929     *
 930     * Unused for other shader types.
 931     */
 932    unsigned tcs_output_size;
 933
 934    /** Atomic counter offsets by binding */
 935    unsigned atomic_counter_offsets[MAX_COMBINED_ATOMIC_BUFFERS];
 936
 937    /** Whether gl_Layer output is viewport-relative. */
 938    bool redeclares_gl_layer;
 939    bool layer_viewport_relative;
 940
 941    bool allow_extension_directive_midshader;
 942    bool allow_glsl_120_subset_in_110;
 943    bool allow_builtin_variable_redeclaration;
 944    bool allow_layout_qualifier_on_function_parameter;
 945
 946    /**
 947     * Known subroutine type declarations.
 948     */
 949    int num_subroutine_types;
 950    ir_function **subroutine_types;
 951
 952    /**
 953     * Functions that are associated with
 954     * subroutine types.
 955     */
 956    int num_subroutines;
 957    ir_function **subroutines;
 958
 959    /**
 960     * field selection temporary parser storage -
 961     * did the parser just parse a dot.
 962     */
 963    bool is_field;
 964
 965    /**
 966     * seen values for clip/cull distance sizes
 967     * so we can check totals aren't too large.
 968     */
 969    unsigned clip_dist_size, cull_dist_size;
 970 };
 971
 972 # define YYLLOC_DEFAULT(Current, Rhs, N)                        \
 973 do {                                                            \
 974    if (N)                                                       \
 975    {                                                            \
 976       (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;     \
 977       (Current).first_column = YYRHSLOC(Rhs, 1).first_column;   \
 978       (Current).last_line    = YYRHSLOC(Rhs, N).last_line;      \
 979       (Current).last_column  = YYRHSLOC(Rhs, N).last_column;    \
 980       (Current).path         = YYRHSLOC(Rhs, N).path;           \
 981    }                                                            \
 982    else                                                         \
 983    {                                                            \
 984       (Current).first_line   = (Current).last_line =            \
 985          YYRHSLOC(Rhs, 0).last_line;                            \
 986       (Current).first_column = (Current).last_column =          \
 987          YYRHSLOC(Rhs, 0).last_column;                          \
 988       (Current).path = YYRHSLOC(Rhs, 0).path;                   \
 989    }                                                            \
 990    (Current).source = 0;                                        \
 991 } while (0)
 992
 993 /**
 994  * Emit a warning to the shader log
 995  *
 996  * \sa _mesa_glsl_error
 997  */
 998 extern void _mesa_glsl_warning(const YYLTYPE *locp,
 999                                _mesa_glsl_parse_state *state,
1000                                const char *fmt, ...);
1001
1002 extern void _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state,
1003                                   const char *string);
1004
1005 extern void _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state);
1006
1007 union YYSTYPE;
1008 extern int _mesa_glsl_lexer_lex(union YYSTYPE *yylval, YYLTYPE *yylloc,
1009                                 void *scanner);
1010
1011 extern int _mesa_glsl_parse(struct _mesa_glsl_parse_state *);
1012
1013 /**
1014  * Process elements of the #extension directive
1015  *
1016  * \return
1017  * If \c name and \c behavior are valid, \c true is returned.  Otherwise
1018  * \c false is returned.
1019  */
1020 extern bool _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
1021                                          const char *behavior,
1022                                          YYLTYPE *behavior_locp,
1023                                          _mesa_glsl_parse_state *state);
1024
1025 #endif /* __cplusplus */
1026
1027
1028 /*
1029  * These definitions apply to C and C++
1030  */
1031 #ifdef __cplusplus
1032 extern "C" {
1033 #endif
1034
1035 struct glcpp_parser;
1036 struct _mesa_glsl_parse_state;
1037
1038 typedef void (*glcpp_extension_iterator)(
1039               struct _mesa_glsl_parse_state *state,
1040               void (*add_builtin_define)(struct glcpp_parser *, const char *, int),
1041               struct glcpp_parser *data,
1042               unsigned version,
1043               bool es);
1044
1045 extern int glcpp_preprocess(void *ctx, const char **shader, char **info_log,
1046                             glcpp_extension_iterator extensions,
1047                             struct _mesa_glsl_parse_state *state,
1048                             struct gl_context *gl_ctx);
1049
1050 extern void
1051 _mesa_glsl_copy_symbols_from_table(struct exec_list *shader_ir,
1052                                    struct glsl_symbol_table *src,
1053                                    struct glsl_symbol_table *dest);
1054
1055 #ifdef __cplusplus
1056 }
1057 #endif
1058
1059
1060 #endif /* GLSL_PARSER_EXTRAS_H */