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