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