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 /** 25 * \file linker.cpp 26 * GLSL linker implementation 27 * 28 * Given a set of shaders that are to be linked to generate a final program, 29 * there are three distinct stages. 30 * 31 * In the first stage shaders are partitioned into groups based on the shader 32 * type. All shaders of a particular type (e.g., vertex shaders) are linked 33 * together. 34 * 35 * - Undefined references in each shader are resolve to definitions in 36 * another shader. 37 * - Types and qualifiers of uniforms, outputs, and global variables defined 38 * in multiple shaders with the same name are verified to be the same. 39 * - Initializers for uniforms and global variables defined 40 * in multiple shaders with the same name are verified to be the same. 41 * 42 * The result, in the terminology of the GLSL spec, is a set of shader 43 * executables for each processing unit. 44 * 45 * After the first stage is complete, a series of semantic checks are performed 46 * on each of the shader executables. 47 * 48 * - Each shader executable must define a \c main function. 49 * - Each vertex shader executable must write to \c gl_Position. 50 * - Each fragment shader executable must write to either \c gl_FragData or 51 * \c gl_FragColor. 52 * 53 * In the final stage individual shader executables are linked to create a 54 * complete exectuable. 55 * 56 * - Types of uniforms defined in multiple shader stages with the same name 57 * are verified to be the same. 58 * - Initializers for uniforms defined in multiple shader stages with the 59 * same name are verified to be the same. 60 * - Types and qualifiers of outputs defined in one stage are verified to 61 * be the same as the types and qualifiers of inputs defined with the same 62 * name in a later stage. 63 * 64 * \author Ian Romanick <ian.d.romanick (at) intel.com> 65 */ 66 67 #include <ctype.h> 68 #include "util/strndup.h" 69 #include "main/core.h" 70 #include "glsl_symbol_table.h" 71 #include "glsl_parser_extras.h" 72 #include "ir.h" 73 #include "program.h" 74 #include "program/prog_instruction.h" 75 #include "program/program.h" 76 #include "util/mesa-sha1.h" 77 #include "util/set.h" 78 #include "string_to_uint_map.h" 79 #include "linker.h" 80 #include "link_varyings.h" 81 #include "ir_optimization.h" 82 #include "ir_rvalue_visitor.h" 83 #include "ir_uniform.h" 84 #include "builtin_functions.h" 85 #include "shader_cache.h" 86 87 #include "main/shaderobj.h" 88 #include "main/enums.h" 89 90 91 namespace { 92 93 struct find_variable { 94 const char *name; 95 bool found; 96 97 find_variable(const char *name) : name(name), found(false) {} 98 }; 99 100 /** 101 * Visitor that determines whether or not a variable is ever written. 102 * 103 * Use \ref find_assignments for convenience. 104 */ 105 class find_assignment_visitor : public ir_hierarchical_visitor { 106 public: 107 find_assignment_visitor(unsigned num_vars, 108 find_variable * const *vars) 109 : num_variables(num_vars), num_found(0), variables(vars) 110 { 111 } 112 113 virtual ir_visitor_status visit_enter(ir_assignment *ir) 114 { 115 ir_variable *const var = ir->lhs->variable_referenced(); 116 117 return check_variable_name(var->name); 118 } 119 120 virtual ir_visitor_status visit_enter(ir_call *ir) 121 { 122 foreach_two_lists(formal_node, &ir->callee->parameters, 123 actual_node, &ir->actual_parameters) { 124 ir_rvalue *param_rval = (ir_rvalue *) actual_node; 125 ir_variable *sig_param = (ir_variable *) formal_node; 126 127 if (sig_param->data.mode == ir_var_function_out || 128 sig_param->data.mode == ir_var_function_inout) { 129 ir_variable *var = param_rval->variable_referenced(); 130 if (var && check_variable_name(var->name) == visit_stop) 131 return visit_stop; 132 } 133 } 134 135 if (ir->return_deref != NULL) { 136 ir_variable *const var = ir->return_deref->variable_referenced(); 137 138 if (check_variable_name(var->name) == visit_stop) 139 return visit_stop; 140 } 141 142 return visit_continue_with_parent; 143 } 144 145 private: 146 ir_visitor_status check_variable_name(const char *name) 147 { 148 for (unsigned i = 0; i < num_variables; ++i) { 149 if (strcmp(variables[i]->name, name) == 0) { 150 if (!variables[i]->found) { 151 variables[i]->found = true; 152 153 assert(num_found < num_variables); 154 if (++num_found == num_variables) 155 return visit_stop; 156 } 157 break; 158 } 159 } 160 161 return visit_continue_with_parent; 162 } 163 164 private: 165 unsigned num_variables; /**< Number of variables to find */ 166 unsigned num_found; /**< Number of variables already found */ 167 find_variable * const *variables; /**< Variables to find */ 168 }; 169 170 /** 171 * Determine whether or not any of NULL-terminated list of variables is ever 172 * written to. 173 */ 174 static void 175 find_assignments(exec_list *ir, find_variable * const *vars) 176 { 177 unsigned num_variables = 0; 178 179 for (find_variable * const *v = vars; *v; ++v) 180 num_variables++; 181 182 find_assignment_visitor visitor(num_variables, vars); 183 visitor.run(ir); 184 } 185 186 /** 187 * Determine whether or not the given variable is ever written to. 188 */ 189 static void 190 find_assignments(exec_list *ir, find_variable *var) 191 { 192 find_assignment_visitor visitor(1, &var); 193 visitor.run(ir); 194 } 195 196 /** 197 * Visitor that determines whether or not a variable is ever read. 198 */ 199 class find_deref_visitor : public ir_hierarchical_visitor { 200 public: 201 find_deref_visitor(const char *name) 202 : name(name), found(false) 203 { 204 /* empty */ 205 } 206 207 virtual ir_visitor_status visit(ir_dereference_variable *ir) 208 { 209 if (strcmp(this->name, ir->var->name) == 0) { 210 this->found = true; 211 return visit_stop; 212 } 213 214 return visit_continue; 215 } 216 217 bool variable_found() const 218 { 219 return this->found; 220 } 221 222 private: 223 const char *name; /**< Find writes to a variable with this name. */ 224 bool found; /**< Was a write to the variable found? */ 225 }; 226 227 228 /** 229 * A visitor helper that provides methods for updating the types of 230 * ir_dereferences. Classes that update variable types (say, updating 231 * array sizes) will want to use this so that dereference types stay in sync. 232 */ 233 class deref_type_updater : public ir_hierarchical_visitor { 234 public: 235 virtual ir_visitor_status visit(ir_dereference_variable *ir) 236 { 237 ir->type = ir->var->type; 238 return visit_continue; 239 } 240 241 virtual ir_visitor_status visit_leave(ir_dereference_array *ir) 242 { 243 const glsl_type *const vt = ir->array->type; 244 if (vt->is_array()) 245 ir->type = vt->fields.array; 246 return visit_continue; 247 } 248 249 virtual ir_visitor_status visit_leave(ir_dereference_record *ir) 250 { 251 ir->type = ir->record->type->fields.structure[ir->field_idx].type; 252 return visit_continue; 253 } 254 }; 255 256 257 class array_resize_visitor : public deref_type_updater { 258 public: 259 unsigned num_vertices; 260 gl_shader_program *prog; 261 gl_shader_stage stage; 262 263 array_resize_visitor(unsigned num_vertices, 264 gl_shader_program *prog, 265 gl_shader_stage stage) 266 { 267 this->num_vertices = num_vertices; 268 this->prog = prog; 269 this->stage = stage; 270 } 271 272 virtual ~array_resize_visitor() 273 { 274 /* empty */ 275 } 276 277 virtual ir_visitor_status visit(ir_variable *var) 278 { 279 if (!var->type->is_array() || var->data.mode != ir_var_shader_in || 280 var->data.patch) 281 return visit_continue; 282 283 unsigned size = var->type->length; 284 285 if (stage == MESA_SHADER_GEOMETRY) { 286 /* Generate a link error if the shader has declared this array with 287 * an incorrect size. 288 */ 289 if (!var->data.implicit_sized_array && 290 size && size != this->num_vertices) { 291 linker_error(this->prog, "size of array %s declared as %u, " 292 "but number of input vertices is %u\n", 293 var->name, size, this->num_vertices); 294 return visit_continue; 295 } 296 297 /* Generate a link error if the shader attempts to access an input 298 * array using an index too large for its actual size assigned at 299 * link time. 300 */ 301 if (var->data.max_array_access >= (int)this->num_vertices) { 302 linker_error(this->prog, "%s shader accesses element %i of " 303 "%s, but only %i input vertices\n", 304 _mesa_shader_stage_to_string(this->stage), 305 var->data.max_array_access, var->name, this->num_vertices); 306 return visit_continue; 307 } 308 } 309 310 var->type = glsl_type::get_array_instance(var->type->fields.array, 311 this->num_vertices); 312 var->data.max_array_access = this->num_vertices - 1; 313 314 return visit_continue; 315 } 316 }; 317 318 /** 319 * Visitor that determines the highest stream id to which a (geometry) shader 320 * emits vertices. It also checks whether End{Stream}Primitive is ever called. 321 */ 322 class find_emit_vertex_visitor : public ir_hierarchical_visitor { 323 public: 324 find_emit_vertex_visitor(int max_allowed) 325 : max_stream_allowed(max_allowed), 326 invalid_stream_id(0), 327 invalid_stream_id_from_emit_vertex(false), 328 end_primitive_found(false), 329 uses_non_zero_stream(false) 330 { 331 /* empty */ 332 } 333 334 virtual ir_visitor_status visit_leave(ir_emit_vertex *ir) 335 { 336 int stream_id = ir->stream_id(); 337 338 if (stream_id < 0) { 339 invalid_stream_id = stream_id; 340 invalid_stream_id_from_emit_vertex = true; 341 return visit_stop; 342 } 343 344 if (stream_id > max_stream_allowed) { 345 invalid_stream_id = stream_id; 346 invalid_stream_id_from_emit_vertex = true; 347 return visit_stop; 348 } 349 350 if (stream_id != 0) 351 uses_non_zero_stream = true; 352 353 return visit_continue; 354 } 355 356 virtual ir_visitor_status visit_leave(ir_end_primitive *ir) 357 { 358 end_primitive_found = true; 359 360 int stream_id = ir->stream_id(); 361 362 if (stream_id < 0) { 363 invalid_stream_id = stream_id; 364 invalid_stream_id_from_emit_vertex = false; 365 return visit_stop; 366 } 367 368 if (stream_id > max_stream_allowed) { 369 invalid_stream_id = stream_id; 370 invalid_stream_id_from_emit_vertex = false; 371 return visit_stop; 372 } 373 374 if (stream_id != 0) 375 uses_non_zero_stream = true; 376 377 return visit_continue; 378 } 379 380 bool error() 381 { 382 return invalid_stream_id != 0; 383 } 384 385 const char *error_func() 386 { 387 return invalid_stream_id_from_emit_vertex ? 388 "EmitStreamVertex" : "EndStreamPrimitive"; 389 } 390 391 int error_stream() 392 { 393 return invalid_stream_id; 394 } 395 396 bool uses_streams() 397 { 398 return uses_non_zero_stream; 399 } 400 401 bool uses_end_primitive() 402 { 403 return end_primitive_found; 404 } 405 406 private: 407 int max_stream_allowed; 408 int invalid_stream_id; 409 bool invalid_stream_id_from_emit_vertex; 410 bool end_primitive_found; 411 bool uses_non_zero_stream; 412 }; 413 414 /* Class that finds array derefs and check if indexes are dynamic. */ 415 class dynamic_sampler_array_indexing_visitor : public ir_hierarchical_visitor 416 { 417 public: 418 dynamic_sampler_array_indexing_visitor() : 419 dynamic_sampler_array_indexing(false) 420 { 421 } 422 423 ir_visitor_status visit_enter(ir_dereference_array *ir) 424 { 425 if (!ir->variable_referenced()) 426 return visit_continue; 427 428 if (!ir->variable_referenced()->type->contains_sampler()) 429 return visit_continue; 430 431 if (!ir->array_index->constant_expression_value(ralloc_parent(ir))) { 432 dynamic_sampler_array_indexing = true; 433 return visit_stop; 434 } 435 return visit_continue; 436 } 437 438 bool uses_dynamic_sampler_array_indexing() 439 { 440 return dynamic_sampler_array_indexing; 441 } 442 443 private: 444 bool dynamic_sampler_array_indexing; 445 }; 446 447 } /* anonymous namespace */ 448 449 void 450 linker_error(gl_shader_program *prog, const char *fmt, ...) 451 { 452 va_list ap; 453 454 ralloc_strcat(&prog->data->InfoLog, "error: "); 455 va_start(ap, fmt); 456 ralloc_vasprintf_append(&prog->data->InfoLog, fmt, ap); 457 va_end(ap); 458 459 prog->data->LinkStatus = linking_failure; 460 } 461 462 463 void 464 linker_warning(gl_shader_program *prog, const char *fmt, ...) 465 { 466 va_list ap; 467 468 ralloc_strcat(&prog->data->InfoLog, "warning: "); 469 va_start(ap, fmt); 470 ralloc_vasprintf_append(&prog->data->InfoLog, fmt, ap); 471 va_end(ap); 472 473 } 474 475 476 /** 477 * Given a string identifying a program resource, break it into a base name 478 * and an optional array index in square brackets. 479 * 480 * If an array index is present, \c out_base_name_end is set to point to the 481 * "[" that precedes the array index, and the array index itself is returned 482 * as a long. 483 * 484 * If no array index is present (or if the array index is negative or 485 * mal-formed), \c out_base_name_end, is set to point to the null terminator 486 * at the end of the input string, and -1 is returned. 487 * 488 * Only the final array index is parsed; if the string contains other array 489 * indices (or structure field accesses), they are left in the base name. 490 * 491 * No attempt is made to check that the base name is properly formed; 492 * typically the caller will look up the base name in a hash table, so 493 * ill-formed base names simply turn into hash table lookup failures. 494 */ 495 long 496 parse_program_resource_name(const GLchar *name, 497 const GLchar **out_base_name_end) 498 { 499 /* Section 7.3.1 ("Program Interfaces") of the OpenGL 4.3 spec says: 500 * 501 * "When an integer array element or block instance number is part of 502 * the name string, it will be specified in decimal form without a "+" 503 * or "-" sign or any extra leading zeroes. Additionally, the name 504 * string will not include white space anywhere in the string." 505 */ 506 507 const size_t len = strlen(name); 508 *out_base_name_end = name + len; 509 510 if (len == 0 || name[len-1] != ']') 511 return -1; 512 513 /* Walk backwards over the string looking for a non-digit character. This 514 * had better be the opening bracket for an array index. 515 * 516 * Initially, i specifies the location of the ']'. Since the string may 517 * contain only the ']' charcater, walk backwards very carefully. 518 */ 519 unsigned i; 520 for (i = len - 1; (i > 0) && isdigit(name[i-1]); --i) 521 /* empty */ ; 522 523 if ((i == 0) || name[i-1] != '[') 524 return -1; 525 526 long array_index = strtol(&name[i], NULL, 10); 527 if (array_index < 0) 528 return -1; 529 530 /* Check for leading zero */ 531 if (name[i] == '0' && name[i+1] != ']') 532 return -1; 533 534 *out_base_name_end = name + (i - 1); 535 return array_index; 536 } 537 538 539 void 540 link_invalidate_variable_locations(exec_list *ir) 541 { 542 foreach_in_list(ir_instruction, node, ir) { 543 ir_variable *const var = node->as_variable(); 544 545 if (var == NULL) 546 continue; 547 548 /* Only assign locations for variables that lack an explicit location. 549 * Explicit locations are set for all built-in variables, generic vertex 550 * shader inputs (via layout(location=...)), and generic fragment shader 551 * outputs (also via layout(location=...)). 552 */ 553 if (!var->data.explicit_location) { 554 var->data.location = -1; 555 var->data.location_frac = 0; 556 } 557 558 /* ir_variable::is_unmatched_generic_inout is used by the linker while 559 * connecting outputs from one stage to inputs of the next stage. 560 */ 561 if (var->data.explicit_location && 562 var->data.location < VARYING_SLOT_VAR0) { 563 var->data.is_unmatched_generic_inout = 0; 564 } else { 565 var->data.is_unmatched_generic_inout = 1; 566 } 567 } 568 } 569 570 571 /** 572 * Set clip_distance_array_size based and cull_distance_array_size on the given 573 * shader. 574 * 575 * Also check for errors based on incorrect usage of gl_ClipVertex and 576 * gl_ClipDistance and gl_CullDistance. 577 * Additionally test whether the arrays gl_ClipDistance and gl_CullDistance 578 * exceed the maximum size defined by gl_MaxCombinedClipAndCullDistances. 579 * 580 * Return false if an error was reported. 581 */ 582 static void 583 analyze_clip_cull_usage(struct gl_shader_program *prog, 584 struct gl_linked_shader *shader, 585 struct gl_context *ctx, 586 GLuint *clip_distance_array_size, 587 GLuint *cull_distance_array_size) 588 { 589 *clip_distance_array_size = 0; 590 *cull_distance_array_size = 0; 591 592 if (prog->data->Version >= (prog->IsES ? 300 : 130)) { 593 /* From section 7.1 (Vertex Shader Special Variables) of the 594 * GLSL 1.30 spec: 595 * 596 * "It is an error for a shader to statically write both 597 * gl_ClipVertex and gl_ClipDistance." 598 * 599 * This does not apply to GLSL ES shaders, since GLSL ES defines neither 600 * gl_ClipVertex nor gl_ClipDistance. However with 601 * GL_EXT_clip_cull_distance, this functionality is exposed in ES 3.0. 602 */ 603 find_variable gl_ClipDistance("gl_ClipDistance"); 604 find_variable gl_CullDistance("gl_CullDistance"); 605 find_variable gl_ClipVertex("gl_ClipVertex"); 606 find_variable * const variables[] = { 607 &gl_ClipDistance, 608 &gl_CullDistance, 609 !prog->IsES ? &gl_ClipVertex : NULL, 610 NULL 611 }; 612 find_assignments(shader->ir, variables); 613 614 /* From the ARB_cull_distance spec: 615 * 616 * It is a compile-time or link-time error for the set of shaders forming 617 * a program to statically read or write both gl_ClipVertex and either 618 * gl_ClipDistance or gl_CullDistance. 619 * 620 * This does not apply to GLSL ES shaders, since GLSL ES doesn't define 621 * gl_ClipVertex. 622 */ 623 if (!prog->IsES) { 624 if (gl_ClipVertex.found && gl_ClipDistance.found) { 625 linker_error(prog, "%s shader writes to both `gl_ClipVertex' " 626 "and `gl_ClipDistance'\n", 627 _mesa_shader_stage_to_string(shader->Stage)); 628 return; 629 } 630 if (gl_ClipVertex.found && gl_CullDistance.found) { 631 linker_error(prog, "%s shader writes to both `gl_ClipVertex' " 632 "and `gl_CullDistance'\n", 633 _mesa_shader_stage_to_string(shader->Stage)); 634 return; 635 } 636 } 637 638 if (gl_ClipDistance.found) { 639 ir_variable *clip_distance_var = 640 shader->symbols->get_variable("gl_ClipDistance"); 641 assert(clip_distance_var); 642 *clip_distance_array_size = clip_distance_var->type->length; 643 } 644 if (gl_CullDistance.found) { 645 ir_variable *cull_distance_var = 646 shader->symbols->get_variable("gl_CullDistance"); 647 assert(cull_distance_var); 648 *cull_distance_array_size = cull_distance_var->type->length; 649 } 650 /* From the ARB_cull_distance spec: 651 * 652 * It is a compile-time or link-time error for the set of shaders forming 653 * a program to have the sum of the sizes of the gl_ClipDistance and 654 * gl_CullDistance arrays to be larger than 655 * gl_MaxCombinedClipAndCullDistances. 656 */ 657 if ((*clip_distance_array_size + *cull_distance_array_size) > 658 ctx->Const.MaxClipPlanes) { 659 linker_error(prog, "%s shader: the combined size of " 660 "'gl_ClipDistance' and 'gl_CullDistance' size cannot " 661 "be larger than " 662 "gl_MaxCombinedClipAndCullDistances (%u)", 663 _mesa_shader_stage_to_string(shader->Stage), 664 ctx->Const.MaxClipPlanes); 665 } 666 } 667 } 668 669 670 /** 671 * Verify that a vertex shader executable meets all semantic requirements. 672 * 673 * Also sets info.clip_distance_array_size and 674 * info.cull_distance_array_size as a side effect. 675 * 676 * \param shader Vertex shader executable to be verified 677 */ 678 static void 679 validate_vertex_shader_executable(struct gl_shader_program *prog, 680 struct gl_linked_shader *shader, 681 struct gl_context *ctx) 682 { 683 if (shader == NULL) 684 return; 685 686 /* From the GLSL 1.10 spec, page 48: 687 * 688 * "The variable gl_Position is available only in the vertex 689 * language and is intended for writing the homogeneous vertex 690 * position. All executions of a well-formed vertex shader 691 * executable must write a value into this variable. [...] The 692 * variable gl_Position is available only in the vertex 693 * language and is intended for writing the homogeneous vertex 694 * position. All executions of a well-formed vertex shader 695 * executable must write a value into this variable." 696 * 697 * while in GLSL 1.40 this text is changed to: 698 * 699 * "The variable gl_Position is available only in the vertex 700 * language and is intended for writing the homogeneous vertex 701 * position. It can be written at any time during shader 702 * execution. It may also be read back by a vertex shader 703 * after being written. This value will be used by primitive 704 * assembly, clipping, culling, and other fixed functionality 705 * operations, if present, that operate on primitives after 706 * vertex processing has occurred. Its value is undefined if 707 * the vertex shader executable does not write gl_Position." 708 * 709 * All GLSL ES Versions are similar to GLSL 1.40--failing to write to 710 * gl_Position is not an error. 711 */ 712 if (prog->data->Version < (prog->IsES ? 300 : 140)) { 713 find_variable gl_Position("gl_Position"); 714 find_assignments(shader->ir, &gl_Position); 715 if (!gl_Position.found) { 716 if (prog->IsES) { 717 linker_warning(prog, 718 "vertex shader does not write to `gl_Position'. " 719 "Its value is undefined. \n"); 720 } else { 721 linker_error(prog, 722 "vertex shader does not write to `gl_Position'. \n"); 723 } 724 return; 725 } 726 } 727 728 analyze_clip_cull_usage(prog, shader, ctx, 729 &shader->Program->info.clip_distance_array_size, 730 &shader->Program->info.cull_distance_array_size); 731 } 732 733 static void 734 validate_tess_eval_shader_executable(struct gl_shader_program *prog, 735 struct gl_linked_shader *shader, 736 struct gl_context *ctx) 737 { 738 if (shader == NULL) 739 return; 740 741 analyze_clip_cull_usage(prog, shader, ctx, 742 &shader->Program->info.clip_distance_array_size, 743 &shader->Program->info.cull_distance_array_size); 744 } 745 746 747 /** 748 * Verify that a fragment shader executable meets all semantic requirements 749 * 750 * \param shader Fragment shader executable to be verified 751 */ 752 static void 753 validate_fragment_shader_executable(struct gl_shader_program *prog, 754 struct gl_linked_shader *shader) 755 { 756 if (shader == NULL) 757 return; 758 759 find_variable gl_FragColor("gl_FragColor"); 760 find_variable gl_FragData("gl_FragData"); 761 find_variable * const variables[] = { &gl_FragColor, &gl_FragData, NULL }; 762 find_assignments(shader->ir, variables); 763 764 if (gl_FragColor.found && gl_FragData.found) { 765 linker_error(prog, "fragment shader writes to both " 766 "`gl_FragColor' and `gl_FragData'\n"); 767 } 768 } 769 770 /** 771 * Verify that a geometry shader executable meets all semantic requirements 772 * 773 * Also sets prog->Geom.VerticesIn, and info.clip_distance_array_sizeand 774 * info.cull_distance_array_size as a side effect. 775 * 776 * \param shader Geometry shader executable to be verified 777 */ 778 static void 779 validate_geometry_shader_executable(struct gl_shader_program *prog, 780 struct gl_linked_shader *shader, 781 struct gl_context *ctx) 782 { 783 if (shader == NULL) 784 return; 785 786 unsigned num_vertices = 787 vertices_per_prim(shader->Program->info.gs.input_primitive); 788 prog->Geom.VerticesIn = num_vertices; 789 790 analyze_clip_cull_usage(prog, shader, ctx, 791 &shader->Program->info.clip_distance_array_size, 792 &shader->Program->info.cull_distance_array_size); 793 } 794 795 /** 796 * Check if geometry shaders emit to non-zero streams and do corresponding 797 * validations. 798 */ 799 static void 800 validate_geometry_shader_emissions(struct gl_context *ctx, 801 struct gl_shader_program *prog) 802 { 803 struct gl_linked_shader *sh = prog->_LinkedShaders[MESA_SHADER_GEOMETRY]; 804 805 if (sh != NULL) { 806 find_emit_vertex_visitor emit_vertex(ctx->Const.MaxVertexStreams - 1); 807 emit_vertex.run(sh->ir); 808 if (emit_vertex.error()) { 809 linker_error(prog, "Invalid call %s(%d). Accepted values for the " 810 "stream parameter are in the range [0, %d].\n", 811 emit_vertex.error_func(), 812 emit_vertex.error_stream(), 813 ctx->Const.MaxVertexStreams - 1); 814 } 815 prog->Geom.UsesStreams = emit_vertex.uses_streams(); 816 prog->Geom.UsesEndPrimitive = emit_vertex.uses_end_primitive(); 817 818 /* From the ARB_gpu_shader5 spec: 819 * 820 * "Multiple vertex streams are supported only if the output primitive 821 * type is declared to be "points". A program will fail to link if it 822 * contains a geometry shader calling EmitStreamVertex() or 823 * EndStreamPrimitive() if its output primitive type is not "points". 824 * 825 * However, in the same spec: 826 * 827 * "The function EmitVertex() is equivalent to calling EmitStreamVertex() 828 * with <stream> set to zero." 829 * 830 * And: 831 * 832 * "The function EndPrimitive() is equivalent to calling 833 * EndStreamPrimitive() with <stream> set to zero." 834 * 835 * Since we can call EmitVertex() and EndPrimitive() when we output 836 * primitives other than points, calling EmitStreamVertex(0) or 837 * EmitEndPrimitive(0) should not produce errors. This it also what Nvidia 838 * does. Currently we only set prog->Geom.UsesStreams to TRUE when 839 * EmitStreamVertex() or EmitEndPrimitive() are called with a non-zero 840 * stream. 841 */ 842 if (prog->Geom.UsesStreams && 843 sh->Program->info.gs.output_primitive != GL_POINTS) { 844 linker_error(prog, "EmitStreamVertex(n) and EndStreamPrimitive(n) " 845 "with n>0 requires point output\n"); 846 } 847 } 848 } 849 850 bool 851 validate_intrastage_arrays(struct gl_shader_program *prog, 852 ir_variable *const var, 853 ir_variable *const existing) 854 { 855 /* Consider the types to be "the same" if both types are arrays 856 * of the same type and one of the arrays is implicitly sized. 857 * In addition, set the type of the linked variable to the 858 * explicitly sized array. 859 */ 860 if (var->type->is_array() && existing->type->is_array()) { 861 if ((var->type->fields.array == existing->type->fields.array) && 862 ((var->type->length == 0)|| (existing->type->length == 0))) { 863 if (var->type->length != 0) { 864 if ((int)var->type->length <= existing->data.max_array_access) { 865 linker_error(prog, "%s `%s' declared as type " 866 "`%s' but outermost dimension has an index" 867 " of `%i'\n", 868 mode_string(var), 869 var->name, var->type->name, 870 existing->data.max_array_access); 871 } 872 existing->type = var->type; 873 return true; 874 } else if (existing->type->length != 0) { 875 if((int)existing->type->length <= var->data.max_array_access && 876 !existing->data.from_ssbo_unsized_array) { 877 linker_error(prog, "%s `%s' declared as type " 878 "`%s' but outermost dimension has an index" 879 " of `%i'\n", 880 mode_string(var), 881 var->name, existing->type->name, 882 var->data.max_array_access); 883 } 884 return true; 885 } 886 } 887 } 888 return false; 889 } 890 891 892 /** 893 * Perform validation of global variables used across multiple shaders 894 */ 895 static void 896 cross_validate_globals(struct gl_shader_program *prog, 897 struct exec_list *ir, glsl_symbol_table *variables, 898 bool uniforms_only) 899 { 900 foreach_in_list(ir_instruction, node, ir) { 901 ir_variable *const var = node->as_variable(); 902 903 if (var == NULL) 904 continue; 905 906 if (uniforms_only && (var->data.mode != ir_var_uniform && var->data.mode != ir_var_shader_storage)) 907 continue; 908 909 /* don't cross validate subroutine uniforms */ 910 if (var->type->contains_subroutine()) 911 continue; 912 913 /* Don't cross validate interface instances. These are only relevant 914 * inside a shader. The cross validation is done at the Interface Block 915 * name level. 916 */ 917 if (var->is_interface_instance()) 918 continue; 919 920 /* Don't cross validate temporaries that are at global scope. These 921 * will eventually get pulled into the shaders 'main'. 922 */ 923 if (var->data.mode == ir_var_temporary) 924 continue; 925 926 /* If a global with this name has already been seen, verify that the 927 * new instance has the same type. In addition, if the globals have 928 * initializers, the values of the initializers must be the same. 929 */ 930 ir_variable *const existing = variables->get_variable(var->name); 931 if (existing != NULL) { 932 /* Check if types match. */ 933 if (var->type != existing->type) { 934 if (!validate_intrastage_arrays(prog, var, existing)) { 935 /* If it is an unsized array in a Shader Storage Block, 936 * two different shaders can access to different elements. 937 * Because of that, they might be converted to different 938 * sized arrays, then check that they are compatible but 939 * ignore the array size. 940 */ 941 if (!(var->data.mode == ir_var_shader_storage && 942 var->data.from_ssbo_unsized_array && 943 existing->data.mode == ir_var_shader_storage && 944 existing->data.from_ssbo_unsized_array && 945 var->type->gl_type == existing->type->gl_type)) { 946 linker_error(prog, "%s `%s' declared as type " 947 "`%s' and type `%s'\n", 948 mode_string(var), 949 var->name, var->type->name, 950 existing->type->name); 951 return; 952 } 953 } 954 } 955 956 if (var->data.explicit_location) { 957 if (existing->data.explicit_location 958 && (var->data.location != existing->data.location)) { 959 linker_error(prog, "explicit locations for %s " 960 "`%s' have differing values\n", 961 mode_string(var), var->name); 962 return; 963 } 964 965 if (var->data.location_frac != existing->data.location_frac) { 966 linker_error(prog, "explicit components for %s `%s' have " 967 "differing values\n", mode_string(var), var->name); 968 return; 969 } 970 971 existing->data.location = var->data.location; 972 existing->data.explicit_location = true; 973 } else { 974 /* Check if uniform with implicit location was marked explicit 975 * by earlier shader stage. If so, mark it explicit in this stage 976 * too to make sure later processing does not treat it as 977 * implicit one. 978 */ 979 if (existing->data.explicit_location) { 980 var->data.location = existing->data.location; 981 var->data.explicit_location = true; 982 } 983 } 984 985 /* From the GLSL 4.20 specification: 986 * "A link error will result if two compilation units in a program 987 * specify different integer-constant bindings for the same 988 * opaque-uniform name. However, it is not an error to specify a 989 * binding on some but not all declarations for the same name" 990 */ 991 if (var->data.explicit_binding) { 992 if (existing->data.explicit_binding && 993 var->data.binding != existing->data.binding) { 994 linker_error(prog, "explicit bindings for %s " 995 "`%s' have differing values\n", 996 mode_string(var), var->name); 997 return; 998 } 999 1000 existing->data.binding = var->data.binding; 1001 existing->data.explicit_binding = true; 1002 } 1003 1004 if (var->type->contains_atomic() && 1005 var->data.offset != existing->data.offset) { 1006 linker_error(prog, "offset specifications for %s " 1007 "`%s' have differing values\n", 1008 mode_string(var), var->name); 1009 return; 1010 } 1011 1012 /* Validate layout qualifiers for gl_FragDepth. 1013 * 1014 * From the AMD/ARB_conservative_depth specs: 1015 * 1016 * "If gl_FragDepth is redeclared in any fragment shader in a 1017 * program, it must be redeclared in all fragment shaders in 1018 * that program that have static assignments to 1019 * gl_FragDepth. All redeclarations of gl_FragDepth in all 1020 * fragment shaders in a single program must have the same set 1021 * of qualifiers." 1022 */ 1023 if (strcmp(var->name, "gl_FragDepth") == 0) { 1024 bool layout_declared = var->data.depth_layout != ir_depth_layout_none; 1025 bool layout_differs = 1026 var->data.depth_layout != existing->data.depth_layout; 1027 1028 if (layout_declared && layout_differs) { 1029 linker_error(prog, 1030 "All redeclarations of gl_FragDepth in all " 1031 "fragment shaders in a single program must have " 1032 "the same set of qualifiers.\n"); 1033 } 1034 1035 if (var->data.used && layout_differs) { 1036 linker_error(prog, 1037 "If gl_FragDepth is redeclared with a layout " 1038 "qualifier in any fragment shader, it must be " 1039 "redeclared with the same layout qualifier in " 1040 "all fragment shaders that have assignments to " 1041 "gl_FragDepth\n"); 1042 } 1043 } 1044 1045 /* Page 35 (page 41 of the PDF) of the GLSL 4.20 spec says: 1046 * 1047 * "If a shared global has multiple initializers, the 1048 * initializers must all be constant expressions, and they 1049 * must all have the same value. Otherwise, a link error will 1050 * result. (A shared global having only one initializer does 1051 * not require that initializer to be a constant expression.)" 1052 * 1053 * Previous to 4.20 the GLSL spec simply said that initializers 1054 * must have the same value. In this case of non-constant 1055 * initializers, this was impossible to determine. As a result, 1056 * no vendor actually implemented that behavior. The 4.20 1057 * behavior matches the implemented behavior of at least one other 1058 * vendor, so we'll implement that for all GLSL versions. 1059 */ 1060 if (var->constant_initializer != NULL) { 1061 if (existing->constant_initializer != NULL) { 1062 if (!var->constant_initializer->has_value(existing->constant_initializer)) { 1063 linker_error(prog, "initializers for %s " 1064 "`%s' have differing values\n", 1065 mode_string(var), var->name); 1066 return; 1067 } 1068 } else { 1069 /* If the first-seen instance of a particular uniform did 1070 * not have an initializer but a later instance does, 1071 * replace the former with the later. 1072 */ 1073 variables->replace_variable(existing->name, var); 1074 } 1075 } 1076 1077 if (var->data.has_initializer) { 1078 if (existing->data.has_initializer 1079 && (var->constant_initializer == NULL 1080 || existing->constant_initializer == NULL)) { 1081 linker_error(prog, 1082 "shared global variable `%s' has multiple " 1083 "non-constant initializers.\n", 1084 var->name); 1085 return; 1086 } 1087 } 1088 1089 if (existing->data.invariant != var->data.invariant) { 1090 linker_error(prog, "declarations for %s `%s' have " 1091 "mismatching invariant qualifiers\n", 1092 mode_string(var), var->name); 1093 return; 1094 } 1095 if (existing->data.centroid != var->data.centroid) { 1096 linker_error(prog, "declarations for %s `%s' have " 1097 "mismatching centroid qualifiers\n", 1098 mode_string(var), var->name); 1099 return; 1100 } 1101 if (existing->data.sample != var->data.sample) { 1102 linker_error(prog, "declarations for %s `%s` have " 1103 "mismatching sample qualifiers\n", 1104 mode_string(var), var->name); 1105 return; 1106 } 1107 if (existing->data.image_format != var->data.image_format) { 1108 linker_error(prog, "declarations for %s `%s` have " 1109 "mismatching image format qualifiers\n", 1110 mode_string(var), var->name); 1111 return; 1112 } 1113 1114 /* Check the precision qualifier matches for uniform variables on 1115 * GLSL ES. 1116 */ 1117 if (prog->IsES && !var->get_interface_type() && 1118 existing->data.precision != var->data.precision) { 1119 if ((existing->data.used && var->data.used) || prog->data->Version >= 300) { 1120 linker_error(prog, "declarations for %s `%s` have " 1121 "mismatching precision qualifiers\n", 1122 mode_string(var), var->name); 1123 return; 1124 } else { 1125 linker_warning(prog, "declarations for %s `%s` have " 1126 "mismatching precision qualifiers\n", 1127 mode_string(var), var->name); 1128 } 1129 } 1130 1131 /* In OpenGL GLSL 3.20 spec, section 4.3.9: 1132 * 1133 * "It is a link-time error if any particular shader interface 1134 * contains: 1135 * 1136 * - two different blocks, each having no instance name, and each 1137 * having a member of the same name, or 1138 * 1139 * - a variable outside a block, and a block with no instance name, 1140 * where the variable has the same name as a member in the block." 1141 */ 1142 const glsl_type *var_itype = var->get_interface_type(); 1143 const glsl_type *existing_itype = existing->get_interface_type(); 1144 if (var_itype != existing_itype) { 1145 if (!var_itype || !existing_itype) { 1146 linker_error(prog, "declarations for %s `%s` are inside block " 1147 "`%s` and outside a block", 1148 mode_string(var), var->name, 1149 var_itype ? var_itype->name : existing_itype->name); 1150 return; 1151 } else if (strcmp(var_itype->name, existing_itype->name) != 0) { 1152 linker_error(prog, "declarations for %s `%s` are inside blocks " 1153 "`%s` and `%s`", 1154 mode_string(var), var->name, 1155 existing_itype->name, 1156 var_itype->name); 1157 return; 1158 } 1159 } 1160 } else 1161 variables->add_variable(var); 1162 } 1163 } 1164 1165 1166 /** 1167 * Perform validation of uniforms used across multiple shader stages 1168 */ 1169 static void 1170 cross_validate_uniforms(struct gl_shader_program *prog) 1171 { 1172 glsl_symbol_table variables; 1173 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 1174 if (prog->_LinkedShaders[i] == NULL) 1175 continue; 1176 1177 cross_validate_globals(prog, prog->_LinkedShaders[i]->ir, &variables, 1178 true); 1179 } 1180 } 1181 1182 /** 1183 * Accumulates the array of buffer blocks and checks that all definitions of 1184 * blocks agree on their contents. 1185 */ 1186 static bool 1187 interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog, 1188 bool validate_ssbo) 1189 { 1190 int *InterfaceBlockStageIndex[MESA_SHADER_STAGES]; 1191 struct gl_uniform_block *blks = NULL; 1192 unsigned *num_blks = validate_ssbo ? &prog->data->NumShaderStorageBlocks : 1193 &prog->data->NumUniformBlocks; 1194 1195 unsigned max_num_buffer_blocks = 0; 1196 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 1197 if (prog->_LinkedShaders[i]) { 1198 if (validate_ssbo) { 1199 max_num_buffer_blocks += 1200 prog->_LinkedShaders[i]->Program->info.num_ssbos; 1201 } else { 1202 max_num_buffer_blocks += 1203 prog->_LinkedShaders[i]->Program->info.num_ubos; 1204 } 1205 } 1206 } 1207 1208 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 1209 struct gl_linked_shader *sh = prog->_LinkedShaders[i]; 1210 1211 InterfaceBlockStageIndex[i] = new int[max_num_buffer_blocks]; 1212 for (unsigned int j = 0; j < max_num_buffer_blocks; j++) 1213 InterfaceBlockStageIndex[i][j] = -1; 1214 1215 if (sh == NULL) 1216 continue; 1217 1218 unsigned sh_num_blocks; 1219 struct gl_uniform_block **sh_blks; 1220 if (validate_ssbo) { 1221 sh_num_blocks = prog->_LinkedShaders[i]->Program->info.num_ssbos; 1222 sh_blks = sh->Program->sh.ShaderStorageBlocks; 1223 } else { 1224 sh_num_blocks = prog->_LinkedShaders[i]->Program->info.num_ubos; 1225 sh_blks = sh->Program->sh.UniformBlocks; 1226 } 1227 1228 for (unsigned int j = 0; j < sh_num_blocks; j++) { 1229 int index = link_cross_validate_uniform_block(prog->data, &blks, 1230 num_blks, sh_blks[j]); 1231 1232 if (index == -1) { 1233 linker_error(prog, "buffer block `%s' has mismatching " 1234 "definitions\n", sh_blks[j]->Name); 1235 1236 for (unsigned k = 0; k <= i; k++) { 1237 delete[] InterfaceBlockStageIndex[k]; 1238 } 1239 1240 /* Reset the block count. This will help avoid various segfaults 1241 * from api calls that assume the array exists due to the count 1242 * being non-zero. 1243 */ 1244 *num_blks = 0; 1245 return false; 1246 } 1247 1248 InterfaceBlockStageIndex[i][index] = j; 1249 } 1250 } 1251 1252 /* Update per stage block pointers to point to the program list. 1253 * FIXME: We should be able to free the per stage blocks here. 1254 */ 1255 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 1256 for (unsigned j = 0; j < *num_blks; j++) { 1257 int stage_index = InterfaceBlockStageIndex[i][j]; 1258 1259 if (stage_index != -1) { 1260 struct gl_linked_shader *sh = prog->_LinkedShaders[i]; 1261 1262 struct gl_uniform_block **sh_blks = validate_ssbo ? 1263 sh->Program->sh.ShaderStorageBlocks : 1264 sh->Program->sh.UniformBlocks; 1265 1266 blks[j].stageref |= sh_blks[stage_index]->stageref; 1267 sh_blks[stage_index] = &blks[j]; 1268 } 1269 } 1270 } 1271 1272 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 1273 delete[] InterfaceBlockStageIndex[i]; 1274 } 1275 1276 if (validate_ssbo) 1277 prog->data->ShaderStorageBlocks = blks; 1278 else 1279 prog->data->UniformBlocks = blks; 1280 1281 return true; 1282 } 1283 1284 1285 /** 1286 * Populates a shaders symbol table with all global declarations 1287 */ 1288 static void 1289 populate_symbol_table(gl_linked_shader *sh, glsl_symbol_table *symbols) 1290 { 1291 sh->symbols = new(sh) glsl_symbol_table; 1292 1293 _mesa_glsl_copy_symbols_from_table(sh->ir, symbols, sh->symbols); 1294 } 1295 1296 1297 /** 1298 * Remap variables referenced in an instruction tree 1299 * 1300 * This is used when instruction trees are cloned from one shader and placed in 1301 * another. These trees will contain references to \c ir_variable nodes that 1302 * do not exist in the target shader. This function finds these \c ir_variable 1303 * references and replaces the references with matching variables in the target 1304 * shader. 1305 * 1306 * If there is no matching variable in the target shader, a clone of the 1307 * \c ir_variable is made and added to the target shader. The new variable is 1308 * added to \b both the instruction stream and the symbol table. 1309 * 1310 * \param inst IR tree that is to be processed. 1311 * \param symbols Symbol table containing global scope symbols in the 1312 * linked shader. 1313 * \param instructions Instruction stream where new variable declarations 1314 * should be added. 1315 */ 1316 static void 1317 remap_variables(ir_instruction *inst, struct gl_linked_shader *target, 1318 hash_table *temps) 1319 { 1320 class remap_visitor : public ir_hierarchical_visitor { 1321 public: 1322 remap_visitor(struct gl_linked_shader *target, hash_table *temps) 1323 { 1324 this->target = target; 1325 this->symbols = target->symbols; 1326 this->instructions = target->ir; 1327 this->temps = temps; 1328 } 1329 1330 virtual ir_visitor_status visit(ir_dereference_variable *ir) 1331 { 1332 if (ir->var->data.mode == ir_var_temporary) { 1333 hash_entry *entry = _mesa_hash_table_search(temps, ir->var); 1334 ir_variable *var = entry ? (ir_variable *) entry->data : NULL; 1335 1336 assert(var != NULL); 1337 ir->var = var; 1338 return visit_continue; 1339 } 1340 1341 ir_variable *const existing = 1342 this->symbols->get_variable(ir->var->name); 1343 if (existing != NULL) 1344 ir->var = existing; 1345 else { 1346 ir_variable *copy = ir->var->clone(this->target, NULL); 1347 1348 this->symbols->add_variable(copy); 1349 this->instructions->push_head(copy); 1350 ir->var = copy; 1351 } 1352 1353 return visit_continue; 1354 } 1355 1356 private: 1357 struct gl_linked_shader *target; 1358 glsl_symbol_table *symbols; 1359 exec_list *instructions; 1360 hash_table *temps; 1361 }; 1362 1363 remap_visitor v(target, temps); 1364 1365 inst->accept(&v); 1366 } 1367 1368 1369 /** 1370 * Move non-declarations from one instruction stream to another 1371 * 1372 * The intended usage pattern of this function is to pass the pointer to the 1373 * head sentinel of a list (i.e., a pointer to the list cast to an \c exec_node 1374 * pointer) for \c last and \c false for \c make_copies on the first 1375 * call. Successive calls pass the return value of the previous call for 1376 * \c last and \c true for \c make_copies. 1377 * 1378 * \param instructions Source instruction stream 1379 * \param last Instruction after which new instructions should be 1380 * inserted in the target instruction stream 1381 * \param make_copies Flag selecting whether instructions in \c instructions 1382 * should be copied (via \c ir_instruction::clone) into the 1383 * target list or moved. 1384 * 1385 * \return 1386 * The new "last" instruction in the target instruction stream. This pointer 1387 * is suitable for use as the \c last parameter of a later call to this 1388 * function. 1389 */ 1390 static exec_node * 1391 move_non_declarations(exec_list *instructions, exec_node *last, 1392 bool make_copies, gl_linked_shader *target) 1393 { 1394 hash_table *temps = NULL; 1395 1396 if (make_copies) 1397 temps = _mesa_hash_table_create(NULL, _mesa_hash_pointer, 1398 _mesa_key_pointer_equal); 1399 1400 foreach_in_list_safe(ir_instruction, inst, instructions) { 1401 if (inst->as_function()) 1402 continue; 1403 1404 ir_variable *var = inst->as_variable(); 1405 if ((var != NULL) && (var->data.mode != ir_var_temporary)) 1406 continue; 1407 1408 assert(inst->as_assignment() 1409 || inst->as_call() 1410 || inst->as_if() /* for initializers with the ?: operator */ 1411 || ((var != NULL) && (var->data.mode == ir_var_temporary))); 1412 1413 if (make_copies) { 1414 inst = inst->clone(target, NULL); 1415 1416 if (var != NULL) 1417 _mesa_hash_table_insert(temps, var, inst); 1418 else 1419 remap_variables(inst, target, temps); 1420 } else { 1421 inst->remove(); 1422 } 1423 1424 last->insert_after(inst); 1425 last = inst; 1426 } 1427 1428 if (make_copies) 1429 _mesa_hash_table_destroy(temps, NULL); 1430 1431 return last; 1432 } 1433 1434 1435 /** 1436 * This class is only used in link_intrastage_shaders() below but declaring 1437 * it inside that function leads to compiler warnings with some versions of 1438 * gcc. 1439 */ 1440 class array_sizing_visitor : public deref_type_updater { 1441 public: 1442 array_sizing_visitor() 1443 : mem_ctx(ralloc_context(NULL)), 1444 unnamed_interfaces(_mesa_hash_table_create(NULL, _mesa_hash_pointer, 1445 _mesa_key_pointer_equal)) 1446 { 1447 } 1448 1449 ~array_sizing_visitor() 1450 { 1451 _mesa_hash_table_destroy(this->unnamed_interfaces, NULL); 1452 ralloc_free(this->mem_ctx); 1453 } 1454 1455 virtual ir_visitor_status visit(ir_variable *var) 1456 { 1457 const glsl_type *type_without_array; 1458 bool implicit_sized_array = var->data.implicit_sized_array; 1459 fixup_type(&var->type, var->data.max_array_access, 1460 var->data.from_ssbo_unsized_array, 1461 &implicit_sized_array); 1462 var->data.implicit_sized_array = implicit_sized_array; 1463 type_without_array = var->type->without_array(); 1464 if (var->type->is_interface()) { 1465 if (interface_contains_unsized_arrays(var->type)) { 1466 const glsl_type *new_type = 1467 resize_interface_members(var->type, 1468 var->get_max_ifc_array_access(), 1469 var->is_in_shader_storage_block()); 1470 var->type = new_type; 1471 var->change_interface_type(new_type); 1472 } 1473 } else if (type_without_array->is_interface()) { 1474 if (interface_contains_unsized_arrays(type_without_array)) { 1475 const glsl_type *new_type = 1476 resize_interface_members(type_without_array, 1477 var->get_max_ifc_array_access(), 1478 var->is_in_shader_storage_block()); 1479 var->change_interface_type(new_type); 1480 var->type = update_interface_members_array(var->type, new_type); 1481 } 1482 } else if (const glsl_type *ifc_type = var->get_interface_type()) { 1483 /* Store a pointer to the variable in the unnamed_interfaces 1484 * hashtable. 1485 */ 1486 hash_entry *entry = 1487 _mesa_hash_table_search(this->unnamed_interfaces, 1488 ifc_type); 1489 1490 ir_variable **interface_vars = entry ? (ir_variable **) entry->data : NULL; 1491 1492 if (interface_vars == NULL) { 1493 interface_vars = rzalloc_array(mem_ctx, ir_variable *, 1494 ifc_type->length); 1495 _mesa_hash_table_insert(this->unnamed_interfaces, ifc_type, 1496 interface_vars); 1497 } 1498 unsigned index = ifc_type->field_index(var->name); 1499 assert(index < ifc_type->length); 1500 assert(interface_vars[index] == NULL); 1501 interface_vars[index] = var; 1502 } 1503 return visit_continue; 1504 } 1505 1506 /** 1507 * For each unnamed interface block that was discovered while running the 1508 * visitor, adjust the interface type to reflect the newly assigned array 1509 * sizes, and fix up the ir_variable nodes to point to the new interface 1510 * type. 1511 */ 1512 void fixup_unnamed_interface_types() 1513 { 1514 hash_table_call_foreach(this->unnamed_interfaces, 1515 fixup_unnamed_interface_type, NULL); 1516 } 1517 1518 private: 1519 /** 1520 * If the type pointed to by \c type represents an unsized array, replace 1521 * it with a sized array whose size is determined by max_array_access. 1522 */ 1523 static void fixup_type(const glsl_type **type, unsigned max_array_access, 1524 bool from_ssbo_unsized_array, bool *implicit_sized) 1525 { 1526 if (!from_ssbo_unsized_array && (*type)->is_unsized_array()) { 1527 *type = glsl_type::get_array_instance((*type)->fields.array, 1528 max_array_access + 1); 1529 *implicit_sized = true; 1530 assert(*type != NULL); 1531 } 1532 } 1533 1534 static const glsl_type * 1535 update_interface_members_array(const glsl_type *type, 1536 const glsl_type *new_interface_type) 1537 { 1538 const glsl_type *element_type = type->fields.array; 1539 if (element_type->is_array()) { 1540 const glsl_type *new_array_type = 1541 update_interface_members_array(element_type, new_interface_type); 1542 return glsl_type::get_array_instance(new_array_type, type->length); 1543 } else { 1544 return glsl_type::get_array_instance(new_interface_type, 1545 type->length); 1546 } 1547 } 1548 1549 /** 1550 * Determine whether the given interface type contains unsized arrays (if 1551 * it doesn't, array_sizing_visitor doesn't need to process it). 1552 */ 1553 static bool interface_contains_unsized_arrays(const glsl_type *type) 1554 { 1555 for (unsigned i = 0; i < type->length; i++) { 1556 const glsl_type *elem_type = type->fields.structure[i].type; 1557 if (elem_type->is_unsized_array()) 1558 return true; 1559 } 1560 return false; 1561 } 1562 1563 /** 1564 * Create a new interface type based on the given type, with unsized arrays 1565 * replaced by sized arrays whose size is determined by 1566 * max_ifc_array_access. 1567 */ 1568 static const glsl_type * 1569 resize_interface_members(const glsl_type *type, 1570 const int *max_ifc_array_access, 1571 bool is_ssbo) 1572 { 1573 unsigned num_fields = type->length; 1574 glsl_struct_field *fields = new glsl_struct_field[num_fields]; 1575 memcpy(fields, type->fields.structure, 1576 num_fields * sizeof(*fields)); 1577 for (unsigned i = 0; i < num_fields; i++) { 1578 bool implicit_sized_array = fields[i].implicit_sized_array; 1579 /* If SSBO last member is unsized array, we don't replace it by a sized 1580 * array. 1581 */ 1582 if (is_ssbo && i == (num_fields - 1)) 1583 fixup_type(&fields[i].type, max_ifc_array_access[i], 1584 true, &implicit_sized_array); 1585 else 1586 fixup_type(&fields[i].type, max_ifc_array_access[i], 1587 false, &implicit_sized_array); 1588 fields[i].implicit_sized_array = implicit_sized_array; 1589 } 1590 glsl_interface_packing packing = 1591 (glsl_interface_packing) type->interface_packing; 1592 bool row_major = (bool) type->interface_row_major; 1593 const glsl_type *new_ifc_type = 1594 glsl_type::get_interface_instance(fields, num_fields, 1595 packing, row_major, type->name); 1596 delete [] fields; 1597 return new_ifc_type; 1598 } 1599 1600 static void fixup_unnamed_interface_type(const void *key, void *data, 1601 void *) 1602 { 1603 const glsl_type *ifc_type = (const glsl_type *) key; 1604 ir_variable **interface_vars = (ir_variable **) data; 1605 unsigned num_fields = ifc_type->length; 1606 glsl_struct_field *fields = new glsl_struct_field[num_fields]; 1607 memcpy(fields, ifc_type->fields.structure, 1608 num_fields * sizeof(*fields)); 1609 bool interface_type_changed = false; 1610 for (unsigned i = 0; i < num_fields; i++) { 1611 if (interface_vars[i] != NULL && 1612 fields[i].type != interface_vars[i]->type) { 1613 fields[i].type = interface_vars[i]->type; 1614 interface_type_changed = true; 1615 } 1616 } 1617 if (!interface_type_changed) { 1618 delete [] fields; 1619 return; 1620 } 1621 glsl_interface_packing packing = 1622 (glsl_interface_packing) ifc_type->interface_packing; 1623 bool row_major = (bool) ifc_type->interface_row_major; 1624 const glsl_type *new_ifc_type = 1625 glsl_type::get_interface_instance(fields, num_fields, packing, 1626 row_major, ifc_type->name); 1627 delete [] fields; 1628 for (unsigned i = 0; i < num_fields; i++) { 1629 if (interface_vars[i] != NULL) 1630 interface_vars[i]->change_interface_type(new_ifc_type); 1631 } 1632 } 1633 1634 /** 1635 * Memory context used to allocate the data in \c unnamed_interfaces. 1636 */ 1637 void *mem_ctx; 1638 1639 /** 1640 * Hash table from const glsl_type * to an array of ir_variable *'s 1641 * pointing to the ir_variables constituting each unnamed interface block. 1642 */ 1643 hash_table *unnamed_interfaces; 1644 }; 1645 1646 static bool 1647 validate_xfb_buffer_stride(struct gl_context *ctx, unsigned idx, 1648 struct gl_shader_program *prog) 1649 { 1650 /* We will validate doubles at a later stage */ 1651 if (prog->TransformFeedback.BufferStride[idx] % 4) { 1652 linker_error(prog, "invalid qualifier xfb_stride=%d must be a " 1653 "multiple of 4 or if its applied to a type that is " 1654 "or contains a double a multiple of 8.", 1655 prog->TransformFeedback.BufferStride[idx]); 1656 return false; 1657 } 1658 1659 if (prog->TransformFeedback.BufferStride[idx] / 4 > 1660 ctx->Const.MaxTransformFeedbackInterleavedComponents) { 1661 linker_error(prog, "The MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS " 1662 "limit has been exceeded."); 1663 return false; 1664 } 1665 1666 return true; 1667 } 1668 1669 /** 1670 * Check for conflicting xfb_stride default qualifiers and store buffer stride 1671 * for later use. 1672 */ 1673 static void 1674 link_xfb_stride_layout_qualifiers(struct gl_context *ctx, 1675 struct gl_shader_program *prog, 1676 struct gl_shader **shader_list, 1677 unsigned num_shaders) 1678 { 1679 for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) { 1680 prog->TransformFeedback.BufferStride[i] = 0; 1681 } 1682 1683 for (unsigned i = 0; i < num_shaders; i++) { 1684 struct gl_shader *shader = shader_list[i]; 1685 1686 for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) { 1687 if (shader->TransformFeedbackBufferStride[j]) { 1688 if (prog->TransformFeedback.BufferStride[j] == 0) { 1689 prog->TransformFeedback.BufferStride[j] = 1690 shader->TransformFeedbackBufferStride[j]; 1691 if (!validate_xfb_buffer_stride(ctx, j, prog)) 1692 return; 1693 } else if (prog->TransformFeedback.BufferStride[j] != 1694 shader->TransformFeedbackBufferStride[j]){ 1695 linker_error(prog, 1696 "intrastage shaders defined with conflicting " 1697 "xfb_stride for buffer %d (%d and %d)\n", j, 1698 prog->TransformFeedback.BufferStride[j], 1699 shader->TransformFeedbackBufferStride[j]); 1700 return; 1701 } 1702 } 1703 } 1704 } 1705 } 1706 1707 /** 1708 * Check for conflicting bindless/bound sampler/image layout qualifiers at 1709 * global scope. 1710 */ 1711 static void 1712 link_bindless_layout_qualifiers(struct gl_shader_program *prog, 1713 struct gl_shader **shader_list, 1714 unsigned num_shaders) 1715 { 1716 bool bindless_sampler, bindless_image; 1717 bool bound_sampler, bound_image; 1718 1719 bindless_sampler = bindless_image = false; 1720 bound_sampler = bound_image = false; 1721 1722 for (unsigned i = 0; i < num_shaders; i++) { 1723 struct gl_shader *shader = shader_list[i]; 1724 1725 if (shader->bindless_sampler) 1726 bindless_sampler = true; 1727 if (shader->bindless_image) 1728 bindless_image = true; 1729 if (shader->bound_sampler) 1730 bound_sampler = true; 1731 if (shader->bound_image) 1732 bound_image = true; 1733 1734 if ((bindless_sampler && bound_sampler) || 1735 (bindless_image && bound_image)) { 1736 /* From section 4.4.6 of the ARB_bindless_texture spec: 1737 * 1738 * "If both bindless_sampler and bound_sampler, or bindless_image 1739 * and bound_image, are declared at global scope in any 1740 * compilation unit, a link- time error will be generated." 1741 */ 1742 linker_error(prog, "both bindless_sampler and bound_sampler, or " 1743 "bindless_image and bound_image, can't be declared at " 1744 "global scope"); 1745 } 1746 } 1747 } 1748 1749 /** 1750 * Performs the cross-validation of tessellation control shader vertices and 1751 * layout qualifiers for the attached tessellation control shaders, 1752 * and propagates them to the linked TCS and linked shader program. 1753 */ 1754 static void 1755 link_tcs_out_layout_qualifiers(struct gl_shader_program *prog, 1756 struct gl_program *gl_prog, 1757 struct gl_shader **shader_list, 1758 unsigned num_shaders) 1759 { 1760 if (gl_prog->info.stage != MESA_SHADER_TESS_CTRL) 1761 return; 1762 1763 gl_prog->info.tess.tcs_vertices_out = 0; 1764 1765 /* From the GLSL 4.0 spec (chapter 4.3.8.2): 1766 * 1767 * "All tessellation control shader layout declarations in a program 1768 * must specify the same output patch vertex count. There must be at 1769 * least one layout qualifier specifying an output patch vertex count 1770 * in any program containing tessellation control shaders; however, 1771 * such a declaration is not required in all tessellation control 1772 * shaders." 1773 */ 1774 1775 for (unsigned i = 0; i < num_shaders; i++) { 1776 struct gl_shader *shader = shader_list[i]; 1777 1778 if (shader->info.TessCtrl.VerticesOut != 0) { 1779 if (gl_prog->info.tess.tcs_vertices_out != 0 && 1780 gl_prog->info.tess.tcs_vertices_out != 1781 (unsigned) shader->info.TessCtrl.VerticesOut) { 1782 linker_error(prog, "tessellation control shader defined with " 1783 "conflicting output vertex count (%d and %d)\n", 1784 gl_prog->info.tess.tcs_vertices_out, 1785 shader->info.TessCtrl.VerticesOut); 1786 return; 1787 } 1788 gl_prog->info.tess.tcs_vertices_out = 1789 shader->info.TessCtrl.VerticesOut; 1790 } 1791 } 1792 1793 /* Just do the intrastage -> interstage propagation right now, 1794 * since we already know we're in the right type of shader program 1795 * for doing it. 1796 */ 1797 if (gl_prog->info.tess.tcs_vertices_out == 0) { 1798 linker_error(prog, "tessellation control shader didn't declare " 1799 "vertices out layout qualifier\n"); 1800 return; 1801 } 1802 } 1803 1804 1805 /** 1806 * Performs the cross-validation of tessellation evaluation shader 1807 * primitive type, vertex spacing, ordering and point_mode layout qualifiers 1808 * for the attached tessellation evaluation shaders, and propagates them 1809 * to the linked TES and linked shader program. 1810 */ 1811 static void 1812 link_tes_in_layout_qualifiers(struct gl_shader_program *prog, 1813 struct gl_program *gl_prog, 1814 struct gl_shader **shader_list, 1815 unsigned num_shaders) 1816 { 1817 if (gl_prog->info.stage != MESA_SHADER_TESS_EVAL) 1818 return; 1819 1820 int point_mode = -1; 1821 unsigned vertex_order = 0; 1822 1823 gl_prog->info.tess.primitive_mode = PRIM_UNKNOWN; 1824 gl_prog->info.tess.spacing = TESS_SPACING_UNSPECIFIED; 1825 1826 /* From the GLSL 4.0 spec (chapter 4.3.8.1): 1827 * 1828 * "At least one tessellation evaluation shader (compilation unit) in 1829 * a program must declare a primitive mode in its input layout. 1830 * Declaration vertex spacing, ordering, and point mode identifiers is 1831 * optional. It is not required that all tessellation evaluation 1832 * shaders in a program declare a primitive mode. If spacing or 1833 * vertex ordering declarations are omitted, the tessellation 1834 * primitive generator will use equal spacing or counter-clockwise 1835 * vertex ordering, respectively. If a point mode declaration is 1836 * omitted, the tessellation primitive generator will produce lines or 1837 * triangles according to the primitive mode." 1838 */ 1839 1840 for (unsigned i = 0; i < num_shaders; i++) { 1841 struct gl_shader *shader = shader_list[i]; 1842 1843 if (shader->info.TessEval.PrimitiveMode != PRIM_UNKNOWN) { 1844 if (gl_prog->info.tess.primitive_mode != PRIM_UNKNOWN && 1845 gl_prog->info.tess.primitive_mode != 1846 shader->info.TessEval.PrimitiveMode) { 1847 linker_error(prog, "tessellation evaluation shader defined with " 1848 "conflicting input primitive modes.\n"); 1849 return; 1850 } 1851 gl_prog->info.tess.primitive_mode = 1852 shader->info.TessEval.PrimitiveMode; 1853 } 1854 1855 if (shader->info.TessEval.Spacing != 0) { 1856 if (gl_prog->info.tess.spacing != 0 && gl_prog->info.tess.spacing != 1857 shader->info.TessEval.Spacing) { 1858 linker_error(prog, "tessellation evaluation shader defined with " 1859 "conflicting vertex spacing.\n"); 1860 return; 1861 } 1862 gl_prog->info.tess.spacing = shader->info.TessEval.Spacing; 1863 } 1864 1865 if (shader->info.TessEval.VertexOrder != 0) { 1866 if (vertex_order != 0 && 1867 vertex_order != shader->info.TessEval.VertexOrder) { 1868 linker_error(prog, "tessellation evaluation shader defined with " 1869 "conflicting ordering.\n"); 1870 return; 1871 } 1872 vertex_order = shader->info.TessEval.VertexOrder; 1873 } 1874 1875 if (shader->info.TessEval.PointMode != -1) { 1876 if (point_mode != -1 && 1877 point_mode != shader->info.TessEval.PointMode) { 1878 linker_error(prog, "tessellation evaluation shader defined with " 1879 "conflicting point modes.\n"); 1880 return; 1881 } 1882 point_mode = shader->info.TessEval.PointMode; 1883 } 1884 1885 } 1886 1887 /* Just do the intrastage -> interstage propagation right now, 1888 * since we already know we're in the right type of shader program 1889 * for doing it. 1890 */ 1891 if (gl_prog->info.tess.primitive_mode == PRIM_UNKNOWN) { 1892 linker_error(prog, 1893 "tessellation evaluation shader didn't declare input " 1894 "primitive modes.\n"); 1895 return; 1896 } 1897 1898 if (gl_prog->info.tess.spacing == TESS_SPACING_UNSPECIFIED) 1899 gl_prog->info.tess.spacing = TESS_SPACING_EQUAL; 1900 1901 if (vertex_order == 0 || vertex_order == GL_CCW) 1902 gl_prog->info.tess.ccw = true; 1903 else 1904 gl_prog->info.tess.ccw = false; 1905 1906 1907 if (point_mode == -1 || point_mode == GL_FALSE) 1908 gl_prog->info.tess.point_mode = false; 1909 else 1910 gl_prog->info.tess.point_mode = true; 1911 } 1912 1913 1914 /** 1915 * Performs the cross-validation of layout qualifiers specified in 1916 * redeclaration of gl_FragCoord for the attached fragment shaders, 1917 * and propagates them to the linked FS and linked shader program. 1918 */ 1919 static void 1920 link_fs_inout_layout_qualifiers(struct gl_shader_program *prog, 1921 struct gl_linked_shader *linked_shader, 1922 struct gl_shader **shader_list, 1923 unsigned num_shaders) 1924 { 1925 bool redeclares_gl_fragcoord = false; 1926 bool uses_gl_fragcoord = false; 1927 bool origin_upper_left = false; 1928 bool pixel_center_integer = false; 1929 1930 if (linked_shader->Stage != MESA_SHADER_FRAGMENT || 1931 (prog->data->Version < 150 && 1932 !prog->ARB_fragment_coord_conventions_enable)) 1933 return; 1934 1935 for (unsigned i = 0; i < num_shaders; i++) { 1936 struct gl_shader *shader = shader_list[i]; 1937 /* From the GLSL 1.50 spec, page 39: 1938 * 1939 * "If gl_FragCoord is redeclared in any fragment shader in a program, 1940 * it must be redeclared in all the fragment shaders in that program 1941 * that have a static use gl_FragCoord." 1942 */ 1943 if ((redeclares_gl_fragcoord && !shader->redeclares_gl_fragcoord && 1944 shader->uses_gl_fragcoord) 1945 || (shader->redeclares_gl_fragcoord && !redeclares_gl_fragcoord && 1946 uses_gl_fragcoord)) { 1947 linker_error(prog, "fragment shader defined with conflicting " 1948 "layout qualifiers for gl_FragCoord\n"); 1949 } 1950 1951 /* From the GLSL 1.50 spec, page 39: 1952 * 1953 * "All redeclarations of gl_FragCoord in all fragment shaders in a 1954 * single program must have the same set of qualifiers." 1955 */ 1956 if (redeclares_gl_fragcoord && shader->redeclares_gl_fragcoord && 1957 (shader->origin_upper_left != origin_upper_left || 1958 shader->pixel_center_integer != pixel_center_integer)) { 1959 linker_error(prog, "fragment shader defined with conflicting " 1960 "layout qualifiers for gl_FragCoord\n"); 1961 } 1962 1963 /* Update the linked shader state. Note that uses_gl_fragcoord should 1964 * accumulate the results. The other values should replace. If there 1965 * are multiple redeclarations, all the fields except uses_gl_fragcoord 1966 * are already known to be the same. 1967 */ 1968 if (shader->redeclares_gl_fragcoord || shader->uses_gl_fragcoord) { 1969 redeclares_gl_fragcoord = shader->redeclares_gl_fragcoord; 1970 uses_gl_fragcoord |= shader->uses_gl_fragcoord; 1971 origin_upper_left = shader->origin_upper_left; 1972 pixel_center_integer = shader->pixel_center_integer; 1973 } 1974 1975 linked_shader->Program->info.fs.early_fragment_tests |= 1976 shader->EarlyFragmentTests || shader->PostDepthCoverage; 1977 linked_shader->Program->info.fs.inner_coverage |= shader->InnerCoverage; 1978 linked_shader->Program->info.fs.post_depth_coverage |= 1979 shader->PostDepthCoverage; 1980 1981 linked_shader->Program->sh.fs.BlendSupport |= shader->BlendSupport; 1982 } 1983 } 1984 1985 /** 1986 * Performs the cross-validation of geometry shader max_vertices and 1987 * primitive type layout qualifiers for the attached geometry shaders, 1988 * and propagates them to the linked GS and linked shader program. 1989 */ 1990 static void 1991 link_gs_inout_layout_qualifiers(struct gl_shader_program *prog, 1992 struct gl_program *gl_prog, 1993 struct gl_shader **shader_list, 1994 unsigned num_shaders) 1995 { 1996 /* No in/out qualifiers defined for anything but GLSL 1.50+ 1997 * geometry shaders so far. 1998 */ 1999 if (gl_prog->info.stage != MESA_SHADER_GEOMETRY || 2000 prog->data->Version < 150) 2001 return; 2002 2003 int vertices_out = -1; 2004 2005 gl_prog->info.gs.invocations = 0; 2006 gl_prog->info.gs.input_primitive = PRIM_UNKNOWN; 2007 gl_prog->info.gs.output_primitive = PRIM_UNKNOWN; 2008 2009 /* From the GLSL 1.50 spec, page 46: 2010 * 2011 * "All geometry shader output layout declarations in a program 2012 * must declare the same layout and same value for 2013 * max_vertices. There must be at least one geometry output 2014 * layout declaration somewhere in a program, but not all 2015 * geometry shaders (compilation units) are required to 2016 * declare it." 2017 */ 2018 2019 for (unsigned i = 0; i < num_shaders; i++) { 2020 struct gl_shader *shader = shader_list[i]; 2021 2022 if (shader->info.Geom.InputType != PRIM_UNKNOWN) { 2023 if (gl_prog->info.gs.input_primitive != PRIM_UNKNOWN && 2024 gl_prog->info.gs.input_primitive != 2025 shader->info.Geom.InputType) { 2026 linker_error(prog, "geometry shader defined with conflicting " 2027 "input types\n"); 2028 return; 2029 } 2030 gl_prog->info.gs.input_primitive = shader->info.Geom.InputType; 2031 } 2032 2033 if (shader->info.Geom.OutputType != PRIM_UNKNOWN) { 2034 if (gl_prog->info.gs.output_primitive != PRIM_UNKNOWN && 2035 gl_prog->info.gs.output_primitive != 2036 shader->info.Geom.OutputType) { 2037 linker_error(prog, "geometry shader defined with conflicting " 2038 "output types\n"); 2039 return; 2040 } 2041 gl_prog->info.gs.output_primitive = shader->info.Geom.OutputType; 2042 } 2043 2044 if (shader->info.Geom.VerticesOut != -1) { 2045 if (vertices_out != -1 && 2046 vertices_out != shader->info.Geom.VerticesOut) { 2047 linker_error(prog, "geometry shader defined with conflicting " 2048 "output vertex count (%d and %d)\n", 2049 vertices_out, shader->info.Geom.VerticesOut); 2050 return; 2051 } 2052 vertices_out = shader->info.Geom.VerticesOut; 2053 } 2054 2055 if (shader->info.Geom.Invocations != 0) { 2056 if (gl_prog->info.gs.invocations != 0 && 2057 gl_prog->info.gs.invocations != 2058 (unsigned) shader->info.Geom.Invocations) { 2059 linker_error(prog, "geometry shader defined with conflicting " 2060 "invocation count (%d and %d)\n", 2061 gl_prog->info.gs.invocations, 2062 shader->info.Geom.Invocations); 2063 return; 2064 } 2065 gl_prog->info.gs.invocations = shader->info.Geom.Invocations; 2066 } 2067 } 2068 2069 /* Just do the intrastage -> interstage propagation right now, 2070 * since we already know we're in the right type of shader program 2071 * for doing it. 2072 */ 2073 if (gl_prog->info.gs.input_primitive == PRIM_UNKNOWN) { 2074 linker_error(prog, 2075 "geometry shader didn't declare primitive input type\n"); 2076 return; 2077 } 2078 2079 if (gl_prog->info.gs.output_primitive == PRIM_UNKNOWN) { 2080 linker_error(prog, 2081 "geometry shader didn't declare primitive output type\n"); 2082 return; 2083 } 2084 2085 if (vertices_out == -1) { 2086 linker_error(prog, 2087 "geometry shader didn't declare max_vertices\n"); 2088 return; 2089 } else { 2090 gl_prog->info.gs.vertices_out = vertices_out; 2091 } 2092 2093 if (gl_prog->info.gs.invocations == 0) 2094 gl_prog->info.gs.invocations = 1; 2095 } 2096 2097 2098 /** 2099 * Perform cross-validation of compute shader local_size_{x,y,z} layout 2100 * qualifiers for the attached compute shaders, and propagate them to the 2101 * linked CS and linked shader program. 2102 */ 2103 static void 2104 link_cs_input_layout_qualifiers(struct gl_shader_program *prog, 2105 struct gl_program *gl_prog, 2106 struct gl_shader **shader_list, 2107 unsigned num_shaders) 2108 { 2109 /* This function is called for all shader stages, but it only has an effect 2110 * for compute shaders. 2111 */ 2112 if (gl_prog->info.stage != MESA_SHADER_COMPUTE) 2113 return; 2114 2115 for (int i = 0; i < 3; i++) 2116 gl_prog->info.cs.local_size[i] = 0; 2117 2118 gl_prog->info.cs.local_size_variable = false; 2119 2120 /* From the ARB_compute_shader spec, in the section describing local size 2121 * declarations: 2122 * 2123 * If multiple compute shaders attached to a single program object 2124 * declare local work-group size, the declarations must be identical; 2125 * otherwise a link-time error results. Furthermore, if a program 2126 * object contains any compute shaders, at least one must contain an 2127 * input layout qualifier specifying the local work sizes of the 2128 * program, or a link-time error will occur. 2129 */ 2130 for (unsigned sh = 0; sh < num_shaders; sh++) { 2131 struct gl_shader *shader = shader_list[sh]; 2132 2133 if (shader->info.Comp.LocalSize[0] != 0) { 2134 if (gl_prog->info.cs.local_size[0] != 0) { 2135 for (int i = 0; i < 3; i++) { 2136 if (gl_prog->info.cs.local_size[i] != 2137 shader->info.Comp.LocalSize[i]) { 2138 linker_error(prog, "compute shader defined with conflicting " 2139 "local sizes\n"); 2140 return; 2141 } 2142 } 2143 } 2144 for (int i = 0; i < 3; i++) { 2145 gl_prog->info.cs.local_size[i] = 2146 shader->info.Comp.LocalSize[i]; 2147 } 2148 } else if (shader->info.Comp.LocalSizeVariable) { 2149 if (gl_prog->info.cs.local_size[0] != 0) { 2150 /* The ARB_compute_variable_group_size spec says: 2151 * 2152 * If one compute shader attached to a program declares a 2153 * variable local group size and a second compute shader 2154 * attached to the same program declares a fixed local group 2155 * size, a link-time error results. 2156 */ 2157 linker_error(prog, "compute shader defined with both fixed and " 2158 "variable local group size\n"); 2159 return; 2160 } 2161 gl_prog->info.cs.local_size_variable = true; 2162 } 2163 } 2164 2165 /* Just do the intrastage -> interstage propagation right now, 2166 * since we already know we're in the right type of shader program 2167 * for doing it. 2168 */ 2169 if (gl_prog->info.cs.local_size[0] == 0 && 2170 !gl_prog->info.cs.local_size_variable) { 2171 linker_error(prog, "compute shader must contain a fixed or a variable " 2172 "local group size\n"); 2173 return; 2174 } 2175 } 2176 2177 2178 /** 2179 * Combine a group of shaders for a single stage to generate a linked shader 2180 * 2181 * \note 2182 * If this function is supplied a single shader, it is cloned, and the new 2183 * shader is returned. 2184 */ 2185 struct gl_linked_shader * 2186 link_intrastage_shaders(void *mem_ctx, 2187 struct gl_context *ctx, 2188 struct gl_shader_program *prog, 2189 struct gl_shader **shader_list, 2190 unsigned num_shaders, 2191 bool allow_missing_main) 2192 { 2193 struct gl_uniform_block *ubo_blocks = NULL; 2194 struct gl_uniform_block *ssbo_blocks = NULL; 2195 unsigned num_ubo_blocks = 0; 2196 unsigned num_ssbo_blocks = 0; 2197 2198 /* Check that global variables defined in multiple shaders are consistent. 2199 */ 2200 glsl_symbol_table variables; 2201 for (unsigned i = 0; i < num_shaders; i++) { 2202 if (shader_list[i] == NULL) 2203 continue; 2204 cross_validate_globals(prog, shader_list[i]->ir, &variables, false); 2205 } 2206 2207 if (!prog->data->LinkStatus) 2208 return NULL; 2209 2210 /* Check that interface blocks defined in multiple shaders are consistent. 2211 */ 2212 validate_intrastage_interface_blocks(prog, (const gl_shader **)shader_list, 2213 num_shaders); 2214 if (!prog->data->LinkStatus) 2215 return NULL; 2216 2217 /* Check that there is only a single definition of each function signature 2218 * across all shaders. 2219 */ 2220 for (unsigned i = 0; i < (num_shaders - 1); i++) { 2221 foreach_in_list(ir_instruction, node, shader_list[i]->ir) { 2222 ir_function *const f = node->as_function(); 2223 2224 if (f == NULL) 2225 continue; 2226 2227 for (unsigned j = i + 1; j < num_shaders; j++) { 2228 ir_function *const other = 2229 shader_list[j]->symbols->get_function(f->name); 2230 2231 /* If the other shader has no function (and therefore no function 2232 * signatures) with the same name, skip to the next shader. 2233 */ 2234 if (other == NULL) 2235 continue; 2236 2237 foreach_in_list(ir_function_signature, sig, &f->signatures) { 2238 if (!sig->is_defined) 2239 continue; 2240 2241 ir_function_signature *other_sig = 2242 other->exact_matching_signature(NULL, &sig->parameters); 2243 2244 if (other_sig != NULL && other_sig->is_defined) { 2245 linker_error(prog, "function `%s' is multiply defined\n", 2246 f->name); 2247 return NULL; 2248 } 2249 } 2250 } 2251 } 2252 } 2253 2254 /* Find the shader that defines main, and make a clone of it. 2255 * 2256 * Starting with the clone, search for undefined references. If one is 2257 * found, find the shader that defines it. Clone the reference and add 2258 * it to the shader. Repeat until there are no undefined references or 2259 * until a reference cannot be resolved. 2260 */ 2261 gl_shader *main = NULL; 2262 for (unsigned i = 0; i < num_shaders; i++) { 2263 if (_mesa_get_main_function_signature(shader_list[i]->symbols)) { 2264 main = shader_list[i]; 2265 break; 2266 } 2267 } 2268 2269 if (main == NULL && allow_missing_main) 2270 main = shader_list[0]; 2271 2272 if (main == NULL) { 2273 linker_error(prog, "%s shader lacks `main'\n", 2274 _mesa_shader_stage_to_string(shader_list[0]->Stage)); 2275 return NULL; 2276 } 2277 2278 gl_linked_shader *linked = rzalloc(NULL, struct gl_linked_shader); 2279 linked->Stage = shader_list[0]->Stage; 2280 2281 /* Create program and attach it to the linked shader */ 2282 struct gl_program *gl_prog = 2283 ctx->Driver.NewProgram(ctx, 2284 _mesa_shader_stage_to_program(shader_list[0]->Stage), 2285 prog->Name, false); 2286 if (!gl_prog) { 2287 prog->data->LinkStatus = linking_failure; 2288 _mesa_delete_linked_shader(ctx, linked); 2289 return NULL; 2290 } 2291 2292 _mesa_reference_shader_program_data(ctx, &gl_prog->sh.data, prog->data); 2293 2294 /* Don't use _mesa_reference_program() just take ownership */ 2295 linked->Program = gl_prog; 2296 2297 linked->ir = new(linked) exec_list; 2298 clone_ir_list(mem_ctx, linked->ir, main->ir); 2299 2300 link_fs_inout_layout_qualifiers(prog, linked, shader_list, num_shaders); 2301 link_tcs_out_layout_qualifiers(prog, gl_prog, shader_list, num_shaders); 2302 link_tes_in_layout_qualifiers(prog, gl_prog, shader_list, num_shaders); 2303 link_gs_inout_layout_qualifiers(prog, gl_prog, shader_list, num_shaders); 2304 link_cs_input_layout_qualifiers(prog, gl_prog, shader_list, num_shaders); 2305 2306 if (linked->Stage != MESA_SHADER_FRAGMENT) 2307 link_xfb_stride_layout_qualifiers(ctx, prog, shader_list, num_shaders); 2308 2309 link_bindless_layout_qualifiers(prog, shader_list, num_shaders); 2310 2311 populate_symbol_table(linked, shader_list[0]->symbols); 2312 2313 /* The pointer to the main function in the final linked shader (i.e., the 2314 * copy of the original shader that contained the main function). 2315 */ 2316 ir_function_signature *const main_sig = 2317 _mesa_get_main_function_signature(linked->symbols); 2318 2319 /* Move any instructions other than variable declarations or function 2320 * declarations into main. 2321 */ 2322 if (main_sig != NULL) { 2323 exec_node *insertion_point = 2324 move_non_declarations(linked->ir, (exec_node *) &main_sig->body, false, 2325 linked); 2326 2327 for (unsigned i = 0; i < num_shaders; i++) { 2328 if (shader_list[i] == main) 2329 continue; 2330 2331 insertion_point = move_non_declarations(shader_list[i]->ir, 2332 insertion_point, true, linked); 2333 } 2334 } 2335 2336 if (!link_function_calls(prog, linked, shader_list, num_shaders)) { 2337 _mesa_delete_linked_shader(ctx, linked); 2338 return NULL; 2339 } 2340 2341 /* Make a pass over all variable declarations to ensure that arrays with 2342 * unspecified sizes have a size specified. The size is inferred from the 2343 * max_array_access field. 2344 */ 2345 array_sizing_visitor v; 2346 v.run(linked->ir); 2347 v.fixup_unnamed_interface_types(); 2348 2349 /* Link up uniform blocks defined within this stage. */ 2350 link_uniform_blocks(mem_ctx, ctx, prog, linked, &ubo_blocks, 2351 &num_ubo_blocks, &ssbo_blocks, &num_ssbo_blocks); 2352 2353 if (!prog->data->LinkStatus) { 2354 _mesa_delete_linked_shader(ctx, linked); 2355 return NULL; 2356 } 2357 2358 /* Copy ubo blocks to linked shader list */ 2359 linked->Program->sh.UniformBlocks = 2360 ralloc_array(linked, gl_uniform_block *, num_ubo_blocks); 2361 ralloc_steal(linked, ubo_blocks); 2362 for (unsigned i = 0; i < num_ubo_blocks; i++) { 2363 linked->Program->sh.UniformBlocks[i] = &ubo_blocks[i]; 2364 } 2365 linked->Program->info.num_ubos = num_ubo_blocks; 2366 2367 /* Copy ssbo blocks to linked shader list */ 2368 linked->Program->sh.ShaderStorageBlocks = 2369 ralloc_array(linked, gl_uniform_block *, num_ssbo_blocks); 2370 ralloc_steal(linked, ssbo_blocks); 2371 for (unsigned i = 0; i < num_ssbo_blocks; i++) { 2372 linked->Program->sh.ShaderStorageBlocks[i] = &ssbo_blocks[i]; 2373 } 2374 linked->Program->info.num_ssbos = num_ssbo_blocks; 2375 2376 /* At this point linked should contain all of the linked IR, so 2377 * validate it to make sure nothing went wrong. 2378 */ 2379 validate_ir_tree(linked->ir); 2380 2381 /* Set the size of geometry shader input arrays */ 2382 if (linked->Stage == MESA_SHADER_GEOMETRY) { 2383 unsigned num_vertices = 2384 vertices_per_prim(gl_prog->info.gs.input_primitive); 2385 array_resize_visitor input_resize_visitor(num_vertices, prog, 2386 MESA_SHADER_GEOMETRY); 2387 foreach_in_list(ir_instruction, ir, linked->ir) { 2388 ir->accept(&input_resize_visitor); 2389 } 2390 } 2391 2392 if (ctx->Const.VertexID_is_zero_based) 2393 lower_vertex_id(linked); 2394 2395 if (ctx->Const.LowerCsDerivedVariables) 2396 lower_cs_derived(linked); 2397 2398 #ifdef DEBUG 2399 /* Compute the source checksum. */ 2400 linked->SourceChecksum = 0; 2401 for (unsigned i = 0; i < num_shaders; i++) { 2402 if (shader_list[i] == NULL) 2403 continue; 2404 linked->SourceChecksum ^= shader_list[i]->SourceChecksum; 2405 } 2406 #endif 2407 2408 return linked; 2409 } 2410 2411 /** 2412 * Update the sizes of linked shader uniform arrays to the maximum 2413 * array index used. 2414 * 2415 * From page 81 (page 95 of the PDF) of the OpenGL 2.1 spec: 2416 * 2417 * If one or more elements of an array are active, 2418 * GetActiveUniform will return the name of the array in name, 2419 * subject to the restrictions listed above. The type of the array 2420 * is returned in type. The size parameter contains the highest 2421 * array element index used, plus one. The compiler or linker 2422 * determines the highest index used. There will be only one 2423 * active uniform reported by the GL per uniform array. 2424 2425 */ 2426 static void 2427 update_array_sizes(struct gl_shader_program *prog) 2428 { 2429 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 2430 if (prog->_LinkedShaders[i] == NULL) 2431 continue; 2432 2433 bool types_were_updated = false; 2434 2435 foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) { 2436 ir_variable *const var = node->as_variable(); 2437 2438 if ((var == NULL) || (var->data.mode != ir_var_uniform) || 2439 !var->type->is_array()) 2440 continue; 2441 2442 /* GL_ARB_uniform_buffer_object says that std140 uniforms 2443 * will not be eliminated. Since we always do std140, just 2444 * don't resize arrays in UBOs. 2445 * 2446 * Atomic counters are supposed to get deterministic 2447 * locations assigned based on the declaration ordering and 2448 * sizes, array compaction would mess that up. 2449 * 2450 * Subroutine uniforms are not removed. 2451 */ 2452 if (var->is_in_buffer_block() || var->type->contains_atomic() || 2453 var->type->contains_subroutine() || var->constant_initializer) 2454 continue; 2455 2456 int size = var->data.max_array_access; 2457 for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) { 2458 if (prog->_LinkedShaders[j] == NULL) 2459 continue; 2460 2461 foreach_in_list(ir_instruction, node2, prog->_LinkedShaders[j]->ir) { 2462 ir_variable *other_var = node2->as_variable(); 2463 if (!other_var) 2464 continue; 2465 2466 if (strcmp(var->name, other_var->name) == 0 && 2467 other_var->data.max_array_access > size) { 2468 size = other_var->data.max_array_access; 2469 } 2470 } 2471 } 2472 2473 if (size + 1 != (int)var->type->length) { 2474 /* If this is a built-in uniform (i.e., it's backed by some 2475 * fixed-function state), adjust the number of state slots to 2476 * match the new array size. The number of slots per array entry 2477 * is not known. It seems safe to assume that the total number of 2478 * slots is an integer multiple of the number of array elements. 2479 * Determine the number of slots per array element by dividing by 2480 * the old (total) size. 2481 */ 2482 const unsigned num_slots = var->get_num_state_slots(); 2483 if (num_slots > 0) { 2484 var->set_num_state_slots((size + 1) 2485 * (num_slots / var->type->length)); 2486 } 2487 2488 var->type = glsl_type::get_array_instance(var->type->fields.array, 2489 size + 1); 2490 types_were_updated = true; 2491 } 2492 } 2493 2494 /* Update the types of dereferences in case we changed any. */ 2495 if (types_were_updated) { 2496 deref_type_updater v; 2497 v.run(prog->_LinkedShaders[i]->ir); 2498 } 2499 } 2500 } 2501 2502 /** 2503 * Resize tessellation evaluation per-vertex inputs to the size of 2504 * tessellation control per-vertex outputs. 2505 */ 2506 static void 2507 resize_tes_inputs(struct gl_context *ctx, 2508 struct gl_shader_program *prog) 2509 { 2510 if (prog->_LinkedShaders[MESA_SHADER_TESS_EVAL] == NULL) 2511 return; 2512 2513 gl_linked_shader *const tcs = prog->_LinkedShaders[MESA_SHADER_TESS_CTRL]; 2514 gl_linked_shader *const tes = prog->_LinkedShaders[MESA_SHADER_TESS_EVAL]; 2515 2516 /* If no control shader is present, then the TES inputs are statically 2517 * sized to MaxPatchVertices; the actual size of the arrays won't be 2518 * known until draw time. 2519 */ 2520 const int num_vertices = tcs 2521 ? tcs->Program->info.tess.tcs_vertices_out 2522 : ctx->Const.MaxPatchVertices; 2523 2524 array_resize_visitor input_resize_visitor(num_vertices, prog, 2525 MESA_SHADER_TESS_EVAL); 2526 foreach_in_list(ir_instruction, ir, tes->ir) { 2527 ir->accept(&input_resize_visitor); 2528 } 2529 2530 if (tcs) { 2531 /* Convert the gl_PatchVerticesIn system value into a constant, since 2532 * the value is known at this point. 2533 */ 2534 foreach_in_list(ir_instruction, ir, tes->ir) { 2535 ir_variable *var = ir->as_variable(); 2536 if (var && var->data.mode == ir_var_system_value && 2537 var->data.location == SYSTEM_VALUE_VERTICES_IN) { 2538 void *mem_ctx = ralloc_parent(var); 2539 var->data.location = 0; 2540 var->data.explicit_location = false; 2541 var->data.mode = ir_var_auto; 2542 var->constant_value = new(mem_ctx) ir_constant(num_vertices); 2543 } 2544 } 2545 } 2546 } 2547 2548 /** 2549 * Find a contiguous set of available bits in a bitmask. 2550 * 2551 * \param used_mask Bits representing used (1) and unused (0) locations 2552 * \param needed_count Number of contiguous bits needed. 2553 * 2554 * \return 2555 * Base location of the available bits on success or -1 on failure. 2556 */ 2557 static int 2558 find_available_slots(unsigned used_mask, unsigned needed_count) 2559 { 2560 unsigned needed_mask = (1 << needed_count) - 1; 2561 const int max_bit_to_test = (8 * sizeof(used_mask)) - needed_count; 2562 2563 /* The comparison to 32 is redundant, but without it GCC emits "warning: 2564 * cannot optimize possibly infinite loops" for the loop below. 2565 */ 2566 if ((needed_count == 0) || (max_bit_to_test < 0) || (max_bit_to_test > 32)) 2567 return -1; 2568 2569 for (int i = 0; i <= max_bit_to_test; i++) { 2570 if ((needed_mask & ~used_mask) == needed_mask) 2571 return i; 2572 2573 needed_mask <<= 1; 2574 } 2575 2576 return -1; 2577 } 2578 2579 2580 #define SAFE_MASK_FROM_INDEX(i) (((i) >= 32) ? ~0 : ((1 << (i)) - 1)) 2581 2582 /** 2583 * Assign locations for either VS inputs or FS outputs 2584 * 2585 * \param mem_ctx Temporary ralloc context used for linking 2586 * \param prog Shader program whose variables need locations assigned 2587 * \param constants Driver specific constant values for the program. 2588 * \param target_index Selector for the program target to receive location 2589 * assignmnets. Must be either \c MESA_SHADER_VERTEX or 2590 * \c MESA_SHADER_FRAGMENT. 2591 * 2592 * \return 2593 * If locations are successfully assigned, true is returned. Otherwise an 2594 * error is emitted to the shader link log and false is returned. 2595 */ 2596 static bool 2597 assign_attribute_or_color_locations(void *mem_ctx, 2598 gl_shader_program *prog, 2599 struct gl_constants *constants, 2600 unsigned target_index) 2601 { 2602 /* Maximum number of generic locations. This corresponds to either the 2603 * maximum number of draw buffers or the maximum number of generic 2604 * attributes. 2605 */ 2606 unsigned max_index = (target_index == MESA_SHADER_VERTEX) ? 2607 constants->Program[target_index].MaxAttribs : 2608 MAX2(constants->MaxDrawBuffers, constants->MaxDualSourceDrawBuffers); 2609 2610 /* Mark invalid locations as being used. 2611 */ 2612 unsigned used_locations = ~SAFE_MASK_FROM_INDEX(max_index); 2613 unsigned double_storage_locations = 0; 2614 2615 assert((target_index == MESA_SHADER_VERTEX) 2616 || (target_index == MESA_SHADER_FRAGMENT)); 2617 2618 gl_linked_shader *const sh = prog->_LinkedShaders[target_index]; 2619 if (sh == NULL) 2620 return true; 2621 2622 /* Operate in a total of four passes. 2623 * 2624 * 1. Invalidate the location assignments for all vertex shader inputs. 2625 * 2626 * 2. Assign locations for inputs that have user-defined (via 2627 * glBindVertexAttribLocation) locations and outputs that have 2628 * user-defined locations (via glBindFragDataLocation). 2629 * 2630 * 3. Sort the attributes without assigned locations by number of slots 2631 * required in decreasing order. Fragmentation caused by attribute 2632 * locations assigned by the application may prevent large attributes 2633 * from having enough contiguous space. 2634 * 2635 * 4. Assign locations to any inputs without assigned locations. 2636 */ 2637 2638 const int generic_base = (target_index == MESA_SHADER_VERTEX) 2639 ? (int) VERT_ATTRIB_GENERIC0 : (int) FRAG_RESULT_DATA0; 2640 2641 const enum ir_variable_mode direction = 2642 (target_index == MESA_SHADER_VERTEX) 2643 ? ir_var_shader_in : ir_var_shader_out; 2644 2645 2646 /* Temporary storage for the set of attributes that need locations assigned. 2647 */ 2648 struct temp_attr { 2649 unsigned slots; 2650 ir_variable *var; 2651 2652 /* Used below in the call to qsort. */ 2653 static int compare(const void *a, const void *b) 2654 { 2655 const temp_attr *const l = (const temp_attr *) a; 2656 const temp_attr *const r = (const temp_attr *) b; 2657 2658 /* Reversed because we want a descending order sort below. */ 2659 return r->slots - l->slots; 2660 } 2661 } to_assign[32]; 2662 assert(max_index <= 32); 2663 2664 /* Temporary array for the set of attributes that have locations assigned, 2665 * for the purpose of checking overlapping slots/components of (non-ES) 2666 * fragment shader outputs. 2667 */ 2668 ir_variable *assigned[12 * 4]; /* (max # of FS outputs) * # components */ 2669 unsigned assigned_attr = 0; 2670 2671 unsigned num_attr = 0; 2672 2673 foreach_in_list(ir_instruction, node, sh->ir) { 2674 ir_variable *const var = node->as_variable(); 2675 2676 if ((var == NULL) || (var->data.mode != (unsigned) direction)) 2677 continue; 2678 2679 if (var->data.explicit_location) { 2680 var->data.is_unmatched_generic_inout = 0; 2681 if ((var->data.location >= (int)(max_index + generic_base)) 2682 || (var->data.location < 0)) { 2683 linker_error(prog, 2684 "invalid explicit location %d specified for `%s'\n", 2685 (var->data.location < 0) 2686 ? var->data.location 2687 : var->data.location - generic_base, 2688 var->name); 2689 return false; 2690 } 2691 } else if (target_index == MESA_SHADER_VERTEX) { 2692 unsigned binding; 2693 2694 if (prog->AttributeBindings->get(binding, var->name)) { 2695 assert(binding >= VERT_ATTRIB_GENERIC0); 2696 var->data.location = binding; 2697 var->data.is_unmatched_generic_inout = 0; 2698 } 2699 } else if (target_index == MESA_SHADER_FRAGMENT) { 2700 unsigned binding; 2701 unsigned index; 2702 const char *name = var->name; 2703 const glsl_type *type = var->type; 2704 2705 while (type) { 2706 /* Check if there's a binding for the variable name */ 2707 if (prog->FragDataBindings->get(binding, name)) { 2708 assert(binding >= FRAG_RESULT_DATA0); 2709 var->data.location = binding; 2710 var->data.is_unmatched_generic_inout = 0; 2711 2712 if (prog->FragDataIndexBindings->get(index, name)) { 2713 var->data.index = index; 2714 } 2715 break; 2716 } 2717 2718 /* If not, but it's an array type, look for name[0] */ 2719 if (type->is_array()) { 2720 name = ralloc_asprintf(mem_ctx, "%s[0]", name); 2721 type = type->fields.array; 2722 continue; 2723 } 2724 2725 break; 2726 } 2727 } 2728 2729 if (strcmp(var->name, "gl_LastFragData") == 0) 2730 continue; 2731 2732 /* From GL4.5 core spec, section 15.2 (Shader Execution): 2733 * 2734 * "Output binding assignments will cause LinkProgram to fail: 2735 * ... 2736 * If the program has an active output assigned to a location greater 2737 * than or equal to the value of MAX_DUAL_SOURCE_DRAW_BUFFERS and has 2738 * an active output assigned an index greater than or equal to one;" 2739 */ 2740 if (target_index == MESA_SHADER_FRAGMENT && var->data.index >= 1 && 2741 var->data.location - generic_base >= 2742 (int) constants->MaxDualSourceDrawBuffers) { 2743 linker_error(prog, 2744 "output location %d >= GL_MAX_DUAL_SOURCE_DRAW_BUFFERS " 2745 "with index %u for %s\n", 2746 var->data.location - generic_base, var->data.index, 2747 var->name); 2748 return false; 2749 } 2750 2751 const unsigned slots = var->type->count_attribute_slots(target_index == MESA_SHADER_VERTEX); 2752 2753 /* If the variable is not a built-in and has a location statically 2754 * assigned in the shader (presumably via a layout qualifier), make sure 2755 * that it doesn't collide with other assigned locations. Otherwise, 2756 * add it to the list of variables that need linker-assigned locations. 2757 */ 2758 if (var->data.location != -1) { 2759 if (var->data.location >= generic_base && var->data.index < 1) { 2760 /* From page 61 of the OpenGL 4.0 spec: 2761 * 2762 * "LinkProgram will fail if the attribute bindings assigned 2763 * by BindAttribLocation do not leave not enough space to 2764 * assign a location for an active matrix attribute or an 2765 * active attribute array, both of which require multiple 2766 * contiguous generic attributes." 2767 * 2768 * I think above text prohibits the aliasing of explicit and 2769 * automatic assignments. But, aliasing is allowed in manual 2770 * assignments of attribute locations. See below comments for 2771 * the details. 2772 * 2773 * From OpenGL 4.0 spec, page 61: 2774 * 2775 * "It is possible for an application to bind more than one 2776 * attribute name to the same location. This is referred to as 2777 * aliasing. This will only work if only one of the aliased 2778 * attributes is active in the executable program, or if no 2779 * path through the shader consumes more than one attribute of 2780 * a set of attributes aliased to the same location. A link 2781 * error can occur if the linker determines that every path 2782 * through the shader consumes multiple aliased attributes, 2783 * but implementations are not required to generate an error 2784 * in this case." 2785 * 2786 * From GLSL 4.30 spec, page 54: 2787 * 2788 * "A program will fail to link if any two non-vertex shader 2789 * input variables are assigned to the same location. For 2790 * vertex shaders, multiple input variables may be assigned 2791 * to the same location using either layout qualifiers or via 2792 * the OpenGL API. However, such aliasing is intended only to 2793 * support vertex shaders where each execution path accesses 2794 * at most one input per each location. Implementations are 2795 * permitted, but not required, to generate link-time errors 2796 * if they detect that every path through the vertex shader 2797 * executable accesses multiple inputs assigned to any single 2798 * location. For all shader types, a program will fail to link 2799 * if explicit location assignments leave the linker unable 2800 * to find space for other variables without explicit 2801 * assignments." 2802 * 2803 * From OpenGL ES 3.0 spec, page 56: 2804 * 2805 * "Binding more than one attribute name to the same location 2806 * is referred to as aliasing, and is not permitted in OpenGL 2807 * ES Shading Language 3.00 vertex shaders. LinkProgram will 2808 * fail when this condition exists. However, aliasing is 2809 * possible in OpenGL ES Shading Language 1.00 vertex shaders. 2810 * This will only work if only one of the aliased attributes 2811 * is active in the executable program, or if no path through 2812 * the shader consumes more than one attribute of a set of 2813 * attributes aliased to the same location. A link error can 2814 * occur if the linker determines that every path through the 2815 * shader consumes multiple aliased attributes, but implemen- 2816 * tations are not required to generate an error in this case." 2817 * 2818 * After looking at above references from OpenGL, OpenGL ES and 2819 * GLSL specifications, we allow aliasing of vertex input variables 2820 * in: OpenGL 2.0 (and above) and OpenGL ES 2.0. 2821 * 2822 * NOTE: This is not required by the spec but its worth mentioning 2823 * here that we're not doing anything to make sure that no path 2824 * through the vertex shader executable accesses multiple inputs 2825 * assigned to any single location. 2826 */ 2827 2828 /* Mask representing the contiguous slots that will be used by 2829 * this attribute. 2830 */ 2831 const unsigned attr = var->data.location - generic_base; 2832 const unsigned use_mask = (1 << slots) - 1; 2833 const char *const string = (target_index == MESA_SHADER_VERTEX) 2834 ? "vertex shader input" : "fragment shader output"; 2835 2836 /* Generate a link error if the requested locations for this 2837 * attribute exceed the maximum allowed attribute location. 2838 */ 2839 if (attr + slots > max_index) { 2840 linker_error(prog, 2841 "insufficient contiguous locations " 2842 "available for %s `%s' %d %d %d\n", string, 2843 var->name, used_locations, use_mask, attr); 2844 return false; 2845 } 2846 2847 /* Generate a link error if the set of bits requested for this 2848 * attribute overlaps any previously allocated bits. 2849 */ 2850 if ((~(use_mask << attr) & used_locations) != used_locations) { 2851 if (target_index == MESA_SHADER_FRAGMENT && !prog->IsES) { 2852 /* From section 4.4.2 (Output Layout Qualifiers) of the GLSL 2853 * 4.40 spec: 2854 * 2855 * "Additionally, for fragment shader outputs, if two 2856 * variables are placed within the same location, they 2857 * must have the same underlying type (floating-point or 2858 * integer). No component aliasing of output variables or 2859 * members is allowed. 2860 */ 2861 for (unsigned i = 0; i < assigned_attr; i++) { 2862 unsigned assigned_slots = 2863 assigned[i]->type->count_attribute_slots(false); 2864 unsigned assig_attr = 2865 assigned[i]->data.location - generic_base; 2866 unsigned assigned_use_mask = (1 << assigned_slots) - 1; 2867 2868 if ((assigned_use_mask << assig_attr) & 2869 (use_mask << attr)) { 2870 2871 const glsl_type *assigned_type = 2872 assigned[i]->type->without_array(); 2873 const glsl_type *type = var->type->without_array(); 2874 if (assigned_type->base_type != type->base_type) { 2875 linker_error(prog, "types do not match for aliased" 2876 " %ss %s and %s\n", string, 2877 assigned[i]->name, var->name); 2878 return false; 2879 } 2880 2881 unsigned assigned_component_mask = 2882 ((1 << assigned_type->vector_elements) - 1) << 2883 assigned[i]->data.location_frac; 2884 unsigned component_mask = 2885 ((1 << type->vector_elements) - 1) << 2886 var->data.location_frac; 2887 if (assigned_component_mask & component_mask) { 2888 linker_error(prog, "overlapping component is " 2889 "assigned to %ss %s and %s " 2890 "(component=%d)\n", 2891 string, assigned[i]->name, var->name, 2892 var->data.location_frac); 2893 return false; 2894 } 2895 } 2896 } 2897 } else if (target_index == MESA_SHADER_FRAGMENT || 2898 (prog->IsES && prog->data->Version >= 300)) { 2899 linker_error(prog, "overlapping location is assigned " 2900 "to %s `%s' %d %d %d\n", string, var->name, 2901 used_locations, use_mask, attr); 2902 return false; 2903 } else { 2904 linker_warning(prog, "overlapping location is assigned " 2905 "to %s `%s' %d %d %d\n", string, var->name, 2906 used_locations, use_mask, attr); 2907 } 2908 } 2909 2910 if (target_index == MESA_SHADER_FRAGMENT && !prog->IsES) { 2911 /* Only track assigned variables for non-ES fragment shaders 2912 * to avoid overflowing the array. 2913 * 2914 * At most one variable per fragment output component should 2915 * reach this. 2916 */ 2917 assert(assigned_attr < ARRAY_SIZE(assigned)); 2918 assigned[assigned_attr] = var; 2919 assigned_attr++; 2920 } 2921 2922 used_locations |= (use_mask << attr); 2923 2924 /* From the GL 4.5 core spec, section 11.1.1 (Vertex Attributes): 2925 * 2926 * "A program with more than the value of MAX_VERTEX_ATTRIBS 2927 * active attribute variables may fail to link, unless 2928 * device-dependent optimizations are able to make the program 2929 * fit within available hardware resources. For the purposes 2930 * of this test, attribute variables of the type dvec3, dvec4, 2931 * dmat2x3, dmat2x4, dmat3, dmat3x4, dmat4x3, and dmat4 may 2932 * count as consuming twice as many attributes as equivalent 2933 * single-precision types. While these types use the same number 2934 * of generic attributes as their single-precision equivalents, 2935 * implementations are permitted to consume two single-precision 2936 * vectors of internal storage for each three- or four-component 2937 * double-precision vector." 2938 * 2939 * Mark this attribute slot as taking up twice as much space 2940 * so we can count it properly against limits. According to 2941 * issue (3) of the GL_ARB_vertex_attrib_64bit behavior, this 2942 * is optional behavior, but it seems preferable. 2943 */ 2944 if (var->type->without_array()->is_dual_slot()) 2945 double_storage_locations |= (use_mask << attr); 2946 } 2947 2948 continue; 2949 } 2950 2951 if (num_attr >= max_index) { 2952 linker_error(prog, "too many %s (max %u)", 2953 target_index == MESA_SHADER_VERTEX ? 2954 "vertex shader inputs" : "fragment shader outputs", 2955 max_index); 2956 return false; 2957 } 2958 to_assign[num_attr].slots = slots; 2959 to_assign[num_attr].var = var; 2960 num_attr++; 2961 } 2962 2963 if (target_index == MESA_SHADER_VERTEX) { 2964 unsigned total_attribs_size = 2965 _mesa_bitcount(used_locations & SAFE_MASK_FROM_INDEX(max_index)) + 2966 _mesa_bitcount(double_storage_locations); 2967 if (total_attribs_size > max_index) { 2968 linker_error(prog, 2969 "attempt to use %d vertex attribute slots only %d available ", 2970 total_attribs_size, max_index); 2971 return false; 2972 } 2973 } 2974 2975 /* If all of the attributes were assigned locations by the application (or 2976 * are built-in attributes with fixed locations), return early. This should 2977 * be the common case. 2978 */ 2979 if (num_attr == 0) 2980 return true; 2981 2982 qsort(to_assign, num_attr, sizeof(to_assign[0]), temp_attr::compare); 2983 2984 if (target_index == MESA_SHADER_VERTEX) { 2985 /* VERT_ATTRIB_GENERIC0 is a pseudo-alias for VERT_ATTRIB_POS. It can 2986 * only be explicitly assigned by via glBindAttribLocation. Mark it as 2987 * reserved to prevent it from being automatically allocated below. 2988 */ 2989 find_deref_visitor find("gl_Vertex"); 2990 find.run(sh->ir); 2991 if (find.variable_found()) 2992 used_locations |= (1 << 0); 2993 } 2994 2995 for (unsigned i = 0; i < num_attr; i++) { 2996 /* Mask representing the contiguous slots that will be used by this 2997 * attribute. 2998 */ 2999 const unsigned use_mask = (1 << to_assign[i].slots) - 1; 3000 3001 int location = find_available_slots(used_locations, to_assign[i].slots); 3002 3003 if (location < 0) { 3004 const char *const string = (target_index == MESA_SHADER_VERTEX) 3005 ? "vertex shader input" : "fragment shader output"; 3006 3007 linker_error(prog, 3008 "insufficient contiguous locations " 3009 "available for %s `%s'\n", 3010 string, to_assign[i].var->name); 3011 return false; 3012 } 3013 3014 to_assign[i].var->data.location = generic_base + location; 3015 to_assign[i].var->data.is_unmatched_generic_inout = 0; 3016 used_locations |= (use_mask << location); 3017 3018 if (to_assign[i].var->type->without_array()->is_dual_slot()) 3019 double_storage_locations |= (use_mask << location); 3020 } 3021 3022 /* Now that we have all the locations, from the GL 4.5 core spec, section 3023 * 11.1.1 (Vertex Attributes), dvec3, dvec4, dmat2x3, dmat2x4, dmat3, 3024 * dmat3x4, dmat4x3, and dmat4 count as consuming twice as many attributes 3025 * as equivalent single-precision types. 3026 */ 3027 if (target_index == MESA_SHADER_VERTEX) { 3028 unsigned total_attribs_size = 3029 _mesa_bitcount(used_locations & SAFE_MASK_FROM_INDEX(max_index)) + 3030 _mesa_bitcount(double_storage_locations); 3031 if (total_attribs_size > max_index) { 3032 linker_error(prog, 3033 "attempt to use %d vertex attribute slots only %d available ", 3034 total_attribs_size, max_index); 3035 return false; 3036 } 3037 } 3038 3039 return true; 3040 } 3041 3042 /** 3043 * Match explicit locations of outputs to inputs and deactivate the 3044 * unmatch flag if found so we don't optimise them away. 3045 */ 3046 static void 3047 match_explicit_outputs_to_inputs(gl_linked_shader *producer, 3048 gl_linked_shader *consumer) 3049 { 3050 glsl_symbol_table parameters; 3051 ir_variable *explicit_locations[MAX_VARYINGS_INCL_PATCH][4] = 3052 { {NULL, NULL} }; 3053 3054 /* Find all shader outputs in the "producer" stage. 3055 */ 3056 foreach_in_list(ir_instruction, node, producer->ir) { 3057 ir_variable *const var = node->as_variable(); 3058 3059 if ((var == NULL) || (var->data.mode != ir_var_shader_out)) 3060 continue; 3061 3062 if (var->data.explicit_location && 3063 var->data.location >= VARYING_SLOT_VAR0) { 3064 const unsigned idx = var->data.location - VARYING_SLOT_VAR0; 3065 if (explicit_locations[idx][var->data.location_frac] == NULL) 3066 explicit_locations[idx][var->data.location_frac] = var; 3067 } 3068 } 3069 3070 /* Match inputs to outputs */ 3071 foreach_in_list(ir_instruction, node, consumer->ir) { 3072 ir_variable *const input = node->as_variable(); 3073 3074 if ((input == NULL) || (input->data.mode != ir_var_shader_in)) 3075 continue; 3076 3077 ir_variable *output = NULL; 3078 if (input->data.explicit_location 3079 && input->data.location >= VARYING_SLOT_VAR0) { 3080 output = explicit_locations[input->data.location - VARYING_SLOT_VAR0] 3081 [input->data.location_frac]; 3082 3083 if (output != NULL){ 3084 input->data.is_unmatched_generic_inout = 0; 3085 output->data.is_unmatched_generic_inout = 0; 3086 } 3087 } 3088 } 3089 } 3090 3091 /** 3092 * Store the gl_FragDepth layout in the gl_shader_program struct. 3093 */ 3094 static void 3095 store_fragdepth_layout(struct gl_shader_program *prog) 3096 { 3097 if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL) { 3098 return; 3099 } 3100 3101 struct exec_list *ir = prog->_LinkedShaders[MESA_SHADER_FRAGMENT]->ir; 3102 3103 /* We don't look up the gl_FragDepth symbol directly because if 3104 * gl_FragDepth is not used in the shader, it's removed from the IR. 3105 * However, the symbol won't be removed from the symbol table. 3106 * 3107 * We're only interested in the cases where the variable is NOT removed 3108 * from the IR. 3109 */ 3110 foreach_in_list(ir_instruction, node, ir) { 3111 ir_variable *const var = node->as_variable(); 3112 3113 if (var == NULL || var->data.mode != ir_var_shader_out) { 3114 continue; 3115 } 3116 3117 if (strcmp(var->name, "gl_FragDepth") == 0) { 3118 switch (var->data.depth_layout) { 3119 case ir_depth_layout_none: 3120 prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_NONE; 3121 return; 3122 case ir_depth_layout_any: 3123 prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_ANY; 3124 return; 3125 case ir_depth_layout_greater: 3126 prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_GREATER; 3127 return; 3128 case ir_depth_layout_less: 3129 prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_LESS; 3130 return; 3131 case ir_depth_layout_unchanged: 3132 prog->FragDepthLayout = FRAG_DEPTH_LAYOUT_UNCHANGED; 3133 return; 3134 default: 3135 assert(0); 3136 return; 3137 } 3138 } 3139 } 3140 } 3141 3142 /** 3143 * Validate the resources used by a program versus the implementation limits 3144 */ 3145 static void 3146 check_resources(struct gl_context *ctx, struct gl_shader_program *prog) 3147 { 3148 unsigned total_uniform_blocks = 0; 3149 unsigned total_shader_storage_blocks = 0; 3150 3151 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 3152 struct gl_linked_shader *sh = prog->_LinkedShaders[i]; 3153 3154 if (sh == NULL) 3155 continue; 3156 3157 if (sh->Program->info.num_textures > 3158 ctx->Const.Program[i].MaxTextureImageUnits) { 3159 linker_error(prog, "Too many %s shader texture samplers\n", 3160 _mesa_shader_stage_to_string(i)); 3161 } 3162 3163 if (sh->num_uniform_components > 3164 ctx->Const.Program[i].MaxUniformComponents) { 3165 if (ctx->Const.GLSLSkipStrictMaxUniformLimitCheck) { 3166 linker_warning(prog, "Too many %s shader default uniform block " 3167 "components, but the driver will try to optimize " 3168 "them out; this is non-portable out-of-spec " 3169 "behavior\n", 3170 _mesa_shader_stage_to_string(i)); 3171 } else { 3172 linker_error(prog, "Too many %s shader default uniform block " 3173 "components\n", 3174 _mesa_shader_stage_to_string(i)); 3175 } 3176 } 3177 3178 if (sh->num_combined_uniform_components > 3179 ctx->Const.Program[i].MaxCombinedUniformComponents) { 3180 if (ctx->Const.GLSLSkipStrictMaxUniformLimitCheck) { 3181 linker_warning(prog, "Too many %s shader uniform components, " 3182 "but the driver will try to optimize them out; " 3183 "this is non-portable out-of-spec behavior\n", 3184 _mesa_shader_stage_to_string(i)); 3185 } else { 3186 linker_error(prog, "Too many %s shader uniform components\n", 3187 _mesa_shader_stage_to_string(i)); 3188 } 3189 } 3190 3191 total_shader_storage_blocks += sh->Program->info.num_ssbos; 3192 total_uniform_blocks += sh->Program->info.num_ubos; 3193 3194 const unsigned max_uniform_blocks = 3195 ctx->Const.Program[i].MaxUniformBlocks; 3196 if (max_uniform_blocks < sh->Program->info.num_ubos) { 3197 linker_error(prog, "Too many %s uniform blocks (%d/%d)\n", 3198 _mesa_shader_stage_to_string(i), 3199 sh->Program->info.num_ubos, max_uniform_blocks); 3200 } 3201 3202 const unsigned max_shader_storage_blocks = 3203 ctx->Const.Program[i].MaxShaderStorageBlocks; 3204 if (max_shader_storage_blocks < sh->Program->info.num_ssbos) { 3205 linker_error(prog, "Too many %s shader storage blocks (%d/%d)\n", 3206 _mesa_shader_stage_to_string(i), 3207 sh->Program->info.num_ssbos, max_shader_storage_blocks); 3208 } 3209 } 3210 3211 if (total_uniform_blocks > ctx->Const.MaxCombinedUniformBlocks) { 3212 linker_error(prog, "Too many combined uniform blocks (%d/%d)\n", 3213 total_uniform_blocks, ctx->Const.MaxCombinedUniformBlocks); 3214 } 3215 3216 if (total_shader_storage_blocks > ctx->Const.MaxCombinedShaderStorageBlocks) { 3217 linker_error(prog, "Too many combined shader storage blocks (%d/%d)\n", 3218 total_shader_storage_blocks, 3219 ctx->Const.MaxCombinedShaderStorageBlocks); 3220 } 3221 3222 for (unsigned i = 0; i < prog->data->NumUniformBlocks; i++) { 3223 if (prog->data->UniformBlocks[i].UniformBufferSize > 3224 ctx->Const.MaxUniformBlockSize) { 3225 linker_error(prog, "Uniform block %s too big (%d/%d)\n", 3226 prog->data->UniformBlocks[i].Name, 3227 prog->data->UniformBlocks[i].UniformBufferSize, 3228 ctx->Const.MaxUniformBlockSize); 3229 } 3230 } 3231 3232 for (unsigned i = 0; i < prog->data->NumShaderStorageBlocks; i++) { 3233 if (prog->data->ShaderStorageBlocks[i].UniformBufferSize > 3234 ctx->Const.MaxShaderStorageBlockSize) { 3235 linker_error(prog, "Shader storage block %s too big (%d/%d)\n", 3236 prog->data->ShaderStorageBlocks[i].Name, 3237 prog->data->ShaderStorageBlocks[i].UniformBufferSize, 3238 ctx->Const.MaxShaderStorageBlockSize); 3239 } 3240 } 3241 } 3242 3243 static void 3244 link_calculate_subroutine_compat(struct gl_shader_program *prog) 3245 { 3246 unsigned mask = prog->data->linked_stages; 3247 while (mask) { 3248 const int i = u_bit_scan(&mask); 3249 struct gl_program *p = prog->_LinkedShaders[i]->Program; 3250 3251 for (unsigned j = 0; j < p->sh.NumSubroutineUniformRemapTable; j++) { 3252 if (p->sh.SubroutineUniformRemapTable[j] == INACTIVE_UNIFORM_EXPLICIT_LOCATION) 3253 continue; 3254 3255 struct gl_uniform_storage *uni = p->sh.SubroutineUniformRemapTable[j]; 3256 3257 if (!uni) 3258 continue; 3259 3260 int count = 0; 3261 if (p->sh.NumSubroutineFunctions == 0) { 3262 linker_error(prog, "subroutine uniform %s defined but no valid functions found\n", uni->type->name); 3263 continue; 3264 } 3265 for (unsigned f = 0; f < p->sh.NumSubroutineFunctions; f++) { 3266 struct gl_subroutine_function *fn = &p->sh.SubroutineFunctions[f]; 3267 for (int k = 0; k < fn->num_compat_types; k++) { 3268 if (fn->types[k] == uni->type) { 3269 count++; 3270 break; 3271 } 3272 } 3273 } 3274 uni->num_compatible_subroutines = count; 3275 } 3276 } 3277 } 3278 3279 static void 3280 check_subroutine_resources(struct gl_shader_program *prog) 3281 { 3282 unsigned mask = prog->data->linked_stages; 3283 while (mask) { 3284 const int i = u_bit_scan(&mask); 3285 struct gl_program *p = prog->_LinkedShaders[i]->Program; 3286 3287 if (p->sh.NumSubroutineUniformRemapTable > MAX_SUBROUTINE_UNIFORM_LOCATIONS) { 3288 linker_error(prog, "Too many %s shader subroutine uniforms\n", 3289 _mesa_shader_stage_to_string(i)); 3290 } 3291 } 3292 } 3293 /** 3294 * Validate shader image resources. 3295 */ 3296 static void 3297 check_image_resources(struct gl_context *ctx, struct gl_shader_program *prog) 3298 { 3299 unsigned total_image_units = 0; 3300 unsigned fragment_outputs = 0; 3301 unsigned total_shader_storage_blocks = 0; 3302 3303 if (!ctx->Extensions.ARB_shader_image_load_store) 3304 return; 3305 3306 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 3307 struct gl_linked_shader *sh = prog->_LinkedShaders[i]; 3308 3309 if (sh) { 3310 if (sh->Program->info.num_images > ctx->Const.Program[i].MaxImageUniforms) 3311 linker_error(prog, "Too many %s shader image uniforms (%u > %u)\n", 3312 _mesa_shader_stage_to_string(i), 3313 sh->Program->info.num_images, 3314 ctx->Const.Program[i].MaxImageUniforms); 3315 3316 total_image_units += sh->Program->info.num_images; 3317 total_shader_storage_blocks += sh->Program->info.num_ssbos; 3318 3319 if (i == MESA_SHADER_FRAGMENT) { 3320 foreach_in_list(ir_instruction, node, sh->ir) { 3321 ir_variable *var = node->as_variable(); 3322 if (var && var->data.mode == ir_var_shader_out) 3323 /* since there are no double fs outputs - pass false */ 3324 fragment_outputs += var->type->count_attribute_slots(false); 3325 } 3326 } 3327 } 3328 } 3329 3330 if (total_image_units > ctx->Const.MaxCombinedImageUniforms) 3331 linker_error(prog, "Too many combined image uniforms\n"); 3332 3333 if (total_image_units + fragment_outputs + total_shader_storage_blocks > 3334 ctx->Const.MaxCombinedShaderOutputResources) 3335 linker_error(prog, "Too many combined image uniforms, shader storage " 3336 " buffers and fragment outputs\n"); 3337 } 3338 3339 3340 /** 3341 * Initializes explicit location slots to INACTIVE_UNIFORM_EXPLICIT_LOCATION 3342 * for a variable, checks for overlaps between other uniforms using explicit 3343 * locations. 3344 */ 3345 static int 3346 reserve_explicit_locations(struct gl_shader_program *prog, 3347 string_to_uint_map *map, ir_variable *var) 3348 { 3349 unsigned slots = var->type->uniform_locations(); 3350 unsigned max_loc = var->data.location + slots - 1; 3351 unsigned return_value = slots; 3352 3353 /* Resize remap table if locations do not fit in the current one. */ 3354 if (max_loc + 1 > prog->NumUniformRemapTable) { 3355 prog->UniformRemapTable = 3356 reralloc(prog, prog->UniformRemapTable, 3357 gl_uniform_storage *, 3358 max_loc + 1); 3359 3360 if (!prog->UniformRemapTable) { 3361 linker_error(prog, "Out of memory during linking.\n"); 3362 return -1; 3363 } 3364 3365 /* Initialize allocated space. */ 3366 for (unsigned i = prog->NumUniformRemapTable; i < max_loc + 1; i++) 3367 prog->UniformRemapTable[i] = NULL; 3368 3369 prog->NumUniformRemapTable = max_loc + 1; 3370 } 3371 3372 for (unsigned i = 0; i < slots; i++) { 3373 unsigned loc = var->data.location + i; 3374 3375 /* Check if location is already used. */ 3376 if (prog->UniformRemapTable[loc] == INACTIVE_UNIFORM_EXPLICIT_LOCATION) { 3377 3378 /* Possibly same uniform from a different stage, this is ok. */ 3379 unsigned hash_loc; 3380 if (map->get(hash_loc, var->name) && hash_loc == loc - i) { 3381 return_value = 0; 3382 continue; 3383 } 3384 3385 /* ARB_explicit_uniform_location specification states: 3386 * 3387 * "No two default-block uniform variables in the program can have 3388 * the same location, even if they are unused, otherwise a compiler 3389 * or linker error will be generated." 3390 */ 3391 linker_error(prog, 3392 "location qualifier for uniform %s overlaps " 3393 "previously used location\n", 3394 var->name); 3395 return -1; 3396 } 3397 3398 /* Initialize location as inactive before optimization 3399 * rounds and location assignment. 3400 */ 3401 prog->UniformRemapTable[loc] = INACTIVE_UNIFORM_EXPLICIT_LOCATION; 3402 } 3403 3404 /* Note, base location used for arrays. */ 3405 map->put(var->data.location, var->name); 3406 3407 return return_value; 3408 } 3409 3410 static bool 3411 reserve_subroutine_explicit_locations(struct gl_shader_program *prog, 3412 struct gl_program *p, 3413 ir_variable *var) 3414 { 3415 unsigned slots = var->type->uniform_locations(); 3416 unsigned max_loc = var->data.location + slots - 1; 3417 3418 /* Resize remap table if locations do not fit in the current one. */ 3419 if (max_loc + 1 > p->sh.NumSubroutineUniformRemapTable) { 3420 p->sh.SubroutineUniformRemapTable = 3421 reralloc(p, p->sh.SubroutineUniformRemapTable, 3422 gl_uniform_storage *, 3423 max_loc + 1); 3424 3425 if (!p->sh.SubroutineUniformRemapTable) { 3426 linker_error(prog, "Out of memory during linking.\n"); 3427 return false; 3428 } 3429 3430 /* Initialize allocated space. */ 3431 for (unsigned i = p->sh.NumSubroutineUniformRemapTable; i < max_loc + 1; i++) 3432 p->sh.SubroutineUniformRemapTable[i] = NULL; 3433 3434 p->sh.NumSubroutineUniformRemapTable = max_loc + 1; 3435 } 3436 3437 for (unsigned i = 0; i < slots; i++) { 3438 unsigned loc = var->data.location + i; 3439 3440 /* Check if location is already used. */ 3441 if (p->sh.SubroutineUniformRemapTable[loc] == INACTIVE_UNIFORM_EXPLICIT_LOCATION) { 3442 3443 /* ARB_explicit_uniform_location specification states: 3444 * "No two subroutine uniform variables can have the same location 3445 * in the same shader stage, otherwise a compiler or linker error 3446 * will be generated." 3447 */ 3448 linker_error(prog, 3449 "location qualifier for uniform %s overlaps " 3450 "previously used location\n", 3451 var->name); 3452 return false; 3453 } 3454 3455 /* Initialize location as inactive before optimization 3456 * rounds and location assignment. 3457 */ 3458 p->sh.SubroutineUniformRemapTable[loc] = INACTIVE_UNIFORM_EXPLICIT_LOCATION; 3459 } 3460 3461 return true; 3462 } 3463 /** 3464 * Check and reserve all explicit uniform locations, called before 3465 * any optimizations happen to handle also inactive uniforms and 3466 * inactive array elements that may get trimmed away. 3467 */ 3468 static void 3469 check_explicit_uniform_locations(struct gl_context *ctx, 3470 struct gl_shader_program *prog) 3471 { 3472 prog->NumExplicitUniformLocations = 0; 3473 3474 if (!ctx->Extensions.ARB_explicit_uniform_location) 3475 return; 3476 3477 /* This map is used to detect if overlapping explicit locations 3478 * occur with the same uniform (from different stage) or a different one. 3479 */ 3480 string_to_uint_map *uniform_map = new string_to_uint_map; 3481 3482 if (!uniform_map) { 3483 linker_error(prog, "Out of memory during linking.\n"); 3484 return; 3485 } 3486 3487 unsigned entries_total = 0; 3488 unsigned mask = prog->data->linked_stages; 3489 while (mask) { 3490 const int i = u_bit_scan(&mask); 3491 struct gl_program *p = prog->_LinkedShaders[i]->Program; 3492 3493 foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) { 3494 ir_variable *var = node->as_variable(); 3495 if (!var || var->data.mode != ir_var_uniform) 3496 continue; 3497 3498 if (var->data.explicit_location) { 3499 bool ret = false; 3500 if (var->type->without_array()->is_subroutine()) 3501 ret = reserve_subroutine_explicit_locations(prog, p, var); 3502 else { 3503 int slots = reserve_explicit_locations(prog, uniform_map, 3504 var); 3505 if (slots != -1) { 3506 ret = true; 3507 entries_total += slots; 3508 } 3509 } 3510 if (!ret) { 3511 delete uniform_map; 3512 return; 3513 } 3514 } 3515 } 3516 } 3517 3518 struct empty_uniform_block *current_block = NULL; 3519 3520 for (unsigned i = 0; i < prog->NumUniformRemapTable; i++) { 3521 /* We found empty space in UniformRemapTable. */ 3522 if (prog->UniformRemapTable[i] == NULL) { 3523 /* We've found the beginning of a new continous block of empty slots */ 3524 if (!current_block || current_block->start + current_block->slots != i) { 3525 current_block = rzalloc(prog, struct empty_uniform_block); 3526 current_block->start = i; 3527 exec_list_push_tail(&prog->EmptyUniformLocations, 3528 ¤t_block->link); 3529 } 3530 3531 /* The current block continues, so we simply increment its slots */ 3532 current_block->slots++; 3533 } 3534 } 3535 3536 delete uniform_map; 3537 prog->NumExplicitUniformLocations = entries_total; 3538 } 3539 3540 static bool 3541 should_add_buffer_variable(struct gl_shader_program *shProg, 3542 GLenum type, const char *name) 3543 { 3544 bool found_interface = false; 3545 unsigned block_name_len = 0; 3546 const char *block_name_dot = strchr(name, '.'); 3547 3548 /* These rules only apply to buffer variables. So we return 3549 * true for the rest of types. 3550 */ 3551 if (type != GL_BUFFER_VARIABLE) 3552 return true; 3553 3554 for (unsigned i = 0; i < shProg->data->NumShaderStorageBlocks; i++) { 3555 const char *block_name = shProg->data->ShaderStorageBlocks[i].Name; 3556 block_name_len = strlen(block_name); 3557 3558 const char *block_square_bracket = strchr(block_name, '['); 3559 if (block_square_bracket) { 3560 /* The block is part of an array of named interfaces, 3561 * for the name comparison we ignore the "[x]" part. 3562 */ 3563 block_name_len -= strlen(block_square_bracket); 3564 } 3565 3566 if (block_name_dot) { 3567 /* Check if the variable name starts with the interface 3568 * name. The interface name (if present) should have the 3569 * length than the interface block name we are comparing to. 3570 */ 3571 unsigned len = strlen(name) - strlen(block_name_dot); 3572 if (len != block_name_len) 3573 continue; 3574 } 3575 3576 if (strncmp(block_name, name, block_name_len) == 0) { 3577 found_interface = true; 3578 break; 3579 } 3580 } 3581 3582 /* We remove the interface name from the buffer variable name, 3583 * including the dot that follows it. 3584 */ 3585 if (found_interface) 3586 name = name + block_name_len + 1; 3587 3588 /* The ARB_program_interface_query spec says: 3589 * 3590 * "For an active shader storage block member declared as an array, an 3591 * entry will be generated only for the first array element, regardless 3592 * of its type. For arrays of aggregate types, the enumeration rules 3593 * are applied recursively for the single enumerated array element." 3594 */ 3595 const char *struct_first_dot = strchr(name, '.'); 3596 const char *first_square_bracket = strchr(name, '['); 3597 3598 /* The buffer variable is on top level and it is not an array */ 3599 if (!first_square_bracket) { 3600 return true; 3601 /* The shader storage block member is a struct, then generate the entry */ 3602 } else if (struct_first_dot && struct_first_dot < first_square_bracket) { 3603 return true; 3604 } else { 3605 /* Shader storage block member is an array, only generate an entry for the 3606 * first array element. 3607 */ 3608 if (strncmp(first_square_bracket, "[0]", 3) == 0) 3609 return true; 3610 } 3611 3612 return false; 3613 } 3614 3615 static bool 3616 add_program_resource(struct gl_shader_program *prog, 3617 struct set *resource_set, 3618 GLenum type, const void *data, uint8_t stages) 3619 { 3620 assert(data); 3621 3622 /* If resource already exists, do not add it again. */ 3623 if (_mesa_set_search(resource_set, data)) 3624 return true; 3625 3626 prog->data->ProgramResourceList = 3627 reralloc(prog->data, 3628 prog->data->ProgramResourceList, 3629 gl_program_resource, 3630 prog->data->NumProgramResourceList + 1); 3631 3632 if (!prog->data->ProgramResourceList) { 3633 linker_error(prog, "Out of memory during linking.\n"); 3634 return false; 3635 } 3636 3637 struct gl_program_resource *res = 3638 &prog->data->ProgramResourceList[prog->data->NumProgramResourceList]; 3639 3640 res->Type = type; 3641 res->Data = data; 3642 res->StageReferences = stages; 3643 3644 prog->data->NumProgramResourceList++; 3645 3646 _mesa_set_add(resource_set, data); 3647 3648 return true; 3649 } 3650 3651 /* Function checks if a variable var is a packed varying and 3652 * if given name is part of packed varying's list. 3653 * 3654 * If a variable is a packed varying, it has a name like 3655 * 'packed:a,b,c' where a, b and c are separate variables. 3656 */ 3657 static bool 3658 included_in_packed_varying(ir_variable *var, const char *name) 3659 { 3660 if (strncmp(var->name, "packed:", 7) != 0) 3661 return false; 3662 3663 char *list = strdup(var->name + 7); 3664 assert(list); 3665 3666 bool found = false; 3667 char *saveptr; 3668 char *token = strtok_r(list, ",", &saveptr); 3669 while (token) { 3670 if (strcmp(token, name) == 0) { 3671 found = true; 3672 break; 3673 } 3674 token = strtok_r(NULL, ",", &saveptr); 3675 } 3676 free(list); 3677 return found; 3678 } 3679 3680 /** 3681 * Function builds a stage reference bitmask from variable name. 3682 */ 3683 static uint8_t 3684 build_stageref(struct gl_shader_program *shProg, const char *name, 3685 unsigned mode) 3686 { 3687 uint8_t stages = 0; 3688 3689 /* Note, that we assume MAX 8 stages, if there will be more stages, type 3690 * used for reference mask in gl_program_resource will need to be changed. 3691 */ 3692 assert(MESA_SHADER_STAGES < 8); 3693 3694 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 3695 struct gl_linked_shader *sh = shProg->_LinkedShaders[i]; 3696 if (!sh) 3697 continue; 3698 3699 /* Shader symbol table may contain variables that have 3700 * been optimized away. Search IR for the variable instead. 3701 */ 3702 foreach_in_list(ir_instruction, node, sh->ir) { 3703 ir_variable *var = node->as_variable(); 3704 if (var) { 3705 unsigned baselen = strlen(var->name); 3706 3707 if (included_in_packed_varying(var, name)) { 3708 stages |= (1 << i); 3709 break; 3710 } 3711 3712 /* Type needs to match if specified, otherwise we might 3713 * pick a variable with same name but different interface. 3714 */ 3715 if (var->data.mode != mode) 3716 continue; 3717 3718 if (strncmp(var->name, name, baselen) == 0) { 3719 /* Check for exact name matches but also check for arrays and 3720 * structs. 3721 */ 3722 if (name[baselen] == '\0' || 3723 name[baselen] == '[' || 3724 name[baselen] == '.') { 3725 stages |= (1 << i); 3726 break; 3727 } 3728 } 3729 } 3730 } 3731 } 3732 return stages; 3733 } 3734 3735 /** 3736 * Create gl_shader_variable from ir_variable class. 3737 */ 3738 static gl_shader_variable * 3739 create_shader_variable(struct gl_shader_program *shProg, 3740 const ir_variable *in, 3741 const char *name, const glsl_type *type, 3742 const glsl_type *interface_type, 3743 bool use_implicit_location, int location, 3744 const glsl_type *outermost_struct_type) 3745 { 3746 /* Allocate zero-initialized memory to ensure that bitfield padding 3747 * is zero. 3748 */ 3749 gl_shader_variable *out = rzalloc(shProg, struct gl_shader_variable); 3750 if (!out) 3751 return NULL; 3752 3753 /* Since gl_VertexID may be lowered to gl_VertexIDMESA, but applications 3754 * expect to see gl_VertexID in the program resource list. Pretend. 3755 */ 3756 if (in->data.mode == ir_var_system_value && 3757 in->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) { 3758 out->name = ralloc_strdup(shProg, "gl_VertexID"); 3759 } else if ((in->data.mode == ir_var_shader_out && 3760 in->data.location == VARYING_SLOT_TESS_LEVEL_OUTER) || 3761 (in->data.mode == ir_var_system_value && 3762 in->data.location == SYSTEM_VALUE_TESS_LEVEL_OUTER)) { 3763 out->name = ralloc_strdup(shProg, "gl_TessLevelOuter"); 3764 type = glsl_type::get_array_instance(glsl_type::float_type, 4); 3765 } else if ((in->data.mode == ir_var_shader_out && 3766 in->data.location == VARYING_SLOT_TESS_LEVEL_INNER) || 3767 (in->data.mode == ir_var_system_value && 3768 in->data.location == SYSTEM_VALUE_TESS_LEVEL_INNER)) { 3769 out->name = ralloc_strdup(shProg, "gl_TessLevelInner"); 3770 type = glsl_type::get_array_instance(glsl_type::float_type, 2); 3771 } else { 3772 out->name = ralloc_strdup(shProg, name); 3773 } 3774 3775 if (!out->name) 3776 return NULL; 3777 3778 /* The ARB_program_interface_query spec says: 3779 * 3780 * "Not all active variables are assigned valid locations; the 3781 * following variables will have an effective location of -1: 3782 * 3783 * * uniforms declared as atomic counters; 3784 * 3785 * * members of a uniform block; 3786 * 3787 * * built-in inputs, outputs, and uniforms (starting with "gl_"); and 3788 * 3789 * * inputs or outputs not declared with a "location" layout 3790 * qualifier, except for vertex shader inputs and fragment shader 3791 * outputs." 3792 */ 3793 if (in->type->is_atomic_uint() || is_gl_identifier(in->name) || 3794 !(in->data.explicit_location || use_implicit_location)) { 3795 out->location = -1; 3796 } else { 3797 out->location = location; 3798 } 3799 3800 out->type = type; 3801 out->outermost_struct_type = outermost_struct_type; 3802 out->interface_type = interface_type; 3803 out->component = in->data.location_frac; 3804 out->index = in->data.index; 3805 out->patch = in->data.patch; 3806 out->mode = in->data.mode; 3807 out->interpolation = in->data.interpolation; 3808 out->explicit_location = in->data.explicit_location; 3809 out->precision = in->data.precision; 3810 3811 return out; 3812 } 3813 3814 static bool 3815 add_shader_variable(const struct gl_context *ctx, 3816 struct gl_shader_program *shProg, 3817 struct set *resource_set, 3818 unsigned stage_mask, 3819 GLenum programInterface, ir_variable *var, 3820 const char *name, const glsl_type *type, 3821 bool use_implicit_location, int location, 3822 bool inouts_share_location, 3823 const glsl_type *outermost_struct_type = NULL) 3824 { 3825 const glsl_type *interface_type = var->get_interface_type(); 3826 3827 if (outermost_struct_type == NULL) { 3828 if (var->data.from_named_ifc_block) { 3829 const char *interface_name = interface_type->name; 3830 3831 if (interface_type->is_array()) { 3832 /* Issue #16 of the ARB_program_interface_query spec says: 3833 * 3834 * "* If a variable is a member of an interface block without an 3835 * instance name, it is enumerated using just the variable name. 3836 * 3837 * * If a variable is a member of an interface block with an 3838 * instance name, it is enumerated as "BlockName.Member", where 3839 * "BlockName" is the name of the interface block (not the 3840 * instance name) and "Member" is the name of the variable." 3841 * 3842 * In particular, it indicates that it should be "BlockName", 3843 * not "BlockName[array length]". The conformance suite and 3844 * dEQP both require this behavior. 3845 * 3846 * Here, we unwrap the extra array level added by named interface 3847 * block array lowering so we have the correct variable type. We 3848 * also unwrap the interface type when constructing the name. 3849 * 3850 * We leave interface_type the same so that ES 3.x SSO pipeline 3851 * validation can enforce the rules requiring array length to 3852 * match on interface blocks. 3853 */ 3854 type = type->fields.array; 3855 3856 interface_name = interface_type->fields.array->name; 3857 } 3858 3859 name = ralloc_asprintf(shProg, "%s.%s", interface_name, name); 3860 } 3861 } 3862 3863 switch (type->base_type) { 3864 case GLSL_TYPE_STRUCT: { 3865 /* The ARB_program_interface_query spec says: 3866 * 3867 * "For an active variable declared as a structure, a separate entry 3868 * will be generated for each active structure member. The name of 3869 * each entry is formed by concatenating the name of the structure, 3870 * the "." character, and the name of the structure member. If a 3871 * structure member to enumerate is itself a structure or array, 3872 * these enumeration rules are applied recursively." 3873 */ 3874 if (outermost_struct_type == NULL) 3875 outermost_struct_type = type; 3876 3877 unsigned field_location = location; 3878 for (unsigned i = 0; i < type->length; i++) { 3879 const struct glsl_struct_field *field = &type->fields.structure[i]; 3880 char *field_name = ralloc_asprintf(shProg, "%s.%s", name, field->name); 3881 if (!add_shader_variable(ctx, shProg, resource_set, 3882 stage_mask, programInterface, 3883 var, field_name, field->type, 3884 use_implicit_location, field_location, 3885 false, outermost_struct_type)) 3886 return false; 3887 3888 field_location += field->type->count_attribute_slots(false); 3889 } 3890 return true; 3891 } 3892 3893 case GLSL_TYPE_ARRAY: { 3894 /* The ARB_program_interface_query spec says: 3895 * 3896 * "For an active variable declared as an array of basic types, a 3897 * single entry will be generated, with its name string formed by 3898 * concatenating the name of the array and the string "[0]"." 3899 * 3900 * "For an active variable declared as an array of an aggregate data 3901 * type (structures or arrays), a separate entry will be generated 3902 * for each active array element, unless noted immediately below. 3903 * The name of each entry is formed by concatenating the name of 3904 * the array, the "[" character, an integer identifying the element 3905 * number, and the "]" character. These enumeration rules are 3906 * applied recursively, treating each enumerated array element as a 3907 * separate active variable." 3908 */ 3909 const struct glsl_type *array_type = type->fields.array; 3910 if (array_type->base_type == GLSL_TYPE_STRUCT || 3911 array_type->base_type == GLSL_TYPE_ARRAY) { 3912 unsigned elem_location = location; 3913 unsigned stride = inouts_share_location ? 0 : 3914 array_type->count_attribute_slots(false); 3915 for (unsigned i = 0; i < type->length; i++) { 3916 char *elem = ralloc_asprintf(shProg, "%s[%d]", name, i); 3917 if (!add_shader_variable(ctx, shProg, resource_set, 3918 stage_mask, programInterface, 3919 var, elem, array_type, 3920 use_implicit_location, elem_location, 3921 false, outermost_struct_type)) 3922 return false; 3923 elem_location += stride; 3924 } 3925 return true; 3926 } 3927 /* fallthrough */ 3928 } 3929 3930 default: { 3931 /* The ARB_program_interface_query spec says: 3932 * 3933 * "For an active variable declared as a single instance of a basic 3934 * type, a single entry will be generated, using the variable name 3935 * from the shader source." 3936 */ 3937 gl_shader_variable *sha_v = 3938 create_shader_variable(shProg, var, name, type, interface_type, 3939 use_implicit_location, location, 3940 outermost_struct_type); 3941 if (!sha_v) 3942 return false; 3943 3944 return add_program_resource(shProg, resource_set, 3945 programInterface, sha_v, stage_mask); 3946 } 3947 } 3948 } 3949 3950 static bool 3951 inout_has_same_location(const ir_variable *var, unsigned stage) 3952 { 3953 if (!var->data.patch && 3954 ((var->data.mode == ir_var_shader_out && 3955 stage == MESA_SHADER_TESS_CTRL) || 3956 (var->data.mode == ir_var_shader_in && 3957 (stage == MESA_SHADER_TESS_CTRL || stage == MESA_SHADER_TESS_EVAL || 3958 stage == MESA_SHADER_GEOMETRY)))) 3959 return true; 3960 else 3961 return false; 3962 } 3963 3964 static bool 3965 add_interface_variables(const struct gl_context *ctx, 3966 struct gl_shader_program *shProg, 3967 struct set *resource_set, 3968 unsigned stage, GLenum programInterface) 3969 { 3970 exec_list *ir = shProg->_LinkedShaders[stage]->ir; 3971 3972 foreach_in_list(ir_instruction, node, ir) { 3973 ir_variable *var = node->as_variable(); 3974 3975 if (!var || var->data.how_declared == ir_var_hidden) 3976 continue; 3977 3978 int loc_bias; 3979 3980 switch (var->data.mode) { 3981 case ir_var_system_value: 3982 case ir_var_shader_in: 3983 if (programInterface != GL_PROGRAM_INPUT) 3984 continue; 3985 loc_bias = (stage == MESA_SHADER_VERTEX) ? int(VERT_ATTRIB_GENERIC0) 3986 : int(VARYING_SLOT_VAR0); 3987 break; 3988 case ir_var_shader_out: 3989 if (programInterface != GL_PROGRAM_OUTPUT) 3990 continue; 3991 loc_bias = (stage == MESA_SHADER_FRAGMENT) ? int(FRAG_RESULT_DATA0) 3992 : int(VARYING_SLOT_VAR0); 3993 break; 3994 default: 3995 continue; 3996 }; 3997 3998 if (var->data.patch) 3999 loc_bias = int(VARYING_SLOT_PATCH0); 4000 4001 /* Skip packed varyings, packed varyings are handled separately 4002 * by add_packed_varyings. 4003 */ 4004 if (strncmp(var->name, "packed:", 7) == 0) 4005 continue; 4006 4007 /* Skip fragdata arrays, these are handled separately 4008 * by add_fragdata_arrays. 4009 */ 4010 if (strncmp(var->name, "gl_out_FragData", 15) == 0) 4011 continue; 4012 4013 const bool vs_input_or_fs_output = 4014 (stage == MESA_SHADER_VERTEX && var->data.mode == ir_var_shader_in) || 4015 (stage == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_out); 4016 4017 if (!add_shader_variable(ctx, shProg, resource_set, 4018 1 << stage, programInterface, 4019 var, var->name, var->type, vs_input_or_fs_output, 4020 var->data.location - loc_bias, 4021 inout_has_same_location(var, stage))) 4022 return false; 4023 } 4024 return true; 4025 } 4026 4027 static bool 4028 add_packed_varyings(const struct gl_context *ctx, 4029 struct gl_shader_program *shProg, 4030 struct set *resource_set, 4031 int stage, GLenum type) 4032 { 4033 struct gl_linked_shader *sh = shProg->_LinkedShaders[stage]; 4034 GLenum iface; 4035 4036 if (!sh || !sh->packed_varyings) 4037 return true; 4038 4039 foreach_in_list(ir_instruction, node, sh->packed_varyings) { 4040 ir_variable *var = node->as_variable(); 4041 if (var) { 4042 switch (var->data.mode) { 4043 case ir_var_shader_in: 4044 iface = GL_PROGRAM_INPUT; 4045 break; 4046 case ir_var_shader_out: 4047 iface = GL_PROGRAM_OUTPUT; 4048 break; 4049 default: 4050 unreachable("unexpected type"); 4051 } 4052 4053 if (type == iface) { 4054 const int stage_mask = 4055 build_stageref(shProg, var->name, var->data.mode); 4056 if (!add_shader_variable(ctx, shProg, resource_set, 4057 stage_mask, 4058 iface, var, var->name, var->type, false, 4059 var->data.location - VARYING_SLOT_VAR0, 4060 inout_has_same_location(var, stage))) 4061 return false; 4062 } 4063 } 4064 } 4065 return true; 4066 } 4067 4068 static bool 4069 add_fragdata_arrays(const struct gl_context *ctx, 4070 struct gl_shader_program *shProg, 4071 struct set *resource_set) 4072 { 4073 struct gl_linked_shader *sh = shProg->_LinkedShaders[MESA_SHADER_FRAGMENT]; 4074 4075 if (!sh || !sh->fragdata_arrays) 4076 return true; 4077 4078 foreach_in_list(ir_instruction, node, sh->fragdata_arrays) { 4079 ir_variable *var = node->as_variable(); 4080 if (var) { 4081 assert(var->data.mode == ir_var_shader_out); 4082 4083 if (!add_shader_variable(ctx, shProg, resource_set, 4084 1 << MESA_SHADER_FRAGMENT, 4085 GL_PROGRAM_OUTPUT, var, var->name, var->type, 4086 true, var->data.location - FRAG_RESULT_DATA0, 4087 false)) 4088 return false; 4089 } 4090 } 4091 return true; 4092 } 4093 4094 static char* 4095 get_top_level_name(const char *name) 4096 { 4097 const char *first_dot = strchr(name, '.'); 4098 const char *first_square_bracket = strchr(name, '['); 4099 int name_size = 0; 4100 4101 /* The ARB_program_interface_query spec says: 4102 * 4103 * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying 4104 * the number of active array elements of the top-level shader storage 4105 * block member containing to the active variable is written to 4106 * <params>. If the top-level block member is not declared as an 4107 * array, the value one is written to <params>. If the top-level block 4108 * member is an array with no declared size, the value zero is written 4109 * to <params>." 4110 */ 4111 4112 /* The buffer variable is on top level.*/ 4113 if (!first_square_bracket && !first_dot) 4114 name_size = strlen(name); 4115 else if ((!first_square_bracket || 4116 (first_dot && first_dot < first_square_bracket))) 4117 name_size = first_dot - name; 4118 else 4119 name_size = first_square_bracket - name; 4120 4121 return strndup(name, name_size); 4122 } 4123 4124 static char* 4125 get_var_name(const char *name) 4126 { 4127 const char *first_dot = strchr(name, '.'); 4128 4129 if (!first_dot) 4130 return strdup(name); 4131 4132 return strndup(first_dot+1, strlen(first_dot) - 1); 4133 } 4134 4135 static bool 4136 is_top_level_shader_storage_block_member(const char* name, 4137 const char* interface_name, 4138 const char* field_name) 4139 { 4140 bool result = false; 4141 4142 /* If the given variable is already a top-level shader storage 4143 * block member, then return array_size = 1. 4144 * We could have two possibilities: if we have an instanced 4145 * shader storage block or not instanced. 4146 * 4147 * For the first, we check create a name as it was in top level and 4148 * compare it with the real name. If they are the same, then 4149 * the variable is already at top-level. 4150 * 4151 * Full instanced name is: interface name + '.' + var name + 4152 * NULL character 4153 */ 4154 int name_length = strlen(interface_name) + 1 + strlen(field_name) + 1; 4155 char *full_instanced_name = (char *) calloc(name_length, sizeof(char)); 4156 if (!full_instanced_name) { 4157 fprintf(stderr, "%s: Cannot allocate space for name\n", __func__); 4158 return false; 4159 } 4160 4161 snprintf(full_instanced_name, name_length, "%s.%s", 4162 interface_name, field_name); 4163 4164 /* Check if its top-level shader storage block member of an 4165 * instanced interface block, or of a unnamed interface block. 4166 */ 4167 if (strcmp(name, full_instanced_name) == 0 || 4168 strcmp(name, field_name) == 0) 4169 result = true; 4170 4171 free(full_instanced_name); 4172 return result; 4173 } 4174 4175 static int 4176 get_array_size(struct gl_uniform_storage *uni, const glsl_struct_field *field, 4177 char *interface_name, char *var_name) 4178 { 4179 /* The ARB_program_interface_query spec says: 4180 * 4181 * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying 4182 * the number of active array elements of the top-level shader storage 4183 * block member containing to the active variable is written to 4184 * <params>. If the top-level block member is not declared as an 4185 * array, the value one is written to <params>. If the top-level block 4186 * member is an array with no declared size, the value zero is written 4187 * to <params>." 4188 */ 4189 if (is_top_level_shader_storage_block_member(uni->name, 4190 interface_name, 4191 var_name)) 4192 return 1; 4193 else if (field->type->is_unsized_array()) 4194 return 0; 4195 else if (field->type->is_array()) 4196 return field->type->length; 4197 4198 return 1; 4199 } 4200 4201 static int 4202 get_array_stride(struct gl_context *ctx, struct gl_uniform_storage *uni, 4203 const glsl_type *interface, const glsl_struct_field *field, 4204 char *interface_name, char *var_name) 4205 { 4206 /* The ARB_program_interface_query spec says: 4207 * 4208 * "For the property TOP_LEVEL_ARRAY_STRIDE, a single integer 4209 * identifying the stride between array elements of the top-level 4210 * shader storage block member containing the active variable is 4211 * written to <params>. For top-level block members declared as 4212 * arrays, the value written is the difference, in basic machine units, 4213 * between the offsets of the active variable for consecutive elements 4214 * in the top-level array. For top-level block members not declared as 4215 * an array, zero is written to <params>." 4216 */ 4217 if (field->type->is_array()) { 4218 const enum glsl_matrix_layout matrix_layout = 4219 glsl_matrix_layout(field->matrix_layout); 4220 bool row_major = matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR; 4221 const glsl_type *array_type = field->type->fields.array; 4222 4223 if (is_top_level_shader_storage_block_member(uni->name, 4224 interface_name, 4225 var_name)) 4226 return 0; 4227 4228 if (GLSL_INTERFACE_PACKING_STD140 == 4229 interface-> 4230 get_internal_ifc_packing(ctx->Const.UseSTD430AsDefaultPacking)) { 4231 if (array_type->is_record() || array_type->is_array()) 4232 return glsl_align(array_type->std140_size(row_major), 16); 4233 else 4234 return MAX2(array_type->std140_base_alignment(row_major), 16); 4235 } else { 4236 return array_type->std430_array_stride(row_major); 4237 } 4238 } 4239 return 0; 4240 } 4241 4242 static void 4243 calculate_array_size_and_stride(struct gl_context *ctx, 4244 struct gl_shader_program *shProg, 4245 struct gl_uniform_storage *uni) 4246 { 4247 int block_index = uni->block_index; 4248 int array_size = -1; 4249 int array_stride = -1; 4250 char *var_name = get_top_level_name(uni->name); 4251 char *interface_name = 4252 get_top_level_name(uni->is_shader_storage ? 4253 shProg->data->ShaderStorageBlocks[block_index].Name : 4254 shProg->data->UniformBlocks[block_index].Name); 4255 4256 if (strcmp(var_name, interface_name) == 0) { 4257 /* Deal with instanced array of SSBOs */ 4258 char *temp_name = get_var_name(uni->name); 4259 if (!temp_name) { 4260 linker_error(shProg, "Out of memory during linking.\n"); 4261 goto write_top_level_array_size_and_stride; 4262 } 4263 free(var_name); 4264 var_name = get_top_level_name(temp_name); 4265 free(temp_name); 4266 if (!var_name) { 4267 linker_error(shProg, "Out of memory during linking.\n"); 4268 goto write_top_level_array_size_and_stride; 4269 } 4270 } 4271 4272 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 4273 const gl_linked_shader *sh = shProg->_LinkedShaders[i]; 4274 if (sh == NULL) 4275 continue; 4276 4277 foreach_in_list(ir_instruction, node, sh->ir) { 4278 ir_variable *var = node->as_variable(); 4279 if (!var || !var->get_interface_type() || 4280 var->data.mode != ir_var_shader_storage) 4281 continue; 4282 4283 const glsl_type *interface = var->get_interface_type(); 4284 4285 if (strcmp(interface_name, interface->name) != 0) 4286 continue; 4287 4288 for (unsigned i = 0; i < interface->length; i++) { 4289 const glsl_struct_field *field = &interface->fields.structure[i]; 4290 if (strcmp(field->name, var_name) != 0) 4291 continue; 4292 4293 array_stride = get_array_stride(ctx, uni, interface, field, 4294 interface_name, var_name); 4295 array_size = get_array_size(uni, field, interface_name, var_name); 4296 goto write_top_level_array_size_and_stride; 4297 } 4298 } 4299 } 4300 write_top_level_array_size_and_stride: 4301 free(interface_name); 4302 free(var_name); 4303 uni->top_level_array_stride = array_stride; 4304 uni->top_level_array_size = array_size; 4305 } 4306 4307 /** 4308 * Builds up a list of program resources that point to existing 4309 * resource data. 4310 */ 4311 void 4312 build_program_resource_list(struct gl_context *ctx, 4313 struct gl_shader_program *shProg) 4314 { 4315 /* Rebuild resource list. */ 4316 if (shProg->data->ProgramResourceList) { 4317 ralloc_free(shProg->data->ProgramResourceList); 4318 shProg->data->ProgramResourceList = NULL; 4319 shProg->data->NumProgramResourceList = 0; 4320 } 4321 4322 int input_stage = MESA_SHADER_STAGES, output_stage = 0; 4323 4324 /* Determine first input and final output stage. These are used to 4325 * detect which variables should be enumerated in the resource list 4326 * for GL_PROGRAM_INPUT and GL_PROGRAM_OUTPUT. 4327 */ 4328 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 4329 if (!shProg->_LinkedShaders[i]) 4330 continue; 4331 if (input_stage == MESA_SHADER_STAGES) 4332 input_stage = i; 4333 output_stage = i; 4334 } 4335 4336 /* Empty shader, no resources. */ 4337 if (input_stage == MESA_SHADER_STAGES && output_stage == 0) 4338 return; 4339 4340 struct set *resource_set = _mesa_set_create(NULL, 4341 _mesa_hash_pointer, 4342 _mesa_key_pointer_equal); 4343 4344 /* Program interface needs to expose varyings in case of SSO. */ 4345 if (shProg->SeparateShader) { 4346 if (!add_packed_varyings(ctx, shProg, resource_set, 4347 input_stage, GL_PROGRAM_INPUT)) 4348 return; 4349 4350 if (!add_packed_varyings(ctx, shProg, resource_set, 4351 output_stage, GL_PROGRAM_OUTPUT)) 4352 return; 4353 } 4354 4355 if (!add_fragdata_arrays(ctx, shProg, resource_set)) 4356 return; 4357 4358 /* Add inputs and outputs to the resource list. */ 4359 if (!add_interface_variables(ctx, shProg, resource_set, 4360 input_stage, GL_PROGRAM_INPUT)) 4361 return; 4362 4363 if (!add_interface_variables(ctx, shProg, resource_set, 4364 output_stage, GL_PROGRAM_OUTPUT)) 4365 return; 4366 4367 if (shProg->last_vert_prog) { 4368 struct gl_transform_feedback_info *linked_xfb = 4369 shProg->last_vert_prog->sh.LinkedTransformFeedback; 4370 4371 /* Add transform feedback varyings. */ 4372 if (linked_xfb->NumVarying > 0) { 4373 for (int i = 0; i < linked_xfb->NumVarying; i++) { 4374 if (!add_program_resource(shProg, resource_set, 4375 GL_TRANSFORM_FEEDBACK_VARYING, 4376 &linked_xfb->Varyings[i], 0)) 4377 return; 4378 } 4379 } 4380 4381 /* Add transform feedback buffers. */ 4382 for (unsigned i = 0; i < ctx->Const.MaxTransformFeedbackBuffers; i++) { 4383 if ((linked_xfb->ActiveBuffers >> i) & 1) { 4384 linked_xfb->Buffers[i].Binding = i; 4385 if (!add_program_resource(shProg, resource_set, 4386 GL_TRANSFORM_FEEDBACK_BUFFER, 4387 &linked_xfb->Buffers[i], 0)) 4388 return; 4389 } 4390 } 4391 } 4392 4393 /* Add uniforms from uniform storage. */ 4394 for (unsigned i = 0; i < shProg->data->NumUniformStorage; i++) { 4395 /* Do not add uniforms internally used by Mesa. */ 4396 if (shProg->data->UniformStorage[i].hidden) 4397 continue; 4398 4399 uint8_t stageref = 4400 build_stageref(shProg, shProg->data->UniformStorage[i].name, 4401 ir_var_uniform); 4402 4403 /* Add stagereferences for uniforms in a uniform block. */ 4404 bool is_shader_storage = 4405 shProg->data->UniformStorage[i].is_shader_storage; 4406 int block_index = shProg->data->UniformStorage[i].block_index; 4407 if (block_index != -1) { 4408 stageref |= is_shader_storage ? 4409 shProg->data->ShaderStorageBlocks[block_index].stageref : 4410 shProg->data->UniformBlocks[block_index].stageref; 4411 } 4412 4413 GLenum type = is_shader_storage ? GL_BUFFER_VARIABLE : GL_UNIFORM; 4414 if (!should_add_buffer_variable(shProg, type, 4415 shProg->data->UniformStorage[i].name)) 4416 continue; 4417 4418 if (is_shader_storage) { 4419 calculate_array_size_and_stride(ctx, shProg, 4420 &shProg->data->UniformStorage[i]); 4421 } 4422 4423 if (!add_program_resource(shProg, resource_set, type, 4424 &shProg->data->UniformStorage[i], stageref)) 4425 return; 4426 } 4427 4428 /* Add program uniform blocks. */ 4429 for (unsigned i = 0; i < shProg->data->NumUniformBlocks; i++) { 4430 if (!add_program_resource(shProg, resource_set, GL_UNIFORM_BLOCK, 4431 &shProg->data->UniformBlocks[i], 0)) 4432 return; 4433 } 4434 4435 /* Add program shader storage blocks. */ 4436 for (unsigned i = 0; i < shProg->data->NumShaderStorageBlocks; i++) { 4437 if (!add_program_resource(shProg, resource_set, GL_SHADER_STORAGE_BLOCK, 4438 &shProg->data->ShaderStorageBlocks[i], 0)) 4439 return; 4440 } 4441 4442 /* Add atomic counter buffers. */ 4443 for (unsigned i = 0; i < shProg->data->NumAtomicBuffers; i++) { 4444 if (!add_program_resource(shProg, resource_set, GL_ATOMIC_COUNTER_BUFFER, 4445 &shProg->data->AtomicBuffers[i], 0)) 4446 return; 4447 } 4448 4449 for (unsigned i = 0; i < shProg->data->NumUniformStorage; i++) { 4450 GLenum type; 4451 if (!shProg->data->UniformStorage[i].hidden) 4452 continue; 4453 4454 for (int j = MESA_SHADER_VERTEX; j < MESA_SHADER_STAGES; j++) { 4455 if (!shProg->data->UniformStorage[i].opaque[j].active || 4456 !shProg->data->UniformStorage[i].type->is_subroutine()) 4457 continue; 4458 4459 type = _mesa_shader_stage_to_subroutine_uniform((gl_shader_stage)j); 4460 /* add shader subroutines */ 4461 if (!add_program_resource(shProg, resource_set, 4462 type, &shProg->data->UniformStorage[i], 0)) 4463 return; 4464 } 4465 } 4466 4467 unsigned mask = shProg->data->linked_stages; 4468 while (mask) { 4469 const int i = u_bit_scan(&mask); 4470 struct gl_program *p = shProg->_LinkedShaders[i]->Program; 4471 4472 GLuint type = _mesa_shader_stage_to_subroutine((gl_shader_stage)i); 4473 for (unsigned j = 0; j < p->sh.NumSubroutineFunctions; j++) { 4474 if (!add_program_resource(shProg, resource_set, 4475 type, &p->sh.SubroutineFunctions[j], 0)) 4476 return; 4477 } 4478 } 4479 4480 _mesa_set_destroy(resource_set, NULL); 4481 } 4482 4483 /** 4484 * This check is done to make sure we allow only constant expression 4485 * indexing and "constant-index-expression" (indexing with an expression 4486 * that includes loop induction variable). 4487 */ 4488 static bool 4489 validate_sampler_array_indexing(struct gl_context *ctx, 4490 struct gl_shader_program *prog) 4491 { 4492 dynamic_sampler_array_indexing_visitor v; 4493 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 4494 if (prog->_LinkedShaders[i] == NULL) 4495 continue; 4496 4497 bool no_dynamic_indexing = 4498 ctx->Const.ShaderCompilerOptions[i].EmitNoIndirectSampler; 4499 4500 /* Search for array derefs in shader. */ 4501 v.run(prog->_LinkedShaders[i]->ir); 4502 if (v.uses_dynamic_sampler_array_indexing()) { 4503 const char *msg = "sampler arrays indexed with non-constant " 4504 "expressions is forbidden in GLSL %s %u"; 4505 /* Backend has indicated that it has no dynamic indexing support. */ 4506 if (no_dynamic_indexing) { 4507 linker_error(prog, msg, prog->IsES ? "ES" : "", 4508 prog->data->Version); 4509 return false; 4510 } else { 4511 linker_warning(prog, msg, prog->IsES ? "ES" : "", 4512 prog->data->Version); 4513 } 4514 } 4515 } 4516 return true; 4517 } 4518 4519 static void 4520 link_assign_subroutine_types(struct gl_shader_program *prog) 4521 { 4522 unsigned mask = prog->data->linked_stages; 4523 while (mask) { 4524 const int i = u_bit_scan(&mask); 4525 gl_program *p = prog->_LinkedShaders[i]->Program; 4526 4527 p->sh.MaxSubroutineFunctionIndex = 0; 4528 foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) { 4529 ir_function *fn = node->as_function(); 4530 if (!fn) 4531 continue; 4532 4533 if (fn->is_subroutine) 4534 p->sh.NumSubroutineUniformTypes++; 4535 4536 if (!fn->num_subroutine_types) 4537 continue; 4538 4539 /* these should have been calculated earlier. */ 4540 assert(fn->subroutine_index != -1); 4541 if (p->sh.NumSubroutineFunctions + 1 > MAX_SUBROUTINES) { 4542 linker_error(prog, "Too many subroutine functions declared.\n"); 4543 return; 4544 } 4545 p->sh.SubroutineFunctions = reralloc(p, p->sh.SubroutineFunctions, 4546 struct gl_subroutine_function, 4547 p->sh.NumSubroutineFunctions + 1); 4548 p->sh.SubroutineFunctions[p->sh.NumSubroutineFunctions].name = ralloc_strdup(p, fn->name); 4549 p->sh.SubroutineFunctions[p->sh.NumSubroutineFunctions].num_compat_types = fn->num_subroutine_types; 4550 p->sh.SubroutineFunctions[p->sh.NumSubroutineFunctions].types = 4551 ralloc_array(p, const struct glsl_type *, 4552 fn->num_subroutine_types); 4553 4554 /* From Section 4.4.4(Subroutine Function Layout Qualifiers) of the 4555 * GLSL 4.5 spec: 4556 * 4557 * "Each subroutine with an index qualifier in the shader must be 4558 * given a unique index, otherwise a compile or link error will be 4559 * generated." 4560 */ 4561 for (unsigned j = 0; j < p->sh.NumSubroutineFunctions; j++) { 4562 if (p->sh.SubroutineFunctions[j].index != -1 && 4563 p->sh.SubroutineFunctions[j].index == fn->subroutine_index) { 4564 linker_error(prog, "each subroutine index qualifier in the " 4565 "shader must be unique\n"); 4566 return; 4567 } 4568 } 4569 p->sh.SubroutineFunctions[p->sh.NumSubroutineFunctions].index = 4570 fn->subroutine_index; 4571 4572 if (fn->subroutine_index > (int)p->sh.MaxSubroutineFunctionIndex) 4573 p->sh.MaxSubroutineFunctionIndex = fn->subroutine_index; 4574 4575 for (int j = 0; j < fn->num_subroutine_types; j++) 4576 p->sh.SubroutineFunctions[p->sh.NumSubroutineFunctions].types[j] = fn->subroutine_types[j]; 4577 p->sh.NumSubroutineFunctions++; 4578 } 4579 } 4580 } 4581 4582 static void 4583 set_always_active_io(exec_list *ir, ir_variable_mode io_mode) 4584 { 4585 assert(io_mode == ir_var_shader_in || io_mode == ir_var_shader_out); 4586 4587 foreach_in_list(ir_instruction, node, ir) { 4588 ir_variable *const var = node->as_variable(); 4589 4590 if (var == NULL || var->data.mode != io_mode) 4591 continue; 4592 4593 /* Don't set always active on builtins that haven't been redeclared */ 4594 if (var->data.how_declared == ir_var_declared_implicitly) 4595 continue; 4596 4597 var->data.always_active_io = true; 4598 } 4599 } 4600 4601 /** 4602 * When separate shader programs are enabled, only input/outputs between 4603 * the stages of a multi-stage separate program can be safely removed 4604 * from the shader interface. Other inputs/outputs must remain active. 4605 */ 4606 static void 4607 disable_varying_optimizations_for_sso(struct gl_shader_program *prog) 4608 { 4609 unsigned first, last; 4610 assert(prog->SeparateShader); 4611 4612 first = MESA_SHADER_STAGES; 4613 last = 0; 4614 4615 /* Determine first and last stage. Excluding the compute stage */ 4616 for (unsigned i = 0; i < MESA_SHADER_COMPUTE; i++) { 4617 if (!prog->_LinkedShaders[i]) 4618 continue; 4619 if (first == MESA_SHADER_STAGES) 4620 first = i; 4621 last = i; 4622 } 4623 4624 if (first == MESA_SHADER_STAGES) 4625 return; 4626 4627 for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) { 4628 gl_linked_shader *sh = prog->_LinkedShaders[stage]; 4629 if (!sh) 4630 continue; 4631 4632 /* Prevent the removal of inputs to the first and outputs from the last 4633 * stage, unless they are the initial pipeline inputs or final pipeline 4634 * outputs, respectively. 4635 * 4636 * The removal of IO between shaders in the same program is always 4637 * allowed. 4638 */ 4639 if (stage == first && stage != MESA_SHADER_VERTEX) 4640 set_always_active_io(sh->ir, ir_var_shader_in); 4641 if (stage == last && stage != MESA_SHADER_FRAGMENT) 4642 set_always_active_io(sh->ir, ir_var_shader_out); 4643 } 4644 } 4645 4646 static void 4647 link_and_validate_uniforms(struct gl_context *ctx, 4648 struct gl_shader_program *prog) 4649 { 4650 update_array_sizes(prog); 4651 link_assign_uniform_locations(prog, ctx); 4652 4653 link_assign_atomic_counter_resources(ctx, prog); 4654 link_calculate_subroutine_compat(prog); 4655 check_resources(ctx, prog); 4656 check_subroutine_resources(prog); 4657 check_image_resources(ctx, prog); 4658 link_check_atomic_counter_resources(ctx, prog); 4659 } 4660 4661 static bool 4662 link_varyings_and_uniforms(unsigned first, unsigned last, 4663 struct gl_context *ctx, 4664 struct gl_shader_program *prog, void *mem_ctx) 4665 { 4666 /* Mark all generic shader inputs and outputs as unpaired. */ 4667 for (unsigned i = MESA_SHADER_VERTEX; i <= MESA_SHADER_FRAGMENT; i++) { 4668 if (prog->_LinkedShaders[i] != NULL) { 4669 link_invalidate_variable_locations(prog->_LinkedShaders[i]->ir); 4670 } 4671 } 4672 4673 unsigned prev = first; 4674 for (unsigned i = prev + 1; i <= MESA_SHADER_FRAGMENT; i++) { 4675 if (prog->_LinkedShaders[i] == NULL) 4676 continue; 4677 4678 match_explicit_outputs_to_inputs(prog->_LinkedShaders[prev], 4679 prog->_LinkedShaders[i]); 4680 prev = i; 4681 } 4682 4683 if (!assign_attribute_or_color_locations(mem_ctx, prog, &ctx->Const, 4684 MESA_SHADER_VERTEX)) { 4685 return false; 4686 } 4687 4688 if (!assign_attribute_or_color_locations(mem_ctx, prog, &ctx->Const, 4689 MESA_SHADER_FRAGMENT)) { 4690 return false; 4691 } 4692 4693 prog->last_vert_prog = NULL; 4694 for (int i = MESA_SHADER_GEOMETRY; i >= MESA_SHADER_VERTEX; i--) { 4695 if (prog->_LinkedShaders[i] == NULL) 4696 continue; 4697 4698 prog->last_vert_prog = prog->_LinkedShaders[i]->Program; 4699 break; 4700 } 4701 4702 if (!link_varyings(prog, first, last, ctx, mem_ctx)) 4703 return false; 4704 4705 link_and_validate_uniforms(ctx, prog); 4706 4707 if (!prog->data->LinkStatus) 4708 return false; 4709 4710 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 4711 if (prog->_LinkedShaders[i] == NULL) 4712 continue; 4713 4714 const struct gl_shader_compiler_options *options = 4715 &ctx->Const.ShaderCompilerOptions[i]; 4716 4717 if (options->LowerBufferInterfaceBlocks) 4718 lower_ubo_reference(prog->_LinkedShaders[i], 4719 options->ClampBlockIndicesToArrayBounds, 4720 ctx->Const.UseSTD430AsDefaultPacking); 4721 4722 if (i == MESA_SHADER_COMPUTE) 4723 lower_shared_reference(ctx, prog, prog->_LinkedShaders[i]); 4724 4725 lower_vector_derefs(prog->_LinkedShaders[i]); 4726 do_vec_index_to_swizzle(prog->_LinkedShaders[i]->ir); 4727 } 4728 4729 return true; 4730 } 4731 4732 static void 4733 linker_optimisation_loop(struct gl_context *ctx, exec_list *ir, 4734 unsigned stage) 4735 { 4736 if (ctx->Const.GLSLOptimizeConservatively) { 4737 /* Run it just once. */ 4738 do_common_optimization(ir, true, false, 4739 &ctx->Const.ShaderCompilerOptions[stage], 4740 ctx->Const.NativeIntegers); 4741 } else { 4742 /* Repeat it until it stops making changes. */ 4743 while (do_common_optimization(ir, true, false, 4744 &ctx->Const.ShaderCompilerOptions[stage], 4745 ctx->Const.NativeIntegers)) 4746 ; 4747 } 4748 } 4749 4750 void 4751 link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) 4752 { 4753 prog->data->LinkStatus = linking_success; /* All error paths will set this to false */ 4754 prog->data->Validated = false; 4755 4756 /* Section 7.3 (Program Objects) of the OpenGL 4.5 Core Profile spec says: 4757 * 4758 * "Linking can fail for a variety of reasons as specified in the 4759 * OpenGL Shading Language Specification, as well as any of the 4760 * following reasons: 4761 * 4762 * - No shader objects are attached to program." 4763 * 4764 * The Compatibility Profile specification does not list the error. In 4765 * Compatibility Profile missing shader stages are replaced by 4766 * fixed-function. This applies to the case where all stages are 4767 * missing. 4768 */ 4769 if (prog->NumShaders == 0) { 4770 if (ctx->API != API_OPENGL_COMPAT) 4771 linker_error(prog, "no shaders attached to the program\n"); 4772 return; 4773 } 4774 4775 #ifdef ENABLE_SHADER_CACHE 4776 /* If transform feedback used on the program then compile all shaders. */ 4777 bool skip_cache = false; 4778 if (prog->TransformFeedback.NumVarying > 0) { 4779 for (unsigned i = 0; i < prog->NumShaders; i++) { 4780 _mesa_glsl_compile_shader(ctx, prog->Shaders[i], false, false, true); 4781 } 4782 skip_cache = true; 4783 } 4784 4785 if (!skip_cache && shader_cache_read_program_metadata(ctx, prog)) 4786 return; 4787 #endif 4788 4789 void *mem_ctx = ralloc_context(NULL); // temporary linker context 4790 4791 prog->ARB_fragment_coord_conventions_enable = false; 4792 4793 /* Separate the shaders into groups based on their type. 4794 */ 4795 struct gl_shader **shader_list[MESA_SHADER_STAGES]; 4796 unsigned num_shaders[MESA_SHADER_STAGES]; 4797 4798 for (int i = 0; i < MESA_SHADER_STAGES; i++) { 4799 shader_list[i] = (struct gl_shader **) 4800 calloc(prog->NumShaders, sizeof(struct gl_shader *)); 4801 num_shaders[i] = 0; 4802 } 4803 4804 unsigned min_version = UINT_MAX; 4805 unsigned max_version = 0; 4806 for (unsigned i = 0; i < prog->NumShaders; i++) { 4807 min_version = MIN2(min_version, prog->Shaders[i]->Version); 4808 max_version = MAX2(max_version, prog->Shaders[i]->Version); 4809 4810 if (prog->Shaders[i]->IsES != prog->Shaders[0]->IsES) { 4811 linker_error(prog, "all shaders must use same shading " 4812 "language version\n"); 4813 goto done; 4814 } 4815 4816 if (prog->Shaders[i]->ARB_fragment_coord_conventions_enable) { 4817 prog->ARB_fragment_coord_conventions_enable = true; 4818 } 4819 4820 gl_shader_stage shader_type = prog->Shaders[i]->Stage; 4821 shader_list[shader_type][num_shaders[shader_type]] = prog->Shaders[i]; 4822 num_shaders[shader_type]++; 4823 } 4824 4825 /* In desktop GLSL, different shader versions may be linked together. In 4826 * GLSL ES, all shader versions must be the same. 4827 */ 4828 if (prog->Shaders[0]->IsES && min_version != max_version) { 4829 linker_error(prog, "all shaders must use same shading " 4830 "language version\n"); 4831 goto done; 4832 } 4833 4834 prog->data->Version = max_version; 4835 prog->IsES = prog->Shaders[0]->IsES; 4836 4837 /* Some shaders have to be linked with some other shaders present. 4838 */ 4839 if (!prog->SeparateShader) { 4840 if (num_shaders[MESA_SHADER_GEOMETRY] > 0 && 4841 num_shaders[MESA_SHADER_VERTEX] == 0) { 4842 linker_error(prog, "Geometry shader must be linked with " 4843 "vertex shader\n"); 4844 goto done; 4845 } 4846 if (num_shaders[MESA_SHADER_TESS_EVAL] > 0 && 4847 num_shaders[MESA_SHADER_VERTEX] == 0) { 4848 linker_error(prog, "Tessellation evaluation shader must be linked " 4849 "with vertex shader\n"); 4850 goto done; 4851 } 4852 if (num_shaders[MESA_SHADER_TESS_CTRL] > 0 && 4853 num_shaders[MESA_SHADER_VERTEX] == 0) { 4854 linker_error(prog, "Tessellation control shader must be linked with " 4855 "vertex shader\n"); 4856 goto done; 4857 } 4858 4859 /* Section 7.3 of the OpenGL ES 3.2 specification says: 4860 * 4861 * "Linking can fail for [...] any of the following reasons: 4862 * 4863 * * program contains an object to form a tessellation control 4864 * shader [...] and [...] the program is not separable and 4865 * contains no object to form a tessellation evaluation shader" 4866 * 4867 * The OpenGL spec is contradictory. It allows linking without a tess 4868 * eval shader, but that can only be used with transform feedback and 4869 * rasterization disabled. However, transform feedback isn't allowed 4870 * with GL_PATCHES, so it can't be used. 4871 * 4872 * More investigation showed that the idea of transform feedback after 4873 * a tess control shader was dropped, because some hw vendors couldn't 4874 * support tessellation without a tess eval shader, but the linker 4875 * section wasn't updated to reflect that. 4876 * 4877 * All specifications (ARB_tessellation_shader, GL 4.0-4.5) have this 4878 * spec bug. 4879 * 4880 * Do what's reasonable and always require a tess eval shader if a tess 4881 * control shader is present. 4882 */ 4883 if (num_shaders[MESA_SHADER_TESS_CTRL] > 0 && 4884 num_shaders[MESA_SHADER_TESS_EVAL] == 0) { 4885 linker_error(prog, "Tessellation control shader must be linked with " 4886 "tessellation evaluation shader\n"); 4887 goto done; 4888 } 4889 4890 if (prog->IsES) { 4891 if (num_shaders[MESA_SHADER_TESS_EVAL] > 0 && 4892 num_shaders[MESA_SHADER_TESS_CTRL] == 0) { 4893 linker_error(prog, "GLSL ES requires non-separable programs " 4894 "containing a tessellation evaluation shader to also " 4895 "be linked with a tessellation control shader\n"); 4896 goto done; 4897 } 4898 } 4899 } 4900 4901 /* Compute shaders have additional restrictions. */ 4902 if (num_shaders[MESA_SHADER_COMPUTE] > 0 && 4903 num_shaders[MESA_SHADER_COMPUTE] != prog->NumShaders) { 4904 linker_error(prog, "Compute shaders may not be linked with any other " 4905 "type of shader\n"); 4906 } 4907 4908 /* Link all shaders for a particular stage and validate the result. 4909 */ 4910 for (int stage = 0; stage < MESA_SHADER_STAGES; stage++) { 4911 if (num_shaders[stage] > 0) { 4912 gl_linked_shader *const sh = 4913 link_intrastage_shaders(mem_ctx, ctx, prog, shader_list[stage], 4914 num_shaders[stage], false); 4915 4916 if (!prog->data->LinkStatus) { 4917 if (sh) 4918 _mesa_delete_linked_shader(ctx, sh); 4919 goto done; 4920 } 4921 4922 switch (stage) { 4923 case MESA_SHADER_VERTEX: 4924 validate_vertex_shader_executable(prog, sh, ctx); 4925 break; 4926 case MESA_SHADER_TESS_CTRL: 4927 /* nothing to be done */ 4928 break; 4929 case MESA_SHADER_TESS_EVAL: 4930 validate_tess_eval_shader_executable(prog, sh, ctx); 4931 break; 4932 case MESA_SHADER_GEOMETRY: 4933 validate_geometry_shader_executable(prog, sh, ctx); 4934 break; 4935 case MESA_SHADER_FRAGMENT: 4936 validate_fragment_shader_executable(prog, sh); 4937 break; 4938 } 4939 if (!prog->data->LinkStatus) { 4940 if (sh) 4941 _mesa_delete_linked_shader(ctx, sh); 4942 goto done; 4943 } 4944 4945 prog->_LinkedShaders[stage] = sh; 4946 prog->data->linked_stages |= 1 << stage; 4947 } 4948 } 4949 4950 /* Here begins the inter-stage linking phase. Some initial validation is 4951 * performed, then locations are assigned for uniforms, attributes, and 4952 * varyings. 4953 */ 4954 cross_validate_uniforms(prog); 4955 if (!prog->data->LinkStatus) 4956 goto done; 4957 4958 unsigned first, last, prev; 4959 4960 first = MESA_SHADER_STAGES; 4961 last = 0; 4962 4963 /* Determine first and last stage. */ 4964 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 4965 if (!prog->_LinkedShaders[i]) 4966 continue; 4967 if (first == MESA_SHADER_STAGES) 4968 first = i; 4969 last = i; 4970 } 4971 4972 check_explicit_uniform_locations(ctx, prog); 4973 link_assign_subroutine_types(prog); 4974 4975 if (!prog->data->LinkStatus) 4976 goto done; 4977 4978 resize_tes_inputs(ctx, prog); 4979 4980 /* Validate the inputs of each stage with the output of the preceding 4981 * stage. 4982 */ 4983 prev = first; 4984 for (unsigned i = prev + 1; i <= MESA_SHADER_FRAGMENT; i++) { 4985 if (prog->_LinkedShaders[i] == NULL) 4986 continue; 4987 4988 validate_interstage_inout_blocks(prog, prog->_LinkedShaders[prev], 4989 prog->_LinkedShaders[i]); 4990 if (!prog->data->LinkStatus) 4991 goto done; 4992 4993 cross_validate_outputs_to_inputs(ctx, prog, 4994 prog->_LinkedShaders[prev], 4995 prog->_LinkedShaders[i]); 4996 if (!prog->data->LinkStatus) 4997 goto done; 4998 4999 prev = i; 5000 } 5001 5002 /* The cross validation of outputs/inputs above validates explicit locations 5003 * but for SSO programs we need to do this also for the inputs in the 5004 * first stage and outputs of the last stage included in the program, since 5005 * there is no cross validation for these. 5006 */ 5007 if (prog->SeparateShader) 5008 validate_sso_explicit_locations(ctx, prog, 5009 (gl_shader_stage) first, 5010 (gl_shader_stage) last); 5011 5012 /* Cross-validate uniform blocks between shader stages */ 5013 validate_interstage_uniform_blocks(prog, prog->_LinkedShaders); 5014 if (!prog->data->LinkStatus) 5015 goto done; 5016 5017 for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) { 5018 if (prog->_LinkedShaders[i] != NULL) 5019 lower_named_interface_blocks(mem_ctx, prog->_LinkedShaders[i]); 5020 } 5021 5022 /* Implement the GLSL 1.30+ rule for discard vs infinite loops Do 5023 * it before optimization because we want most of the checks to get 5024 * dropped thanks to constant propagation. 5025 * 5026 * This rule also applies to GLSL ES 3.00. 5027 */ 5028 if (max_version >= (prog->IsES ? 300 : 130)) { 5029 struct gl_linked_shader *sh = prog->_LinkedShaders[MESA_SHADER_FRAGMENT]; 5030 if (sh) { 5031 lower_discard_flow(sh->ir); 5032 } 5033 } 5034 5035 if (prog->SeparateShader) 5036 disable_varying_optimizations_for_sso(prog); 5037 5038 /* Process UBOs */ 5039 if (!interstage_cross_validate_uniform_blocks(prog, false)) 5040 goto done; 5041 5042 /* Process SSBOs */ 5043 if (!interstage_cross_validate_uniform_blocks(prog, true)) 5044 goto done; 5045 5046 /* Do common optimization before assigning storage for attributes, 5047 * uniforms, and varyings. Later optimization could possibly make 5048 * some of that unused. 5049 */ 5050 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 5051 if (prog->_LinkedShaders[i] == NULL) 5052 continue; 5053 5054 detect_recursion_linked(prog, prog->_LinkedShaders[i]->ir); 5055 if (!prog->data->LinkStatus) 5056 goto done; 5057 5058 if (ctx->Const.ShaderCompilerOptions[i].LowerCombinedClipCullDistance) { 5059 lower_clip_cull_distance(prog, prog->_LinkedShaders[i]); 5060 } 5061 5062 if (ctx->Const.LowerTessLevel) { 5063 lower_tess_level(prog->_LinkedShaders[i]); 5064 } 5065 5066 /* Call opts before lowering const arrays to uniforms so we can const 5067 * propagate any elements accessed directly. 5068 */ 5069 linker_optimisation_loop(ctx, prog->_LinkedShaders[i]->ir, i); 5070 5071 /* Call opts after lowering const arrays to copy propagate things. */ 5072 if (lower_const_arrays_to_uniforms(prog->_LinkedShaders[i]->ir, i)) 5073 linker_optimisation_loop(ctx, prog->_LinkedShaders[i]->ir, i); 5074 5075 propagate_invariance(prog->_LinkedShaders[i]->ir); 5076 } 5077 5078 /* Validation for special cases where we allow sampler array indexing 5079 * with loop induction variable. This check emits a warning or error 5080 * depending if backend can handle dynamic indexing. 5081 */ 5082 if ((!prog->IsES && prog->data->Version < 130) || 5083 (prog->IsES && prog->data->Version < 300)) { 5084 if (!validate_sampler_array_indexing(ctx, prog)) 5085 goto done; 5086 } 5087 5088 /* Check and validate stream emissions in geometry shaders */ 5089 validate_geometry_shader_emissions(ctx, prog); 5090 5091 store_fragdepth_layout(prog); 5092 5093 if(!link_varyings_and_uniforms(first, last, ctx, prog, mem_ctx)) 5094 goto done; 5095 5096 /* Linking varyings can cause some extra, useless swizzles to be generated 5097 * due to packing and unpacking. 5098 */ 5099 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 5100 if (prog->_LinkedShaders[i] == NULL) 5101 continue; 5102 5103 optimize_swizzles(prog->_LinkedShaders[i]->ir); 5104 } 5105 5106 /* OpenGL ES < 3.1 requires that a vertex shader and a fragment shader both 5107 * be present in a linked program. GL_ARB_ES2_compatibility doesn't say 5108 * anything about shader linking when one of the shaders (vertex or 5109 * fragment shader) is absent. So, the extension shouldn't change the 5110 * behavior specified in GLSL specification. 5111 * 5112 * From OpenGL ES 3.1 specification (7.3 Program Objects): 5113 * "Linking can fail for a variety of reasons as specified in the 5114 * OpenGL ES Shading Language Specification, as well as any of the 5115 * following reasons: 5116 * 5117 * ... 5118 * 5119 * * program contains objects to form either a vertex shader or 5120 * fragment shader, and program is not separable, and does not 5121 * contain objects to form both a vertex shader and fragment 5122 * shader." 5123 * 5124 * However, the only scenario in 3.1+ where we don't require them both is 5125 * when we have a compute shader. For example: 5126 * 5127 * - No shaders is a link error. 5128 * - Geom or Tess without a Vertex shader is a link error which means we 5129 * always require a Vertex shader and hence a Fragment shader. 5130 * - Finally a Compute shader linked with any other stage is a link error. 5131 */ 5132 if (!prog->SeparateShader && ctx->API == API_OPENGLES2 && 5133 num_shaders[MESA_SHADER_COMPUTE] == 0) { 5134 if (prog->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) { 5135 linker_error(prog, "program lacks a vertex shader\n"); 5136 } else if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL) { 5137 linker_error(prog, "program lacks a fragment shader\n"); 5138 } 5139 } 5140 5141 done: 5142 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) { 5143 free(shader_list[i]); 5144 if (prog->_LinkedShaders[i] == NULL) 5145 continue; 5146 5147 /* Do a final validation step to make sure that the IR wasn't 5148 * invalidated by any modifications performed after intrastage linking. 5149 */ 5150 validate_ir_tree(prog->_LinkedShaders[i]->ir); 5151 5152 /* Retain any live IR, but trash the rest. */ 5153 reparent_ir(prog->_LinkedShaders[i]->ir, prog->_LinkedShaders[i]->ir); 5154 5155 /* The symbol table in the linked shaders may contain references to 5156 * variables that were removed (e.g., unused uniforms). Since it may 5157 * contain junk, there is no possible valid use. Delete it and set the 5158 * pointer to NULL. 5159 */ 5160 delete prog->_LinkedShaders[i]->symbols; 5161 prog->_LinkedShaders[i]->symbols = NULL; 5162 } 5163 5164 ralloc_free(mem_ctx); 5165 } 5166