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 #include "ast.h" 25 26 void 27 ast_type_specifier::print(void) const 28 { 29 if (structure) { 30 structure->print(); 31 } else { 32 printf("%s ", type_name); 33 } 34 35 if (array_specifier) { 36 array_specifier->print(); 37 } 38 } 39 40 bool 41 ast_fully_specified_type::has_qualifiers(_mesa_glsl_parse_state *state) const 42 { 43 /* 'subroutine' isnt a real qualifier. */ 44 ast_type_qualifier subroutine_only; 45 subroutine_only.flags.i = 0; 46 subroutine_only.flags.q.subroutine = 1; 47 if (state->has_explicit_uniform_location()) { 48 subroutine_only.flags.q.explicit_index = 1; 49 } 50 return (this->qualifier.flags.i & ~subroutine_only.flags.i) != 0; 51 } 52 53 bool ast_type_qualifier::has_interpolation() const 54 { 55 return this->flags.q.smooth 56 || this->flags.q.flat 57 || this->flags.q.noperspective; 58 } 59 60 bool 61 ast_type_qualifier::has_layout() const 62 { 63 return this->flags.q.origin_upper_left 64 || this->flags.q.pixel_center_integer 65 || this->flags.q.depth_type 66 || this->flags.q.std140 67 || this->flags.q.std430 68 || this->flags.q.shared 69 || this->flags.q.column_major 70 || this->flags.q.row_major 71 || this->flags.q.packed 72 || this->flags.q.bindless_sampler 73 || this->flags.q.bindless_image 74 || this->flags.q.bound_sampler 75 || this->flags.q.bound_image 76 || this->flags.q.explicit_align 77 || this->flags.q.explicit_component 78 || this->flags.q.explicit_location 79 || this->flags.q.explicit_image_format 80 || this->flags.q.explicit_index 81 || this->flags.q.explicit_binding 82 || this->flags.q.explicit_offset 83 || this->flags.q.explicit_stream 84 || this->flags.q.explicit_xfb_buffer 85 || this->flags.q.explicit_xfb_offset 86 || this->flags.q.explicit_xfb_stride; 87 } 88 89 bool 90 ast_type_qualifier::has_storage() const 91 { 92 return this->flags.q.constant 93 || this->flags.q.attribute 94 || this->flags.q.varying 95 || this->flags.q.in 96 || this->flags.q.out 97 || this->flags.q.uniform 98 || this->flags.q.buffer 99 || this->flags.q.shared_storage; 100 } 101 102 bool 103 ast_type_qualifier::has_auxiliary_storage() const 104 { 105 return this->flags.q.centroid 106 || this->flags.q.sample 107 || this->flags.q.patch; 108 } 109 110 bool ast_type_qualifier::has_memory() const 111 { 112 return this->flags.q.coherent 113 || this->flags.q._volatile 114 || this->flags.q.restrict_flag 115 || this->flags.q.read_only 116 || this->flags.q.write_only; 117 } 118 119 bool ast_type_qualifier::is_subroutine_decl() const 120 { 121 return this->flags.q.subroutine && !this->subroutine_list; 122 } 123 124 static bool 125 validate_prim_type(YYLTYPE *loc, 126 _mesa_glsl_parse_state *state, 127 const ast_type_qualifier &qualifier, 128 const ast_type_qualifier &new_qualifier) 129 { 130 /* Input layout qualifiers can be specified multiple 131 * times in separate declarations, as long as they match. 132 */ 133 if (qualifier.flags.q.prim_type && new_qualifier.flags.q.prim_type 134 && qualifier.prim_type != new_qualifier.prim_type) { 135 _mesa_glsl_error(loc, state, 136 "conflicting input primitive %s specified", 137 state->stage == MESA_SHADER_GEOMETRY ? 138 "type" : "mode"); 139 return false; 140 } 141 142 return true; 143 } 144 145 static bool 146 validate_vertex_spacing(YYLTYPE *loc, 147 _mesa_glsl_parse_state *state, 148 const ast_type_qualifier &qualifier, 149 const ast_type_qualifier &new_qualifier) 150 { 151 if (qualifier.flags.q.vertex_spacing && new_qualifier.flags.q.vertex_spacing 152 && qualifier.vertex_spacing != new_qualifier.vertex_spacing) { 153 _mesa_glsl_error(loc, state, 154 "conflicting vertex spacing specified"); 155 return false; 156 } 157 158 return true; 159 } 160 161 static bool 162 validate_ordering(YYLTYPE *loc, 163 _mesa_glsl_parse_state *state, 164 const ast_type_qualifier &qualifier, 165 const ast_type_qualifier &new_qualifier) 166 { 167 if (qualifier.flags.q.ordering && new_qualifier.flags.q.ordering 168 && qualifier.ordering != new_qualifier.ordering) { 169 _mesa_glsl_error(loc, state, 170 "conflicting ordering specified"); 171 return false; 172 } 173 174 return true; 175 } 176 177 static bool 178 validate_point_mode(MAYBE_UNUSED const ast_type_qualifier &qualifier, 179 MAYBE_UNUSED const ast_type_qualifier &new_qualifier) 180 { 181 /* Point mode can only be true if the flag is set. */ 182 assert (!qualifier.flags.q.point_mode || !new_qualifier.flags.q.point_mode 183 || (qualifier.point_mode && new_qualifier.point_mode)); 184 185 return true; 186 } 187 188 static void 189 merge_bindless_qualifier(_mesa_glsl_parse_state *state) 190 { 191 if (state->default_uniform_qualifier->flags.q.bindless_sampler) { 192 state->bindless_sampler_specified = true; 193 state->default_uniform_qualifier->flags.q.bindless_sampler = false; 194 } 195 196 if (state->default_uniform_qualifier->flags.q.bindless_image) { 197 state->bindless_image_specified = true; 198 state->default_uniform_qualifier->flags.q.bindless_image = false; 199 } 200 201 if (state->default_uniform_qualifier->flags.q.bound_sampler) { 202 state->bound_sampler_specified = true; 203 state->default_uniform_qualifier->flags.q.bound_sampler = false; 204 } 205 206 if (state->default_uniform_qualifier->flags.q.bound_image) { 207 state->bound_image_specified = true; 208 state->default_uniform_qualifier->flags.q.bound_image = false; 209 } 210 } 211 212 /** 213 * This function merges duplicate layout identifiers. 214 * 215 * It deals with duplicates within a single layout qualifier, among multiple 216 * layout qualifiers on a single declaration and on several declarations for 217 * the same variable. 218 * 219 * The is_single_layout_merge and is_multiple_layouts_merge parameters are 220 * used to differentiate among them. 221 */ 222 bool 223 ast_type_qualifier::merge_qualifier(YYLTYPE *loc, 224 _mesa_glsl_parse_state *state, 225 const ast_type_qualifier &q, 226 bool is_single_layout_merge, 227 bool is_multiple_layouts_merge) 228 { 229 bool r = true; 230 ast_type_qualifier ubo_mat_mask; 231 ubo_mat_mask.flags.i = 0; 232 ubo_mat_mask.flags.q.row_major = 1; 233 ubo_mat_mask.flags.q.column_major = 1; 234 235 ast_type_qualifier ubo_layout_mask; 236 ubo_layout_mask.flags.i = 0; 237 ubo_layout_mask.flags.q.std140 = 1; 238 ubo_layout_mask.flags.q.packed = 1; 239 ubo_layout_mask.flags.q.shared = 1; 240 ubo_layout_mask.flags.q.std430 = 1; 241 242 ast_type_qualifier ubo_binding_mask; 243 ubo_binding_mask.flags.i = 0; 244 ubo_binding_mask.flags.q.explicit_binding = 1; 245 ubo_binding_mask.flags.q.explicit_offset = 1; 246 247 ast_type_qualifier stream_layout_mask; 248 stream_layout_mask.flags.i = 0; 249 stream_layout_mask.flags.q.stream = 1; 250 251 /* FIXME: We should probably do interface and function param validation 252 * separately. 253 */ 254 ast_type_qualifier input_layout_mask; 255 input_layout_mask.flags.i = 0; 256 input_layout_mask.flags.q.centroid = 1; 257 /* Function params can have constant */ 258 input_layout_mask.flags.q.constant = 1; 259 input_layout_mask.flags.q.explicit_component = 1; 260 input_layout_mask.flags.q.explicit_location = 1; 261 input_layout_mask.flags.q.flat = 1; 262 input_layout_mask.flags.q.in = 1; 263 input_layout_mask.flags.q.invariant = 1; 264 input_layout_mask.flags.q.noperspective = 1; 265 input_layout_mask.flags.q.origin_upper_left = 1; 266 /* Function params 'inout' will set this */ 267 input_layout_mask.flags.q.out = 1; 268 input_layout_mask.flags.q.patch = 1; 269 input_layout_mask.flags.q.pixel_center_integer = 1; 270 input_layout_mask.flags.q.precise = 1; 271 input_layout_mask.flags.q.sample = 1; 272 input_layout_mask.flags.q.smooth = 1; 273 274 if (state->has_bindless()) { 275 /* Allow to use image qualifiers with shader inputs/outputs. */ 276 input_layout_mask.flags.q.coherent = 1; 277 input_layout_mask.flags.q._volatile = 1; 278 input_layout_mask.flags.q.restrict_flag = 1; 279 input_layout_mask.flags.q.read_only = 1; 280 input_layout_mask.flags.q.write_only = 1; 281 input_layout_mask.flags.q.explicit_image_format = 1; 282 } 283 284 /* Uniform block layout qualifiers get to overwrite each 285 * other (rightmost having priority), while all other 286 * qualifiers currently don't allow duplicates. 287 */ 288 ast_type_qualifier allowed_duplicates_mask; 289 allowed_duplicates_mask.flags.i = 290 ubo_mat_mask.flags.i | 291 ubo_layout_mask.flags.i | 292 ubo_binding_mask.flags.i; 293 294 /* Geometry shaders can have several layout qualifiers 295 * assigning different stream values. 296 */ 297 if (state->stage == MESA_SHADER_GEOMETRY) { 298 allowed_duplicates_mask.flags.i |= 299 stream_layout_mask.flags.i; 300 } 301 302 if (is_single_layout_merge && !state->has_enhanced_layouts() && 303 (this->flags.i & q.flags.i & ~allowed_duplicates_mask.flags.i) != 0) { 304 _mesa_glsl_error(loc, state, "duplicate layout qualifiers used"); 305 return false; 306 } 307 308 if (is_multiple_layouts_merge && !state->has_420pack_or_es31()) { 309 _mesa_glsl_error(loc, state, 310 "duplicate layout(...) qualifiers"); 311 return false; 312 } 313 314 if (q.flags.q.prim_type) { 315 r &= validate_prim_type(loc, state, *this, q); 316 this->flags.q.prim_type = 1; 317 this->prim_type = q.prim_type; 318 } 319 320 if (q.flags.q.max_vertices) { 321 if (this->flags.q.max_vertices 322 && !is_single_layout_merge && !is_multiple_layouts_merge) { 323 this->max_vertices->merge_qualifier(q.max_vertices); 324 } else { 325 this->flags.q.max_vertices = 1; 326 this->max_vertices = q.max_vertices; 327 } 328 } 329 330 if (q.subroutine_list) { 331 if (this->subroutine_list) { 332 _mesa_glsl_error(loc, state, 333 "conflicting subroutine qualifiers used"); 334 } else { 335 this->subroutine_list = q.subroutine_list; 336 } 337 } 338 339 if (q.flags.q.invocations) { 340 if (this->flags.q.invocations 341 && !is_single_layout_merge && !is_multiple_layouts_merge) { 342 this->invocations->merge_qualifier(q.invocations); 343 } else { 344 this->flags.q.invocations = 1; 345 this->invocations = q.invocations; 346 } 347 } 348 349 if (state->stage == MESA_SHADER_GEOMETRY && 350 state->has_explicit_attrib_stream()) { 351 if (!this->flags.q.explicit_stream) { 352 if (q.flags.q.stream) { 353 this->flags.q.stream = 1; 354 this->stream = q.stream; 355 } else if (!this->flags.q.stream && this->flags.q.out && 356 !this->flags.q.in) { 357 /* Assign default global stream value */ 358 this->flags.q.stream = 1; 359 this->stream = state->out_qualifier->stream; 360 } 361 } 362 } 363 364 if (state->has_enhanced_layouts()) { 365 if (!this->flags.q.explicit_xfb_buffer) { 366 if (q.flags.q.xfb_buffer) { 367 this->flags.q.xfb_buffer = 1; 368 this->xfb_buffer = q.xfb_buffer; 369 } else if (!this->flags.q.xfb_buffer && this->flags.q.out && 370 !this->flags.q.in) { 371 /* Assign global xfb_buffer value */ 372 this->flags.q.xfb_buffer = 1; 373 this->xfb_buffer = state->out_qualifier->xfb_buffer; 374 } 375 } 376 377 if (q.flags.q.explicit_xfb_stride) { 378 this->flags.q.xfb_stride = 1; 379 this->flags.q.explicit_xfb_stride = 1; 380 this->xfb_stride = q.xfb_stride; 381 } 382 } 383 384 if (q.flags.q.vertices) { 385 if (this->flags.q.vertices 386 && !is_single_layout_merge && !is_multiple_layouts_merge) { 387 this->vertices->merge_qualifier(q.vertices); 388 } else { 389 this->flags.q.vertices = 1; 390 this->vertices = q.vertices; 391 } 392 } 393 394 if (q.flags.q.vertex_spacing) { 395 r &= validate_vertex_spacing(loc, state, *this, q); 396 this->flags.q.vertex_spacing = 1; 397 this->vertex_spacing = q.vertex_spacing; 398 } 399 400 if (q.flags.q.ordering) { 401 r &= validate_ordering(loc, state, *this, q); 402 this->flags.q.ordering = 1; 403 this->ordering = q.ordering; 404 } 405 406 if (q.flags.q.point_mode) { 407 r &= validate_point_mode(*this, q); 408 this->flags.q.point_mode = 1; 409 this->point_mode = q.point_mode; 410 } 411 412 if (q.flags.q.early_fragment_tests) 413 this->flags.q.early_fragment_tests = true; 414 415 if ((q.flags.i & ubo_mat_mask.flags.i) != 0) 416 this->flags.i &= ~ubo_mat_mask.flags.i; 417 if ((q.flags.i & ubo_layout_mask.flags.i) != 0) 418 this->flags.i &= ~ubo_layout_mask.flags.i; 419 420 for (int i = 0; i < 3; i++) { 421 if (q.flags.q.local_size & (1 << i)) { 422 if (this->local_size[i] 423 && !is_single_layout_merge && !is_multiple_layouts_merge) { 424 this->local_size[i]->merge_qualifier(q.local_size[i]); 425 } else { 426 this->local_size[i] = q.local_size[i]; 427 } 428 } 429 } 430 431 if (q.flags.q.local_size_variable) 432 this->flags.q.local_size_variable = true; 433 434 if (q.flags.q.bindless_sampler) 435 this->flags.q.bindless_sampler = true; 436 437 if (q.flags.q.bindless_image) 438 this->flags.q.bindless_image = true; 439 440 if (q.flags.q.bound_sampler) 441 this->flags.q.bound_sampler = true; 442 443 if (q.flags.q.bound_image) 444 this->flags.q.bound_image = true; 445 446 this->flags.i |= q.flags.i; 447 448 if (this->flags.q.in && 449 (this->flags.i & ~input_layout_mask.flags.i) != 0) { 450 _mesa_glsl_error(loc, state, "invalid input layout qualifier used"); 451 return false; 452 } 453 454 if (q.flags.q.explicit_align) 455 this->align = q.align; 456 457 if (q.flags.q.explicit_location) 458 this->location = q.location; 459 460 if (q.flags.q.explicit_index) 461 this->index = q.index; 462 463 if (q.flags.q.explicit_component) 464 this->component = q.component; 465 466 if (q.flags.q.explicit_binding) 467 this->binding = q.binding; 468 469 if (q.flags.q.explicit_offset || q.flags.q.explicit_xfb_offset) 470 this->offset = q.offset; 471 472 if (q.precision != ast_precision_none) 473 this->precision = q.precision; 474 475 if (q.flags.q.explicit_image_format) { 476 this->image_format = q.image_format; 477 this->image_base_type = q.image_base_type; 478 } 479 480 if (q.flags.q.bindless_sampler || 481 q.flags.q.bindless_image || 482 q.flags.q.bound_sampler || 483 q.flags.q.bound_image) 484 merge_bindless_qualifier(state); 485 486 return r; 487 } 488 489 bool 490 ast_type_qualifier::validate_out_qualifier(YYLTYPE *loc, 491 _mesa_glsl_parse_state *state) 492 { 493 bool r = true; 494 ast_type_qualifier valid_out_mask; 495 valid_out_mask.flags.i = 0; 496 497 switch (state->stage) { 498 case MESA_SHADER_GEOMETRY: 499 if (this->flags.q.prim_type) { 500 /* Make sure this is a valid output primitive type. */ 501 switch (this->prim_type) { 502 case GL_POINTS: 503 case GL_LINE_STRIP: 504 case GL_TRIANGLE_STRIP: 505 break; 506 default: 507 r = false; 508 _mesa_glsl_error(loc, state, "invalid geometry shader output " 509 "primitive type"); 510 break; 511 } 512 } 513 514 valid_out_mask.flags.q.stream = 1; 515 valid_out_mask.flags.q.explicit_stream = 1; 516 valid_out_mask.flags.q.explicit_xfb_buffer = 1; 517 valid_out_mask.flags.q.xfb_buffer = 1; 518 valid_out_mask.flags.q.explicit_xfb_stride = 1; 519 valid_out_mask.flags.q.xfb_stride = 1; 520 valid_out_mask.flags.q.max_vertices = 1; 521 valid_out_mask.flags.q.prim_type = 1; 522 break; 523 case MESA_SHADER_TESS_CTRL: 524 valid_out_mask.flags.q.vertices = 1; 525 valid_out_mask.flags.q.explicit_xfb_buffer = 1; 526 valid_out_mask.flags.q.xfb_buffer = 1; 527 valid_out_mask.flags.q.explicit_xfb_stride = 1; 528 valid_out_mask.flags.q.xfb_stride = 1; 529 break; 530 case MESA_SHADER_TESS_EVAL: 531 case MESA_SHADER_VERTEX: 532 valid_out_mask.flags.q.explicit_xfb_buffer = 1; 533 valid_out_mask.flags.q.xfb_buffer = 1; 534 valid_out_mask.flags.q.explicit_xfb_stride = 1; 535 valid_out_mask.flags.q.xfb_stride = 1; 536 break; 537 case MESA_SHADER_FRAGMENT: 538 valid_out_mask.flags.q.blend_support = 1; 539 break; 540 default: 541 r = false; 542 _mesa_glsl_error(loc, state, 543 "out layout qualifiers only valid in " 544 "geometry, tessellation, vertex and fragment shaders"); 545 } 546 547 /* Generate an error when invalid output layout qualifiers are used. */ 548 if ((this->flags.i & ~valid_out_mask.flags.i) != 0) { 549 r = false; 550 _mesa_glsl_error(loc, state, "invalid output layout qualifiers used"); 551 } 552 553 return r; 554 } 555 556 bool 557 ast_type_qualifier::merge_into_out_qualifier(YYLTYPE *loc, 558 _mesa_glsl_parse_state *state, 559 ast_node* &node) 560 { 561 const bool r = state->out_qualifier->merge_qualifier(loc, state, 562 *this, false); 563 564 switch (state->stage) { 565 case MESA_SHADER_GEOMETRY: 566 /* Allow future assignments of global out's stream id value */ 567 state->out_qualifier->flags.q.explicit_stream = 0; 568 break; 569 case MESA_SHADER_TESS_CTRL: 570 node = new(state->linalloc) ast_tcs_output_layout(*loc); 571 break; 572 default: 573 break; 574 } 575 576 /* Allow future assignments of global out's */ 577 state->out_qualifier->flags.q.explicit_xfb_buffer = 0; 578 state->out_qualifier->flags.q.explicit_xfb_stride = 0; 579 580 return r; 581 } 582 583 bool 584 ast_type_qualifier::validate_in_qualifier(YYLTYPE *loc, 585 _mesa_glsl_parse_state *state) 586 { 587 bool r = true; 588 ast_type_qualifier valid_in_mask; 589 valid_in_mask.flags.i = 0; 590 591 switch (state->stage) { 592 case MESA_SHADER_TESS_EVAL: 593 if (this->flags.q.prim_type) { 594 /* Make sure this is a valid input primitive type. */ 595 switch (this->prim_type) { 596 case GL_TRIANGLES: 597 case GL_QUADS: 598 case GL_ISOLINES: 599 break; 600 default: 601 r = false; 602 _mesa_glsl_error(loc, state, 603 "invalid tessellation evaluation " 604 "shader input primitive type"); 605 break; 606 } 607 } 608 609 valid_in_mask.flags.q.prim_type = 1; 610 valid_in_mask.flags.q.vertex_spacing = 1; 611 valid_in_mask.flags.q.ordering = 1; 612 valid_in_mask.flags.q.point_mode = 1; 613 break; 614 case MESA_SHADER_GEOMETRY: 615 if (this->flags.q.prim_type) { 616 /* Make sure this is a valid input primitive type. */ 617 switch (this->prim_type) { 618 case GL_POINTS: 619 case GL_LINES: 620 case GL_LINES_ADJACENCY: 621 case GL_TRIANGLES: 622 case GL_TRIANGLES_ADJACENCY: 623 break; 624 default: 625 r = false; 626 _mesa_glsl_error(loc, state, 627 "invalid geometry shader input primitive type"); 628 break; 629 } 630 } 631 632 valid_in_mask.flags.q.prim_type = 1; 633 valid_in_mask.flags.q.invocations = 1; 634 break; 635 case MESA_SHADER_FRAGMENT: 636 valid_in_mask.flags.q.early_fragment_tests = 1; 637 valid_in_mask.flags.q.inner_coverage = 1; 638 valid_in_mask.flags.q.post_depth_coverage = 1; 639 break; 640 case MESA_SHADER_COMPUTE: 641 valid_in_mask.flags.q.local_size = 7; 642 valid_in_mask.flags.q.local_size_variable = 1; 643 break; 644 default: 645 r = false; 646 _mesa_glsl_error(loc, state, 647 "input layout qualifiers only valid in " 648 "geometry, tessellation, fragment and compute shaders"); 649 break; 650 } 651 652 /* Generate an error when invalid input layout qualifiers are used. */ 653 if ((this->flags.i & ~valid_in_mask.flags.i) != 0) { 654 r = false; 655 _mesa_glsl_error(loc, state, "invalid input layout qualifiers used"); 656 } 657 658 /* The checks below are also performed when merging but we want to spit an 659 * error against the default global input qualifier as soon as we can, with 660 * the closest error location in the shader. 661 */ 662 r &= validate_prim_type(loc, state, *state->in_qualifier, *this); 663 r &= validate_vertex_spacing(loc, state, *state->in_qualifier, *this); 664 r &= validate_ordering(loc, state, *state->in_qualifier, *this); 665 r &= validate_point_mode(*state->in_qualifier, *this); 666 667 return r; 668 } 669 670 bool 671 ast_type_qualifier::merge_into_in_qualifier(YYLTYPE *loc, 672 _mesa_glsl_parse_state *state, 673 ast_node* &node) 674 { 675 bool r = true; 676 void *lin_ctx = state->linalloc; 677 678 /* We create the gs_input_layout node before merging so, in the future, no 679 * more repeated nodes will be created as we will have the flag set. 680 */ 681 if (state->stage == MESA_SHADER_GEOMETRY 682 && this->flags.q.prim_type && !state->in_qualifier->flags.q.prim_type) { 683 node = new(lin_ctx) ast_gs_input_layout(*loc, this->prim_type); 684 } 685 686 r = state->in_qualifier->merge_qualifier(loc, state, *this, false); 687 688 if (state->in_qualifier->flags.q.early_fragment_tests) { 689 state->fs_early_fragment_tests = true; 690 state->in_qualifier->flags.q.early_fragment_tests = false; 691 } 692 693 if (state->in_qualifier->flags.q.inner_coverage) { 694 state->fs_inner_coverage = true; 695 state->in_qualifier->flags.q.inner_coverage = false; 696 } 697 698 if (state->in_qualifier->flags.q.post_depth_coverage) { 699 state->fs_post_depth_coverage = true; 700 state->in_qualifier->flags.q.post_depth_coverage = false; 701 } 702 703 if (state->fs_inner_coverage && state->fs_post_depth_coverage) { 704 _mesa_glsl_error(loc, state, 705 "inner_coverage & post_depth_coverage layout qualifiers " 706 "are mutally exclusives"); 707 r = false; 708 } 709 710 /* We allow the creation of multiple cs_input_layout nodes. Coherence among 711 * all existing nodes is checked later, when the AST node is transformed 712 * into HIR. 713 */ 714 if (state->in_qualifier->flags.q.local_size) { 715 node = new(lin_ctx) ast_cs_input_layout(*loc, 716 state->in_qualifier->local_size); 717 state->in_qualifier->flags.q.local_size = 0; 718 for (int i = 0; i < 3; i++) 719 state->in_qualifier->local_size[i] = NULL; 720 } 721 722 if (state->in_qualifier->flags.q.local_size_variable) { 723 state->cs_input_local_size_variable_specified = true; 724 state->in_qualifier->flags.q.local_size_variable = false; 725 } 726 727 return r; 728 } 729 730 bool 731 ast_type_qualifier::push_to_global(YYLTYPE *loc, 732 _mesa_glsl_parse_state *state) 733 { 734 if (this->flags.q.xfb_stride) { 735 this->flags.q.xfb_stride = 0; 736 737 unsigned buff_idx; 738 if (process_qualifier_constant(state, loc, "xfb_buffer", 739 this->xfb_buffer, &buff_idx)) { 740 if (state->out_qualifier->out_xfb_stride[buff_idx]) { 741 state->out_qualifier->out_xfb_stride[buff_idx]->merge_qualifier( 742 new(state->linalloc) ast_layout_expression(*loc, 743 this->xfb_stride)); 744 } else { 745 state->out_qualifier->out_xfb_stride[buff_idx] = 746 new(state->linalloc) ast_layout_expression(*loc, 747 this->xfb_stride); 748 } 749 } 750 } 751 752 return true; 753 } 754 755 /** 756 * Check if the current type qualifier has any illegal flags. 757 * 758 * If so, print an error message, followed by a list of illegal flags. 759 * 760 * \param message The error message to print. 761 * \param allowed_flags A list of valid flags. 762 */ 763 bool 764 ast_type_qualifier::validate_flags(YYLTYPE *loc, 765 _mesa_glsl_parse_state *state, 766 const ast_type_qualifier &allowed_flags, 767 const char *message, const char *name) 768 { 769 ast_type_qualifier bad; 770 bad.flags.i = this->flags.i & ~allowed_flags.flags.i; 771 if (bad.flags.i == 0) 772 return true; 773 774 _mesa_glsl_error(loc, state, 775 "%s '%s':" 776 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" 777 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" 778 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", 779 message, name, 780 bad.flags.q.invariant ? " invariant" : "", 781 bad.flags.q.precise ? " precise" : "", 782 bad.flags.q.constant ? " constant" : "", 783 bad.flags.q.attribute ? " attribute" : "", 784 bad.flags.q.varying ? " varying" : "", 785 bad.flags.q.in ? " in" : "", 786 bad.flags.q.out ? " out" : "", 787 bad.flags.q.centroid ? " centroid" : "", 788 bad.flags.q.sample ? " sample" : "", 789 bad.flags.q.patch ? " patch" : "", 790 bad.flags.q.uniform ? " uniform" : "", 791 bad.flags.q.buffer ? " buffer" : "", 792 bad.flags.q.shared_storage ? " shared_storage" : "", 793 bad.flags.q.smooth ? " smooth" : "", 794 bad.flags.q.flat ? " flat" : "", 795 bad.flags.q.noperspective ? " noperspective" : "", 796 bad.flags.q.origin_upper_left ? " origin_upper_left" : "", 797 bad.flags.q.pixel_center_integer ? " pixel_center_integer" : "", 798 bad.flags.q.explicit_align ? " align" : "", 799 bad.flags.q.explicit_component ? " component" : "", 800 bad.flags.q.explicit_location ? " location" : "", 801 bad.flags.q.explicit_index ? " index" : "", 802 bad.flags.q.explicit_binding ? " binding" : "", 803 bad.flags.q.explicit_offset ? " offset" : "", 804 bad.flags.q.depth_type ? " depth_type" : "", 805 bad.flags.q.std140 ? " std140" : "", 806 bad.flags.q.std430 ? " std430" : "", 807 bad.flags.q.shared ? " shared" : "", 808 bad.flags.q.packed ? " packed" : "", 809 bad.flags.q.column_major ? " column_major" : "", 810 bad.flags.q.row_major ? " row_major" : "", 811 bad.flags.q.prim_type ? " prim_type" : "", 812 bad.flags.q.max_vertices ? " max_vertices" : "", 813 bad.flags.q.local_size ? " local_size" : "", 814 bad.flags.q.local_size_variable ? " local_size_variable" : "", 815 bad.flags.q.early_fragment_tests ? " early_fragment_tests" : "", 816 bad.flags.q.explicit_image_format ? " image_format" : "", 817 bad.flags.q.coherent ? " coherent" : "", 818 bad.flags.q._volatile ? " _volatile" : "", 819 bad.flags.q.restrict_flag ? " restrict_flag" : "", 820 bad.flags.q.read_only ? " read_only" : "", 821 bad.flags.q.write_only ? " write_only" : "", 822 bad.flags.q.invocations ? " invocations" : "", 823 bad.flags.q.stream ? " stream" : "", 824 bad.flags.q.explicit_stream ? " stream" : "", 825 bad.flags.q.explicit_xfb_offset ? " xfb_offset" : "", 826 bad.flags.q.xfb_buffer ? " xfb_buffer" : "", 827 bad.flags.q.explicit_xfb_buffer ? " xfb_buffer" : "", 828 bad.flags.q.xfb_stride ? " xfb_stride" : "", 829 bad.flags.q.explicit_xfb_stride ? " xfb_stride" : "", 830 bad.flags.q.vertex_spacing ? " vertex_spacing" : "", 831 bad.flags.q.ordering ? " ordering" : "", 832 bad.flags.q.point_mode ? " point_mode" : "", 833 bad.flags.q.vertices ? " vertices" : "", 834 bad.flags.q.subroutine ? " subroutine" : "", 835 bad.flags.q.blend_support ? " blend_support" : "", 836 bad.flags.q.inner_coverage ? " inner_coverage" : "", 837 bad.flags.q.bindless_sampler ? " bindless_sampler" : "", 838 bad.flags.q.bindless_image ? " bindless_image" : "", 839 bad.flags.q.bound_sampler ? " bound_sampler" : "", 840 bad.flags.q.bound_image ? " bound_image" : "", 841 bad.flags.q.post_depth_coverage ? " post_depth_coverage" : ""); 842 return false; 843 } 844 845 bool 846 ast_layout_expression::process_qualifier_constant(struct _mesa_glsl_parse_state *state, 847 const char *qual_indentifier, 848 unsigned *value, 849 bool can_be_zero) 850 { 851 int min_value = 0; 852 bool first_pass = true; 853 *value = 0; 854 855 if (!can_be_zero) 856 min_value = 1; 857 858 for (exec_node *node = layout_const_expressions.get_head_raw(); 859 !node->is_tail_sentinel(); node = node->next) { 860 861 exec_list dummy_instructions; 862 ast_node *const_expression = exec_node_data(ast_node, node, link); 863 864 ir_rvalue *const ir = const_expression->hir(&dummy_instructions, state); 865 866 ir_constant *const const_int = 867 ir->constant_expression_value(ralloc_parent(ir)); 868 869 if (const_int == NULL || !const_int->type->is_integer()) { 870 YYLTYPE loc = const_expression->get_location(); 871 _mesa_glsl_error(&loc, state, "%s must be an integral constant " 872 "expression", qual_indentifier); 873 return false; 874 } 875 876 if (const_int->value.i[0] < min_value) { 877 YYLTYPE loc = const_expression->get_location(); 878 _mesa_glsl_error(&loc, state, "%s layout qualifier is invalid " 879 "(%d < %d)", qual_indentifier, 880 const_int->value.i[0], min_value); 881 return false; 882 } 883 884 if (!first_pass && *value != const_int->value.u[0]) { 885 YYLTYPE loc = const_expression->get_location(); 886 _mesa_glsl_error(&loc, state, "%s layout qualifier does not " 887 "match previous declaration (%d vs %d)", 888 qual_indentifier, *value, const_int->value.i[0]); 889 return false; 890 } else { 891 first_pass = false; 892 *value = const_int->value.u[0]; 893 } 894 895 /* If the location is const (and we've verified that 896 * it is) then no instructions should have been emitted 897 * when we converted it to HIR. If they were emitted, 898 * then either the location isn't const after all, or 899 * we are emitting unnecessary instructions. 900 */ 901 assert(dummy_instructions.is_empty()); 902 } 903 904 return true; 905 } 906 907 bool 908 process_qualifier_constant(struct _mesa_glsl_parse_state *state, 909 YYLTYPE *loc, 910 const char *qual_indentifier, 911 ast_expression *const_expression, 912 unsigned *value) 913 { 914 exec_list dummy_instructions; 915 916 if (const_expression == NULL) { 917 *value = 0; 918 return true; 919 } 920 921 ir_rvalue *const ir = const_expression->hir(&dummy_instructions, state); 922 923 ir_constant *const const_int = 924 ir->constant_expression_value(ralloc_parent(ir)); 925 if (const_int == NULL || !const_int->type->is_integer()) { 926 _mesa_glsl_error(loc, state, "%s must be an integral constant " 927 "expression", qual_indentifier); 928 return false; 929 } 930 931 if (const_int->value.i[0] < 0) { 932 _mesa_glsl_error(loc, state, "%s layout qualifier is invalid (%d < 0)", 933 qual_indentifier, const_int->value.u[0]); 934 return false; 935 } 936 937 /* If the location is const (and we've verified that 938 * it is) then no instructions should have been emitted 939 * when we converted it to HIR. If they were emitted, 940 * then either the location isn't const after all, or 941 * we are emitting unnecessary instructions. 942 */ 943 assert(dummy_instructions.is_empty()); 944 945 *value = const_int->value.u[0]; 946 return true; 947 } 948
