2 * Copyright © 2010 Intel Corporation
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:
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
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.
26 * GLSL linker implementation
28 * Given a set of shaders that are to be linked to generate a final program,
29 * there are three distinct stages.
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
35 * - Undefined references in each shader are resolve to definitions in
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.
42 * The result, in the terminology of the GLSL spec, is a set of shader
43 * executables for each processing unit.
45 * After the first stage is complete, a series of semantic checks are performed
46 * on each of the shader executables.
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
53 * In the final stage individual shader executables are linked to create a
54 * complete exectuable.
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.
64 * \author Ian Romanick <ian.d.romanick@intel.com>
68 #include "main/core.h"
69 #include "glsl_symbol_table.h"
70 #include "glsl_parser_extras.h"
73 #include "program/hash_table.h"
75 #include "link_varyings.h"
76 #include "ir_optimization.h"
77 #include "ir_rvalue_visitor.h"
78 #include "ir_uniform.h"
80 #include "main/shaderobj.h"
81 #include "main/enums.h"
84 void linker_error(gl_shader_program
*, const char *, ...);
89 * Visitor that determines whether or not a variable is ever written.
91 class find_assignment_visitor
: public ir_hierarchical_visitor
{
93 find_assignment_visitor(const char *name
)
94 : name(name
), found(false)
99 virtual ir_visitor_status
visit_enter(ir_assignment
*ir
)
101 ir_variable
*const var
= ir
->lhs
->variable_referenced();
103 if (strcmp(name
, var
->name
) == 0) {
108 return visit_continue_with_parent
;
111 virtual ir_visitor_status
visit_enter(ir_call
*ir
)
113 foreach_two_lists(formal_node
, &ir
->callee
->parameters
,
114 actual_node
, &ir
->actual_parameters
) {
115 ir_rvalue
*param_rval
= (ir_rvalue
*) actual_node
;
116 ir_variable
*sig_param
= (ir_variable
*) formal_node
;
118 if (sig_param
->data
.mode
== ir_var_function_out
||
119 sig_param
->data
.mode
== ir_var_function_inout
) {
120 ir_variable
*var
= param_rval
->variable_referenced();
121 if (var
&& strcmp(name
, var
->name
) == 0) {
128 if (ir
->return_deref
!= NULL
) {
129 ir_variable
*const var
= ir
->return_deref
->variable_referenced();
131 if (strcmp(name
, var
->name
) == 0) {
137 return visit_continue_with_parent
;
140 bool variable_found()
146 const char *name
; /**< Find writes to a variable with this name. */
147 bool found
; /**< Was a write to the variable found? */
152 * Visitor that determines whether or not a variable is ever read.
154 class find_deref_visitor
: public ir_hierarchical_visitor
{
156 find_deref_visitor(const char *name
)
157 : name(name
), found(false)
162 virtual ir_visitor_status
visit(ir_dereference_variable
*ir
)
164 if (strcmp(this->name
, ir
->var
->name
) == 0) {
169 return visit_continue
;
172 bool variable_found() const
178 const char *name
; /**< Find writes to a variable with this name. */
179 bool found
; /**< Was a write to the variable found? */
183 class geom_array_resize_visitor
: public ir_hierarchical_visitor
{
185 unsigned num_vertices
;
186 gl_shader_program
*prog
;
188 geom_array_resize_visitor(unsigned num_vertices
, gl_shader_program
*prog
)
190 this->num_vertices
= num_vertices
;
194 virtual ~geom_array_resize_visitor()
199 virtual ir_visitor_status
visit(ir_variable
*var
)
201 if (!var
->type
->is_array() || var
->data
.mode
!= ir_var_shader_in
)
202 return visit_continue
;
204 unsigned size
= var
->type
->length
;
206 /* Generate a link error if the shader has declared this array with an
209 if (size
&& size
!= this->num_vertices
) {
210 linker_error(this->prog
, "size of array %s declared as %u, "
211 "but number of input vertices is %u\n",
212 var
->name
, size
, this->num_vertices
);
213 return visit_continue
;
216 /* Generate a link error if the shader attempts to access an input
217 * array using an index too large for its actual size assigned at link
220 if (var
->data
.max_array_access
>= this->num_vertices
) {
221 linker_error(this->prog
, "geometry shader accesses element %i of "
222 "%s, but only %i input vertices\n",
223 var
->data
.max_array_access
, var
->name
, this->num_vertices
);
224 return visit_continue
;
227 var
->type
= glsl_type::get_array_instance(var
->type
->fields
.array
,
229 var
->data
.max_array_access
= this->num_vertices
- 1;
231 return visit_continue
;
234 /* Dereferences of input variables need to be updated so that their type
235 * matches the newly assigned type of the variable they are accessing. */
236 virtual ir_visitor_status
visit(ir_dereference_variable
*ir
)
238 ir
->type
= ir
->var
->type
;
239 return visit_continue
;
242 /* Dereferences of 2D input arrays need to be updated so that their type
243 * matches the newly assigned type of the array they are accessing. */
244 virtual ir_visitor_status
visit_leave(ir_dereference_array
*ir
)
246 const glsl_type
*const vt
= ir
->array
->type
;
248 ir
->type
= vt
->fields
.array
;
249 return visit_continue
;
254 * Visitor that determines the highest stream id to which a (geometry) shader
255 * emits vertices. It also checks whether End{Stream}Primitive is ever called.
257 class find_emit_vertex_visitor
: public ir_hierarchical_visitor
{
259 find_emit_vertex_visitor(int max_allowed
)
260 : max_stream_allowed(max_allowed
),
261 invalid_stream_id(0),
262 invalid_stream_id_from_emit_vertex(false),
263 end_primitive_found(false),
264 uses_non_zero_stream(false)
269 virtual ir_visitor_status
visit_leave(ir_emit_vertex
*ir
)
271 int stream_id
= ir
->stream_id();
274 invalid_stream_id
= stream_id
;
275 invalid_stream_id_from_emit_vertex
= true;
279 if (stream_id
> max_stream_allowed
) {
280 invalid_stream_id
= stream_id
;
281 invalid_stream_id_from_emit_vertex
= true;
286 uses_non_zero_stream
= true;
288 return visit_continue
;
291 virtual ir_visitor_status
visit_leave(ir_end_primitive
*ir
)
293 end_primitive_found
= true;
295 int stream_id
= ir
->stream_id();
298 invalid_stream_id
= stream_id
;
299 invalid_stream_id_from_emit_vertex
= false;
303 if (stream_id
> max_stream_allowed
) {
304 invalid_stream_id
= stream_id
;
305 invalid_stream_id_from_emit_vertex
= false;
310 uses_non_zero_stream
= true;
312 return visit_continue
;
317 return invalid_stream_id
!= 0;
320 const char *error_func()
322 return invalid_stream_id_from_emit_vertex
?
323 "EmitStreamVertex" : "EndStreamPrimitive";
328 return invalid_stream_id
;
333 return uses_non_zero_stream
;
336 bool uses_end_primitive()
338 return end_primitive_found
;
342 int max_stream_allowed
;
343 int invalid_stream_id
;
344 bool invalid_stream_id_from_emit_vertex
;
345 bool end_primitive_found
;
346 bool uses_non_zero_stream
;
349 /* Class that finds array derefs and check if indexes are dynamic. */
350 class dynamic_sampler_array_indexing_visitor
: public ir_hierarchical_visitor
353 dynamic_sampler_array_indexing_visitor() :
354 dynamic_sampler_array_indexing(false)
358 ir_visitor_status
visit_enter(ir_dereference_array
*ir
)
360 if (!ir
->variable_referenced())
361 return visit_continue
;
363 if (!ir
->variable_referenced()->type
->contains_sampler())
364 return visit_continue
;
366 if (!ir
->array_index
->constant_expression_value()) {
367 dynamic_sampler_array_indexing
= true;
370 return visit_continue
;
373 bool uses_dynamic_sampler_array_indexing()
375 return dynamic_sampler_array_indexing
;
379 bool dynamic_sampler_array_indexing
;
382 } /* anonymous namespace */
385 linker_error(gl_shader_program
*prog
, const char *fmt
, ...)
389 ralloc_strcat(&prog
->InfoLog
, "error: ");
391 ralloc_vasprintf_append(&prog
->InfoLog
, fmt
, ap
);
394 prog
->LinkStatus
= false;
399 linker_warning(gl_shader_program
*prog
, const char *fmt
, ...)
403 ralloc_strcat(&prog
->InfoLog
, "warning: ");
405 ralloc_vasprintf_append(&prog
->InfoLog
, fmt
, ap
);
412 * Given a string identifying a program resource, break it into a base name
413 * and an optional array index in square brackets.
415 * If an array index is present, \c out_base_name_end is set to point to the
416 * "[" that precedes the array index, and the array index itself is returned
419 * If no array index is present (or if the array index is negative or
420 * mal-formed), \c out_base_name_end, is set to point to the null terminator
421 * at the end of the input string, and -1 is returned.
423 * Only the final array index is parsed; if the string contains other array
424 * indices (or structure field accesses), they are left in the base name.
426 * No attempt is made to check that the base name is properly formed;
427 * typically the caller will look up the base name in a hash table, so
428 * ill-formed base names simply turn into hash table lookup failures.
431 parse_program_resource_name(const GLchar
*name
,
432 const GLchar
**out_base_name_end
)
434 /* Section 7.3.1 ("Program Interfaces") of the OpenGL 4.3 spec says:
436 * "When an integer array element or block instance number is part of
437 * the name string, it will be specified in decimal form without a "+"
438 * or "-" sign or any extra leading zeroes. Additionally, the name
439 * string will not include white space anywhere in the string."
442 const size_t len
= strlen(name
);
443 *out_base_name_end
= name
+ len
;
445 if (len
== 0 || name
[len
-1] != ']')
448 /* Walk backwards over the string looking for a non-digit character. This
449 * had better be the opening bracket for an array index.
451 * Initially, i specifies the location of the ']'. Since the string may
452 * contain only the ']' charcater, walk backwards very carefully.
455 for (i
= len
- 1; (i
> 0) && isdigit(name
[i
-1]); --i
)
458 if ((i
== 0) || name
[i
-1] != '[')
461 long array_index
= strtol(&name
[i
], NULL
, 10);
465 /* Check for leading zero */
466 if (name
[i
] == '0' && name
[i
+1] != ']')
469 *out_base_name_end
= name
+ (i
- 1);
475 link_invalidate_variable_locations(exec_list
*ir
)
477 foreach_in_list(ir_instruction
, node
, ir
) {
478 ir_variable
*const var
= node
->as_variable();
483 /* Only assign locations for variables that lack an explicit location.
484 * Explicit locations are set for all built-in variables, generic vertex
485 * shader inputs (via layout(location=...)), and generic fragment shader
486 * outputs (also via layout(location=...)).
488 if (!var
->data
.explicit_location
) {
489 var
->data
.location
= -1;
490 var
->data
.location_frac
= 0;
493 /* ir_variable::is_unmatched_generic_inout is used by the linker while
494 * connecting outputs from one stage to inputs of the next stage.
496 * There are two implicit assumptions here. First, we assume that any
497 * built-in variable (i.e., non-generic in or out) will have
498 * explicit_location set. Second, we assume that any generic in or out
499 * will not have explicit_location set.
501 * This second assumption will only be valid until
502 * GL_ARB_separate_shader_objects is supported. When that extension is
503 * implemented, this function will need some modifications.
505 if (!var
->data
.explicit_location
) {
506 var
->data
.is_unmatched_generic_inout
= 1;
508 var
->data
.is_unmatched_generic_inout
= 0;
515 * Set UsesClipDistance and ClipDistanceArraySize based on the given shader.
517 * Also check for errors based on incorrect usage of gl_ClipVertex and
520 * Return false if an error was reported.
523 analyze_clip_usage(struct gl_shader_program
*prog
,
524 struct gl_shader
*shader
, GLboolean
*UsesClipDistance
,
525 GLuint
*ClipDistanceArraySize
)
527 *ClipDistanceArraySize
= 0;
529 if (!prog
->IsES
&& prog
->Version
>= 130) {
530 /* From section 7.1 (Vertex Shader Special Variables) of the
533 * "It is an error for a shader to statically write both
534 * gl_ClipVertex and gl_ClipDistance."
536 * This does not apply to GLSL ES shaders, since GLSL ES defines neither
537 * gl_ClipVertex nor gl_ClipDistance.
539 find_assignment_visitor
clip_vertex("gl_ClipVertex");
540 find_assignment_visitor
clip_distance("gl_ClipDistance");
542 clip_vertex
.run(shader
->ir
);
543 clip_distance
.run(shader
->ir
);
544 if (clip_vertex
.variable_found() && clip_distance
.variable_found()) {
545 linker_error(prog
, "%s shader writes to both `gl_ClipVertex' "
546 "and `gl_ClipDistance'\n",
547 _mesa_shader_stage_to_string(shader
->Stage
));
550 *UsesClipDistance
= clip_distance
.variable_found();
551 ir_variable
*clip_distance_var
=
552 shader
->symbols
->get_variable("gl_ClipDistance");
553 if (clip_distance_var
)
554 *ClipDistanceArraySize
= clip_distance_var
->type
->length
;
556 *UsesClipDistance
= false;
562 * Verify that a vertex shader executable meets all semantic requirements.
564 * Also sets prog->Vert.UsesClipDistance and prog->Vert.ClipDistanceArraySize
567 * \param shader Vertex shader executable to be verified
570 validate_vertex_shader_executable(struct gl_shader_program
*prog
,
571 struct gl_shader
*shader
)
576 /* From the GLSL 1.10 spec, page 48:
578 * "The variable gl_Position is available only in the vertex
579 * language and is intended for writing the homogeneous vertex
580 * position. All executions of a well-formed vertex shader
581 * executable must write a value into this variable. [...] The
582 * variable gl_Position is available only in the vertex
583 * language and is intended for writing the homogeneous vertex
584 * position. All executions of a well-formed vertex shader
585 * executable must write a value into this variable."
587 * while in GLSL 1.40 this text is changed to:
589 * "The variable gl_Position is available only in the vertex
590 * language and is intended for writing the homogeneous vertex
591 * position. It can be written at any time during shader
592 * execution. It may also be read back by a vertex shader
593 * after being written. This value will be used by primitive
594 * assembly, clipping, culling, and other fixed functionality
595 * operations, if present, that operate on primitives after
596 * vertex processing has occurred. Its value is undefined if
597 * the vertex shader executable does not write gl_Position."
599 * All GLSL ES Versions are similar to GLSL 1.40--failing to write to
600 * gl_Position is not an error.
602 if (prog
->Version
< (prog
->IsES
? 300 : 140)) {
603 find_assignment_visitor
find("gl_Position");
604 find
.run(shader
->ir
);
605 if (!find
.variable_found()) {
608 "vertex shader does not write to `gl_Position'."
609 "It's value is undefined. \n");
612 "vertex shader does not write to `gl_Position'. \n");
618 analyze_clip_usage(prog
, shader
, &prog
->Vert
.UsesClipDistance
,
619 &prog
->Vert
.ClipDistanceArraySize
);
624 * Verify that a fragment shader executable meets all semantic requirements
626 * \param shader Fragment shader executable to be verified
629 validate_fragment_shader_executable(struct gl_shader_program
*prog
,
630 struct gl_shader
*shader
)
635 find_assignment_visitor
frag_color("gl_FragColor");
636 find_assignment_visitor
frag_data("gl_FragData");
638 frag_color
.run(shader
->ir
);
639 frag_data
.run(shader
->ir
);
641 if (frag_color
.variable_found() && frag_data
.variable_found()) {
642 linker_error(prog
, "fragment shader writes to both "
643 "`gl_FragColor' and `gl_FragData'\n");
648 * Verify that a geometry shader executable meets all semantic requirements
650 * Also sets prog->Geom.VerticesIn, prog->Geom.UsesClipDistance, and
651 * prog->Geom.ClipDistanceArraySize as a side effect.
653 * \param shader Geometry shader executable to be verified
656 validate_geometry_shader_executable(struct gl_shader_program
*prog
,
657 struct gl_shader
*shader
)
662 unsigned num_vertices
= vertices_per_prim(prog
->Geom
.InputType
);
663 prog
->Geom
.VerticesIn
= num_vertices
;
665 analyze_clip_usage(prog
, shader
, &prog
->Geom
.UsesClipDistance
,
666 &prog
->Geom
.ClipDistanceArraySize
);
670 * Check if geometry shaders emit to non-zero streams and do corresponding
674 validate_geometry_shader_emissions(struct gl_context
*ctx
,
675 struct gl_shader_program
*prog
)
677 if (prog
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
678 find_emit_vertex_visitor
emit_vertex(ctx
->Const
.MaxVertexStreams
- 1);
679 emit_vertex
.run(prog
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->ir
);
680 if (emit_vertex
.error()) {
681 linker_error(prog
, "Invalid call %s(%d). Accepted values for the "
682 "stream parameter are in the range [0, %d].\n",
683 emit_vertex
.error_func(),
684 emit_vertex
.error_stream(),
685 ctx
->Const
.MaxVertexStreams
- 1);
687 prog
->Geom
.UsesStreams
= emit_vertex
.uses_streams();
688 prog
->Geom
.UsesEndPrimitive
= emit_vertex
.uses_end_primitive();
690 /* From the ARB_gpu_shader5 spec:
692 * "Multiple vertex streams are supported only if the output primitive
693 * type is declared to be "points". A program will fail to link if it
694 * contains a geometry shader calling EmitStreamVertex() or
695 * EndStreamPrimitive() if its output primitive type is not "points".
697 * However, in the same spec:
699 * "The function EmitVertex() is equivalent to calling EmitStreamVertex()
700 * with <stream> set to zero."
704 * "The function EndPrimitive() is equivalent to calling
705 * EndStreamPrimitive() with <stream> set to zero."
707 * Since we can call EmitVertex() and EndPrimitive() when we output
708 * primitives other than points, calling EmitStreamVertex(0) or
709 * EmitEndPrimitive(0) should not produce errors. This it also what Nvidia
710 * does. Currently we only set prog->Geom.UsesStreams to TRUE when
711 * EmitStreamVertex() or EmitEndPrimitive() are called with a non-zero
714 if (prog
->Geom
.UsesStreams
&& prog
->Geom
.OutputType
!= GL_POINTS
) {
715 linker_error(prog
, "EmitStreamVertex(n) and EndStreamPrimitive(n) "
716 "with n>0 requires point output\n");
722 validate_intrastage_arrays(struct gl_shader_program
*prog
,
723 ir_variable
*const var
,
724 ir_variable
*const existing
)
726 /* Consider the types to be "the same" if both types are arrays
727 * of the same type and one of the arrays is implicitly sized.
728 * In addition, set the type of the linked variable to the
729 * explicitly sized array.
731 if (var
->type
->is_array() && existing
->type
->is_array() &&
732 (var
->type
->fields
.array
== existing
->type
->fields
.array
) &&
733 ((var
->type
->length
== 0)|| (existing
->type
->length
== 0))) {
734 if (var
->type
->length
!= 0) {
735 if (var
->type
->length
<= existing
->data
.max_array_access
) {
736 linker_error(prog
, "%s `%s' declared as type "
737 "`%s' but outermost dimension has an index"
740 var
->name
, var
->type
->name
,
741 existing
->data
.max_array_access
);
743 existing
->type
= var
->type
;
745 } else if (existing
->type
->length
!= 0) {
746 if(existing
->type
->length
<= var
->data
.max_array_access
) {
747 linker_error(prog
, "%s `%s' declared as type "
748 "`%s' but outermost dimension has an index"
751 var
->name
, existing
->type
->name
,
752 var
->data
.max_array_access
);
762 * Perform validation of global variables used across multiple shaders
765 cross_validate_globals(struct gl_shader_program
*prog
,
766 struct gl_shader
**shader_list
,
767 unsigned num_shaders
,
770 /* Examine all of the uniforms in all of the shaders and cross validate
773 glsl_symbol_table variables
;
774 for (unsigned i
= 0; i
< num_shaders
; i
++) {
775 if (shader_list
[i
] == NULL
)
778 foreach_in_list(ir_instruction
, node
, shader_list
[i
]->ir
) {
779 ir_variable
*const var
= node
->as_variable();
784 if (uniforms_only
&& (var
->data
.mode
!= ir_var_uniform
&& var
->data
.mode
!= ir_var_shader_storage
))
787 /* Don't cross validate temporaries that are at global scope. These
788 * will eventually get pulled into the shaders 'main'.
790 if (var
->data
.mode
== ir_var_temporary
)
793 /* If a global with this name has already been seen, verify that the
794 * new instance has the same type. In addition, if the globals have
795 * initializers, the values of the initializers must be the same.
797 ir_variable
*const existing
= variables
.get_variable(var
->name
);
798 if (existing
!= NULL
) {
799 /* Check if types match. Interface blocks have some special
800 * rules so we handle those elsewhere.
802 if (var
->type
!= existing
->type
&&
803 !var
->is_interface_instance()) {
804 if (!validate_intrastage_arrays(prog
, var
, existing
)) {
805 if (var
->type
->is_record() && existing
->type
->is_record()
806 && existing
->type
->record_compare(var
->type
)) {
807 existing
->type
= var
->type
;
809 linker_error(prog
, "%s `%s' declared as type "
810 "`%s' and type `%s'\n",
812 var
->name
, var
->type
->name
,
813 existing
->type
->name
);
819 if (var
->data
.explicit_location
) {
820 if (existing
->data
.explicit_location
821 && (var
->data
.location
!= existing
->data
.location
)) {
822 linker_error(prog
, "explicit locations for %s "
823 "`%s' have differing values\n",
824 mode_string(var
), var
->name
);
828 existing
->data
.location
= var
->data
.location
;
829 existing
->data
.explicit_location
= true;
832 /* From the GLSL 4.20 specification:
833 * "A link error will result if two compilation units in a program
834 * specify different integer-constant bindings for the same
835 * opaque-uniform name. However, it is not an error to specify a
836 * binding on some but not all declarations for the same name"
838 if (var
->data
.explicit_binding
) {
839 if (existing
->data
.explicit_binding
&&
840 var
->data
.binding
!= existing
->data
.binding
) {
841 linker_error(prog
, "explicit bindings for %s "
842 "`%s' have differing values\n",
843 mode_string(var
), var
->name
);
847 existing
->data
.binding
= var
->data
.binding
;
848 existing
->data
.explicit_binding
= true;
851 if (var
->type
->contains_atomic() &&
852 var
->data
.atomic
.offset
!= existing
->data
.atomic
.offset
) {
853 linker_error(prog
, "offset specifications for %s "
854 "`%s' have differing values\n",
855 mode_string(var
), var
->name
);
859 /* Validate layout qualifiers for gl_FragDepth.
861 * From the AMD/ARB_conservative_depth specs:
863 * "If gl_FragDepth is redeclared in any fragment shader in a
864 * program, it must be redeclared in all fragment shaders in
865 * that program that have static assignments to
866 * gl_FragDepth. All redeclarations of gl_FragDepth in all
867 * fragment shaders in a single program must have the same set
870 if (strcmp(var
->name
, "gl_FragDepth") == 0) {
871 bool layout_declared
= var
->data
.depth_layout
!= ir_depth_layout_none
;
872 bool layout_differs
=
873 var
->data
.depth_layout
!= existing
->data
.depth_layout
;
875 if (layout_declared
&& layout_differs
) {
877 "All redeclarations of gl_FragDepth in all "
878 "fragment shaders in a single program must have "
879 "the same set of qualifiers.\n");
882 if (var
->data
.used
&& layout_differs
) {
884 "If gl_FragDepth is redeclared with a layout "
885 "qualifier in any fragment shader, it must be "
886 "redeclared with the same layout qualifier in "
887 "all fragment shaders that have assignments to "
892 /* Page 35 (page 41 of the PDF) of the GLSL 4.20 spec says:
894 * "If a shared global has multiple initializers, the
895 * initializers must all be constant expressions, and they
896 * must all have the same value. Otherwise, a link error will
897 * result. (A shared global having only one initializer does
898 * not require that initializer to be a constant expression.)"
900 * Previous to 4.20 the GLSL spec simply said that initializers
901 * must have the same value. In this case of non-constant
902 * initializers, this was impossible to determine. As a result,
903 * no vendor actually implemented that behavior. The 4.20
904 * behavior matches the implemented behavior of at least one other
905 * vendor, so we'll implement that for all GLSL versions.
907 if (var
->constant_initializer
!= NULL
) {
908 if (existing
->constant_initializer
!= NULL
) {
909 if (!var
->constant_initializer
->has_value(existing
->constant_initializer
)) {
910 linker_error(prog
, "initializers for %s "
911 "`%s' have differing values\n",
912 mode_string(var
), var
->name
);
916 /* If the first-seen instance of a particular uniform did not
917 * have an initializer but a later instance does, copy the
918 * initializer to the version stored in the symbol table.
920 /* FINISHME: This is wrong. The constant_value field should
921 * FINISHME: not be modified! Imagine a case where a shader
922 * FINISHME: without an initializer is linked in two different
923 * FINISHME: programs with shaders that have differing
924 * FINISHME: initializers. Linking with the first will
925 * FINISHME: modify the shader, and linking with the second
926 * FINISHME: will fail.
928 existing
->constant_initializer
=
929 var
->constant_initializer
->clone(ralloc_parent(existing
),
934 if (var
->data
.has_initializer
) {
935 if (existing
->data
.has_initializer
936 && (var
->constant_initializer
== NULL
937 || existing
->constant_initializer
== NULL
)) {
939 "shared global variable `%s' has multiple "
940 "non-constant initializers.\n",
945 /* Some instance had an initializer, so keep track of that. In
946 * this location, all sorts of initializers (constant or
947 * otherwise) will propagate the existence to the variable
948 * stored in the symbol table.
950 existing
->data
.has_initializer
= true;
953 if (existing
->data
.invariant
!= var
->data
.invariant
) {
954 linker_error(prog
, "declarations for %s `%s' have "
955 "mismatching invariant qualifiers\n",
956 mode_string(var
), var
->name
);
959 if (existing
->data
.centroid
!= var
->data
.centroid
) {
960 linker_error(prog
, "declarations for %s `%s' have "
961 "mismatching centroid qualifiers\n",
962 mode_string(var
), var
->name
);
965 if (existing
->data
.sample
!= var
->data
.sample
) {
966 linker_error(prog
, "declarations for %s `%s` have "
967 "mismatching sample qualifiers\n",
968 mode_string(var
), var
->name
);
972 variables
.add_variable(var
);
979 * Perform validation of uniforms used across multiple shader stages
982 cross_validate_uniforms(struct gl_shader_program
*prog
)
984 cross_validate_globals(prog
, prog
->_LinkedShaders
,
985 MESA_SHADER_STAGES
, true);
989 * Accumulates the array of prog->UniformBlocks and checks that all
990 * definitons of blocks agree on their contents.
993 interstage_cross_validate_uniform_blocks(struct gl_shader_program
*prog
)
995 unsigned max_num_uniform_blocks
= 0;
996 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
997 if (prog
->_LinkedShaders
[i
])
998 max_num_uniform_blocks
+= prog
->_LinkedShaders
[i
]->NumUniformBlocks
;
1001 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1002 struct gl_shader
*sh
= prog
->_LinkedShaders
[i
];
1004 prog
->UniformBlockStageIndex
[i
] = ralloc_array(prog
, int,
1005 max_num_uniform_blocks
);
1006 for (unsigned int j
= 0; j
< max_num_uniform_blocks
; j
++)
1007 prog
->UniformBlockStageIndex
[i
][j
] = -1;
1012 for (unsigned int j
= 0; j
< sh
->NumUniformBlocks
; j
++) {
1013 int index
= link_cross_validate_uniform_block(prog
,
1014 &prog
->UniformBlocks
,
1015 &prog
->NumUniformBlocks
,
1016 &sh
->UniformBlocks
[j
]);
1019 linker_error(prog
, "uniform block `%s' has mismatching definitions\n",
1020 sh
->UniformBlocks
[j
].Name
);
1024 prog
->UniformBlockStageIndex
[i
][index
] = j
;
1033 * Populates a shaders symbol table with all global declarations
1036 populate_symbol_table(gl_shader
*sh
)
1038 sh
->symbols
= new(sh
) glsl_symbol_table
;
1040 foreach_in_list(ir_instruction
, inst
, sh
->ir
) {
1044 if ((func
= inst
->as_function()) != NULL
) {
1045 sh
->symbols
->add_function(func
);
1046 } else if ((var
= inst
->as_variable()) != NULL
) {
1047 if (var
->data
.mode
!= ir_var_temporary
)
1048 sh
->symbols
->add_variable(var
);
1055 * Remap variables referenced in an instruction tree
1057 * This is used when instruction trees are cloned from one shader and placed in
1058 * another. These trees will contain references to \c ir_variable nodes that
1059 * do not exist in the target shader. This function finds these \c ir_variable
1060 * references and replaces the references with matching variables in the target
1063 * If there is no matching variable in the target shader, a clone of the
1064 * \c ir_variable is made and added to the target shader. The new variable is
1065 * added to \b both the instruction stream and the symbol table.
1067 * \param inst IR tree that is to be processed.
1068 * \param symbols Symbol table containing global scope symbols in the
1070 * \param instructions Instruction stream where new variable declarations
1074 remap_variables(ir_instruction
*inst
, struct gl_shader
*target
,
1077 class remap_visitor
: public ir_hierarchical_visitor
{
1079 remap_visitor(struct gl_shader
*target
,
1082 this->target
= target
;
1083 this->symbols
= target
->symbols
;
1084 this->instructions
= target
->ir
;
1085 this->temps
= temps
;
1088 virtual ir_visitor_status
visit(ir_dereference_variable
*ir
)
1090 if (ir
->var
->data
.mode
== ir_var_temporary
) {
1091 ir_variable
*var
= (ir_variable
*) hash_table_find(temps
, ir
->var
);
1093 assert(var
!= NULL
);
1095 return visit_continue
;
1098 ir_variable
*const existing
=
1099 this->symbols
->get_variable(ir
->var
->name
);
1100 if (existing
!= NULL
)
1103 ir_variable
*copy
= ir
->var
->clone(this->target
, NULL
);
1105 this->symbols
->add_variable(copy
);
1106 this->instructions
->push_head(copy
);
1110 return visit_continue
;
1114 struct gl_shader
*target
;
1115 glsl_symbol_table
*symbols
;
1116 exec_list
*instructions
;
1120 remap_visitor
v(target
, temps
);
1127 * Move non-declarations from one instruction stream to another
1129 * The intended usage pattern of this function is to pass the pointer to the
1130 * head sentinel of a list (i.e., a pointer to the list cast to an \c exec_node
1131 * pointer) for \c last and \c false for \c make_copies on the first
1132 * call. Successive calls pass the return value of the previous call for
1133 * \c last and \c true for \c make_copies.
1135 * \param instructions Source instruction stream
1136 * \param last Instruction after which new instructions should be
1137 * inserted in the target instruction stream
1138 * \param make_copies Flag selecting whether instructions in \c instructions
1139 * should be copied (via \c ir_instruction::clone) into the
1140 * target list or moved.
1143 * The new "last" instruction in the target instruction stream. This pointer
1144 * is suitable for use as the \c last parameter of a later call to this
1148 move_non_declarations(exec_list
*instructions
, exec_node
*last
,
1149 bool make_copies
, gl_shader
*target
)
1151 hash_table
*temps
= NULL
;
1154 temps
= hash_table_ctor(0, hash_table_pointer_hash
,
1155 hash_table_pointer_compare
);
1157 foreach_in_list_safe(ir_instruction
, inst
, instructions
) {
1158 if (inst
->as_function())
1161 ir_variable
*var
= inst
->as_variable();
1162 if ((var
!= NULL
) && (var
->data
.mode
!= ir_var_temporary
))
1165 assert(inst
->as_assignment()
1167 || inst
->as_if() /* for initializers with the ?: operator */
1168 || ((var
!= NULL
) && (var
->data
.mode
== ir_var_temporary
)));
1171 inst
= inst
->clone(target
, NULL
);
1174 hash_table_insert(temps
, inst
, var
);
1176 remap_variables(inst
, target
, temps
);
1181 last
->insert_after(inst
);
1186 hash_table_dtor(temps
);
1192 * Get the function signature for main from a shader
1194 ir_function_signature
*
1195 link_get_main_function_signature(gl_shader
*sh
)
1197 ir_function
*const f
= sh
->symbols
->get_function("main");
1199 exec_list void_parameters
;
1201 /* Look for the 'void main()' signature and ensure that it's defined.
1202 * This keeps the linker from accidentally pick a shader that just
1203 * contains a prototype for main.
1205 * We don't have to check for multiple definitions of main (in multiple
1206 * shaders) because that would have already been caught above.
1208 ir_function_signature
*sig
=
1209 f
->matching_signature(NULL
, &void_parameters
, false);
1210 if ((sig
!= NULL
) && sig
->is_defined
) {
1220 * This class is only used in link_intrastage_shaders() below but declaring
1221 * it inside that function leads to compiler warnings with some versions of
1224 class array_sizing_visitor
: public ir_hierarchical_visitor
{
1226 array_sizing_visitor()
1227 : mem_ctx(ralloc_context(NULL
)),
1228 unnamed_interfaces(hash_table_ctor(0, hash_table_pointer_hash
,
1229 hash_table_pointer_compare
))
1233 ~array_sizing_visitor()
1235 hash_table_dtor(this->unnamed_interfaces
);
1236 ralloc_free(this->mem_ctx
);
1239 virtual ir_visitor_status
visit(ir_variable
*var
)
1241 fixup_type(&var
->type
, var
->data
.max_array_access
);
1242 if (var
->type
->is_interface()) {
1243 if (interface_contains_unsized_arrays(var
->type
)) {
1244 const glsl_type
*new_type
=
1245 resize_interface_members(var
->type
,
1246 var
->get_max_ifc_array_access());
1247 var
->type
= new_type
;
1248 var
->change_interface_type(new_type
);
1250 } else if (var
->type
->is_array() &&
1251 var
->type
->fields
.array
->is_interface()) {
1252 if (interface_contains_unsized_arrays(var
->type
->fields
.array
)) {
1253 const glsl_type
*new_type
=
1254 resize_interface_members(var
->type
->fields
.array
,
1255 var
->get_max_ifc_array_access());
1256 var
->change_interface_type(new_type
);
1257 var
->type
= update_interface_members_array(var
->type
, new_type
);
1259 } else if (const glsl_type
*ifc_type
= var
->get_interface_type()) {
1260 /* Store a pointer to the variable in the unnamed_interfaces
1263 ir_variable
**interface_vars
= (ir_variable
**)
1264 hash_table_find(this->unnamed_interfaces
, ifc_type
);
1265 if (interface_vars
== NULL
) {
1266 interface_vars
= rzalloc_array(mem_ctx
, ir_variable
*,
1268 hash_table_insert(this->unnamed_interfaces
, interface_vars
,
1271 unsigned index
= ifc_type
->field_index(var
->name
);
1272 assert(index
< ifc_type
->length
);
1273 assert(interface_vars
[index
] == NULL
);
1274 interface_vars
[index
] = var
;
1276 return visit_continue
;
1280 * For each unnamed interface block that was discovered while running the
1281 * visitor, adjust the interface type to reflect the newly assigned array
1282 * sizes, and fix up the ir_variable nodes to point to the new interface
1285 void fixup_unnamed_interface_types()
1287 hash_table_call_foreach(this->unnamed_interfaces
,
1288 fixup_unnamed_interface_type
, NULL
);
1293 * If the type pointed to by \c type represents an unsized array, replace
1294 * it with a sized array whose size is determined by max_array_access.
1296 static void fixup_type(const glsl_type
**type
, unsigned max_array_access
)
1298 if ((*type
)->is_unsized_array()) {
1299 *type
= glsl_type::get_array_instance((*type
)->fields
.array
,
1300 max_array_access
+ 1);
1301 assert(*type
!= NULL
);
1305 static const glsl_type
*
1306 update_interface_members_array(const glsl_type
*type
,
1307 const glsl_type
*new_interface_type
)
1309 const glsl_type
*element_type
= type
->fields
.array
;
1310 if (element_type
->is_array()) {
1311 const glsl_type
*new_array_type
=
1312 update_interface_members_array(element_type
, new_interface_type
);
1313 return glsl_type::get_array_instance(new_array_type
, type
->length
);
1315 return glsl_type::get_array_instance(new_interface_type
,
1321 * Determine whether the given interface type contains unsized arrays (if
1322 * it doesn't, array_sizing_visitor doesn't need to process it).
1324 static bool interface_contains_unsized_arrays(const glsl_type
*type
)
1326 for (unsigned i
= 0; i
< type
->length
; i
++) {
1327 const glsl_type
*elem_type
= type
->fields
.structure
[i
].type
;
1328 if (elem_type
->is_unsized_array())
1335 * Create a new interface type based on the given type, with unsized arrays
1336 * replaced by sized arrays whose size is determined by
1337 * max_ifc_array_access.
1339 static const glsl_type
*
1340 resize_interface_members(const glsl_type
*type
,
1341 const unsigned *max_ifc_array_access
)
1343 unsigned num_fields
= type
->length
;
1344 glsl_struct_field
*fields
= new glsl_struct_field
[num_fields
];
1345 memcpy(fields
, type
->fields
.structure
,
1346 num_fields
* sizeof(*fields
));
1347 for (unsigned i
= 0; i
< num_fields
; i
++) {
1348 fixup_type(&fields
[i
].type
, max_ifc_array_access
[i
]);
1350 glsl_interface_packing packing
=
1351 (glsl_interface_packing
) type
->interface_packing
;
1352 const glsl_type
*new_ifc_type
=
1353 glsl_type::get_interface_instance(fields
, num_fields
,
1354 packing
, type
->name
);
1356 return new_ifc_type
;
1359 static void fixup_unnamed_interface_type(const void *key
, void *data
,
1362 const glsl_type
*ifc_type
= (const glsl_type
*) key
;
1363 ir_variable
**interface_vars
= (ir_variable
**) data
;
1364 unsigned num_fields
= ifc_type
->length
;
1365 glsl_struct_field
*fields
= new glsl_struct_field
[num_fields
];
1366 memcpy(fields
, ifc_type
->fields
.structure
,
1367 num_fields
* sizeof(*fields
));
1368 bool interface_type_changed
= false;
1369 for (unsigned i
= 0; i
< num_fields
; i
++) {
1370 if (interface_vars
[i
] != NULL
&&
1371 fields
[i
].type
!= interface_vars
[i
]->type
) {
1372 fields
[i
].type
= interface_vars
[i
]->type
;
1373 interface_type_changed
= true;
1376 if (!interface_type_changed
) {
1380 glsl_interface_packing packing
=
1381 (glsl_interface_packing
) ifc_type
->interface_packing
;
1382 const glsl_type
*new_ifc_type
=
1383 glsl_type::get_interface_instance(fields
, num_fields
, packing
,
1386 for (unsigned i
= 0; i
< num_fields
; i
++) {
1387 if (interface_vars
[i
] != NULL
)
1388 interface_vars
[i
]->change_interface_type(new_ifc_type
);
1393 * Memory context used to allocate the data in \c unnamed_interfaces.
1398 * Hash table from const glsl_type * to an array of ir_variable *'s
1399 * pointing to the ir_variables constituting each unnamed interface block.
1401 hash_table
*unnamed_interfaces
;
1405 * Performs the cross-validation of layout qualifiers specified in
1406 * redeclaration of gl_FragCoord for the attached fragment shaders,
1407 * and propagates them to the linked FS and linked shader program.
1410 link_fs_input_layout_qualifiers(struct gl_shader_program
*prog
,
1411 struct gl_shader
*linked_shader
,
1412 struct gl_shader
**shader_list
,
1413 unsigned num_shaders
)
1415 linked_shader
->redeclares_gl_fragcoord
= false;
1416 linked_shader
->uses_gl_fragcoord
= false;
1417 linked_shader
->origin_upper_left
= false;
1418 linked_shader
->pixel_center_integer
= false;
1420 if (linked_shader
->Stage
!= MESA_SHADER_FRAGMENT
||
1421 (prog
->Version
< 150 && !prog
->ARB_fragment_coord_conventions_enable
))
1424 for (unsigned i
= 0; i
< num_shaders
; i
++) {
1425 struct gl_shader
*shader
= shader_list
[i
];
1426 /* From the GLSL 1.50 spec, page 39:
1428 * "If gl_FragCoord is redeclared in any fragment shader in a program,
1429 * it must be redeclared in all the fragment shaders in that program
1430 * that have a static use gl_FragCoord."
1432 if ((linked_shader
->redeclares_gl_fragcoord
1433 && !shader
->redeclares_gl_fragcoord
1434 && shader
->uses_gl_fragcoord
)
1435 || (shader
->redeclares_gl_fragcoord
1436 && !linked_shader
->redeclares_gl_fragcoord
1437 && linked_shader
->uses_gl_fragcoord
)) {
1438 linker_error(prog
, "fragment shader defined with conflicting "
1439 "layout qualifiers for gl_FragCoord\n");
1442 /* From the GLSL 1.50 spec, page 39:
1444 * "All redeclarations of gl_FragCoord in all fragment shaders in a
1445 * single program must have the same set of qualifiers."
1447 if (linked_shader
->redeclares_gl_fragcoord
&& shader
->redeclares_gl_fragcoord
1448 && (shader
->origin_upper_left
!= linked_shader
->origin_upper_left
1449 || shader
->pixel_center_integer
!= linked_shader
->pixel_center_integer
)) {
1450 linker_error(prog
, "fragment shader defined with conflicting "
1451 "layout qualifiers for gl_FragCoord\n");
1454 /* Update the linked shader state. Note that uses_gl_fragcoord should
1455 * accumulate the results. The other values should replace. If there
1456 * are multiple redeclarations, all the fields except uses_gl_fragcoord
1457 * are already known to be the same.
1459 if (shader
->redeclares_gl_fragcoord
|| shader
->uses_gl_fragcoord
) {
1460 linked_shader
->redeclares_gl_fragcoord
=
1461 shader
->redeclares_gl_fragcoord
;
1462 linked_shader
->uses_gl_fragcoord
= linked_shader
->uses_gl_fragcoord
1463 || shader
->uses_gl_fragcoord
;
1464 linked_shader
->origin_upper_left
= shader
->origin_upper_left
;
1465 linked_shader
->pixel_center_integer
= shader
->pixel_center_integer
;
1468 linked_shader
->EarlyFragmentTests
|= shader
->EarlyFragmentTests
;
1473 * Performs the cross-validation of geometry shader max_vertices and
1474 * primitive type layout qualifiers for the attached geometry shaders,
1475 * and propagates them to the linked GS and linked shader program.
1478 link_gs_inout_layout_qualifiers(struct gl_shader_program
*prog
,
1479 struct gl_shader
*linked_shader
,
1480 struct gl_shader
**shader_list
,
1481 unsigned num_shaders
)
1483 linked_shader
->Geom
.VerticesOut
= 0;
1484 linked_shader
->Geom
.Invocations
= 0;
1485 linked_shader
->Geom
.InputType
= PRIM_UNKNOWN
;
1486 linked_shader
->Geom
.OutputType
= PRIM_UNKNOWN
;
1488 /* No in/out qualifiers defined for anything but GLSL 1.50+
1489 * geometry shaders so far.
1491 if (linked_shader
->Stage
!= MESA_SHADER_GEOMETRY
|| prog
->Version
< 150)
1494 /* From the GLSL 1.50 spec, page 46:
1496 * "All geometry shader output layout declarations in a program
1497 * must declare the same layout and same value for
1498 * max_vertices. There must be at least one geometry output
1499 * layout declaration somewhere in a program, but not all
1500 * geometry shaders (compilation units) are required to
1504 for (unsigned i
= 0; i
< num_shaders
; i
++) {
1505 struct gl_shader
*shader
= shader_list
[i
];
1507 if (shader
->Geom
.InputType
!= PRIM_UNKNOWN
) {
1508 if (linked_shader
->Geom
.InputType
!= PRIM_UNKNOWN
&&
1509 linked_shader
->Geom
.InputType
!= shader
->Geom
.InputType
) {
1510 linker_error(prog
, "geometry shader defined with conflicting "
1514 linked_shader
->Geom
.InputType
= shader
->Geom
.InputType
;
1517 if (shader
->Geom
.OutputType
!= PRIM_UNKNOWN
) {
1518 if (linked_shader
->Geom
.OutputType
!= PRIM_UNKNOWN
&&
1519 linked_shader
->Geom
.OutputType
!= shader
->Geom
.OutputType
) {
1520 linker_error(prog
, "geometry shader defined with conflicting "
1524 linked_shader
->Geom
.OutputType
= shader
->Geom
.OutputType
;
1527 if (shader
->Geom
.VerticesOut
!= 0) {
1528 if (linked_shader
->Geom
.VerticesOut
!= 0 &&
1529 linked_shader
->Geom
.VerticesOut
!= shader
->Geom
.VerticesOut
) {
1530 linker_error(prog
, "geometry shader defined with conflicting "
1531 "output vertex count (%d and %d)\n",
1532 linked_shader
->Geom
.VerticesOut
,
1533 shader
->Geom
.VerticesOut
);
1536 linked_shader
->Geom
.VerticesOut
= shader
->Geom
.VerticesOut
;
1539 if (shader
->Geom
.Invocations
!= 0) {
1540 if (linked_shader
->Geom
.Invocations
!= 0 &&
1541 linked_shader
->Geom
.Invocations
!= shader
->Geom
.Invocations
) {
1542 linker_error(prog
, "geometry shader defined with conflicting "
1543 "invocation count (%d and %d)\n",
1544 linked_shader
->Geom
.Invocations
,
1545 shader
->Geom
.Invocations
);
1548 linked_shader
->Geom
.Invocations
= shader
->Geom
.Invocations
;
1552 /* Just do the intrastage -> interstage propagation right now,
1553 * since we already know we're in the right type of shader program
1556 if (linked_shader
->Geom
.InputType
== PRIM_UNKNOWN
) {
1558 "geometry shader didn't declare primitive input type\n");
1561 prog
->Geom
.InputType
= linked_shader
->Geom
.InputType
;
1563 if (linked_shader
->Geom
.OutputType
== PRIM_UNKNOWN
) {
1565 "geometry shader didn't declare primitive output type\n");
1568 prog
->Geom
.OutputType
= linked_shader
->Geom
.OutputType
;
1570 if (linked_shader
->Geom
.VerticesOut
== 0) {
1572 "geometry shader didn't declare max_vertices\n");
1575 prog
->Geom
.VerticesOut
= linked_shader
->Geom
.VerticesOut
;
1577 if (linked_shader
->Geom
.Invocations
== 0)
1578 linked_shader
->Geom
.Invocations
= 1;
1580 prog
->Geom
.Invocations
= linked_shader
->Geom
.Invocations
;
1585 * Perform cross-validation of compute shader local_size_{x,y,z} layout
1586 * qualifiers for the attached compute shaders, and propagate them to the
1587 * linked CS and linked shader program.
1590 link_cs_input_layout_qualifiers(struct gl_shader_program
*prog
,
1591 struct gl_shader
*linked_shader
,
1592 struct gl_shader
**shader_list
,
1593 unsigned num_shaders
)
1595 for (int i
= 0; i
< 3; i
++)
1596 linked_shader
->Comp
.LocalSize
[i
] = 0;
1598 /* This function is called for all shader stages, but it only has an effect
1599 * for compute shaders.
1601 if (linked_shader
->Stage
!= MESA_SHADER_COMPUTE
)
1604 /* From the ARB_compute_shader spec, in the section describing local size
1607 * If multiple compute shaders attached to a single program object
1608 * declare local work-group size, the declarations must be identical;
1609 * otherwise a link-time error results. Furthermore, if a program
1610 * object contains any compute shaders, at least one must contain an
1611 * input layout qualifier specifying the local work sizes of the
1612 * program, or a link-time error will occur.
1614 for (unsigned sh
= 0; sh
< num_shaders
; sh
++) {
1615 struct gl_shader
*shader
= shader_list
[sh
];
1617 if (shader
->Comp
.LocalSize
[0] != 0) {
1618 if (linked_shader
->Comp
.LocalSize
[0] != 0) {
1619 for (int i
= 0; i
< 3; i
++) {
1620 if (linked_shader
->Comp
.LocalSize
[i
] !=
1621 shader
->Comp
.LocalSize
[i
]) {
1622 linker_error(prog
, "compute shader defined with conflicting "
1628 for (int i
= 0; i
< 3; i
++)
1629 linked_shader
->Comp
.LocalSize
[i
] = shader
->Comp
.LocalSize
[i
];
1633 /* Just do the intrastage -> interstage propagation right now,
1634 * since we already know we're in the right type of shader program
1637 if (linked_shader
->Comp
.LocalSize
[0] == 0) {
1638 linker_error(prog
, "compute shader didn't declare local size\n");
1641 for (int i
= 0; i
< 3; i
++)
1642 prog
->Comp
.LocalSize
[i
] = linked_shader
->Comp
.LocalSize
[i
];
1647 * Combine a group of shaders for a single stage to generate a linked shader
1650 * If this function is supplied a single shader, it is cloned, and the new
1651 * shader is returned.
1653 static struct gl_shader
*
1654 link_intrastage_shaders(void *mem_ctx
,
1655 struct gl_context
*ctx
,
1656 struct gl_shader_program
*prog
,
1657 struct gl_shader
**shader_list
,
1658 unsigned num_shaders
)
1660 struct gl_uniform_block
*uniform_blocks
= NULL
;
1662 /* Check that global variables defined in multiple shaders are consistent.
1664 cross_validate_globals(prog
, shader_list
, num_shaders
, false);
1665 if (!prog
->LinkStatus
)
1668 /* Check that interface blocks defined in multiple shaders are consistent.
1670 validate_intrastage_interface_blocks(prog
, (const gl_shader
**)shader_list
,
1672 if (!prog
->LinkStatus
)
1675 /* Link up uniform blocks defined within this stage. */
1676 const unsigned num_uniform_blocks
=
1677 link_uniform_blocks(mem_ctx
, prog
, shader_list
, num_shaders
,
1679 if (!prog
->LinkStatus
)
1682 /* Check that there is only a single definition of each function signature
1683 * across all shaders.
1685 for (unsigned i
= 0; i
< (num_shaders
- 1); i
++) {
1686 foreach_in_list(ir_instruction
, node
, shader_list
[i
]->ir
) {
1687 ir_function
*const f
= node
->as_function();
1692 for (unsigned j
= i
+ 1; j
< num_shaders
; j
++) {
1693 ir_function
*const other
=
1694 shader_list
[j
]->symbols
->get_function(f
->name
);
1696 /* If the other shader has no function (and therefore no function
1697 * signatures) with the same name, skip to the next shader.
1702 foreach_in_list(ir_function_signature
, sig
, &f
->signatures
) {
1703 if (!sig
->is_defined
|| sig
->is_builtin())
1706 ir_function_signature
*other_sig
=
1707 other
->exact_matching_signature(NULL
, &sig
->parameters
);
1709 if ((other_sig
!= NULL
) && other_sig
->is_defined
1710 && !other_sig
->is_builtin()) {
1711 linker_error(prog
, "function `%s' is multiply defined\n",
1720 /* Find the shader that defines main, and make a clone of it.
1722 * Starting with the clone, search for undefined references. If one is
1723 * found, find the shader that defines it. Clone the reference and add
1724 * it to the shader. Repeat until there are no undefined references or
1725 * until a reference cannot be resolved.
1727 gl_shader
*main
= NULL
;
1728 for (unsigned i
= 0; i
< num_shaders
; i
++) {
1729 if (link_get_main_function_signature(shader_list
[i
]) != NULL
) {
1730 main
= shader_list
[i
];
1736 linker_error(prog
, "%s shader lacks `main'\n",
1737 _mesa_shader_stage_to_string(shader_list
[0]->Stage
));
1741 gl_shader
*linked
= ctx
->Driver
.NewShader(NULL
, 0, main
->Type
);
1742 linked
->ir
= new(linked
) exec_list
;
1743 clone_ir_list(mem_ctx
, linked
->ir
, main
->ir
);
1745 linked
->UniformBlocks
= uniform_blocks
;
1746 linked
->NumUniformBlocks
= num_uniform_blocks
;
1747 ralloc_steal(linked
, linked
->UniformBlocks
);
1749 link_fs_input_layout_qualifiers(prog
, linked
, shader_list
, num_shaders
);
1750 link_gs_inout_layout_qualifiers(prog
, linked
, shader_list
, num_shaders
);
1751 link_cs_input_layout_qualifiers(prog
, linked
, shader_list
, num_shaders
);
1753 populate_symbol_table(linked
);
1755 /* The pointer to the main function in the final linked shader (i.e., the
1756 * copy of the original shader that contained the main function).
1758 ir_function_signature
*const main_sig
=
1759 link_get_main_function_signature(linked
);
1761 /* Move any instructions other than variable declarations or function
1762 * declarations into main.
1764 exec_node
*insertion_point
=
1765 move_non_declarations(linked
->ir
, (exec_node
*) &main_sig
->body
, false,
1768 for (unsigned i
= 0; i
< num_shaders
; i
++) {
1769 if (shader_list
[i
] == main
)
1772 insertion_point
= move_non_declarations(shader_list
[i
]->ir
,
1773 insertion_point
, true, linked
);
1776 /* Check if any shader needs built-in functions. */
1777 bool need_builtins
= false;
1778 for (unsigned i
= 0; i
< num_shaders
; i
++) {
1779 if (shader_list
[i
]->uses_builtin_functions
) {
1780 need_builtins
= true;
1786 if (need_builtins
) {
1787 /* Make a temporary array one larger than shader_list, which will hold
1788 * the built-in function shader as well.
1790 gl_shader
**linking_shaders
= (gl_shader
**)
1791 calloc(num_shaders
+ 1, sizeof(gl_shader
*));
1793 ok
= linking_shaders
!= NULL
;
1796 memcpy(linking_shaders
, shader_list
, num_shaders
* sizeof(gl_shader
*));
1797 linking_shaders
[num_shaders
] = _mesa_glsl_get_builtin_function_shader();
1799 ok
= link_function_calls(prog
, linked
, linking_shaders
, num_shaders
+ 1);
1801 free(linking_shaders
);
1803 _mesa_error_no_memory(__func__
);
1806 ok
= link_function_calls(prog
, linked
, shader_list
, num_shaders
);
1811 ctx
->Driver
.DeleteShader(ctx
, linked
);
1815 /* At this point linked should contain all of the linked IR, so
1816 * validate it to make sure nothing went wrong.
1818 validate_ir_tree(linked
->ir
);
1820 /* Set the size of geometry shader input arrays */
1821 if (linked
->Stage
== MESA_SHADER_GEOMETRY
) {
1822 unsigned num_vertices
= vertices_per_prim(prog
->Geom
.InputType
);
1823 geom_array_resize_visitor
input_resize_visitor(num_vertices
, prog
);
1824 foreach_in_list(ir_instruction
, ir
, linked
->ir
) {
1825 ir
->accept(&input_resize_visitor
);
1829 if (ctx
->Const
.VertexID_is_zero_based
)
1830 lower_vertex_id(linked
);
1832 /* Make a pass over all variable declarations to ensure that arrays with
1833 * unspecified sizes have a size specified. The size is inferred from the
1834 * max_array_access field.
1836 array_sizing_visitor v
;
1838 v
.fixup_unnamed_interface_types();
1844 * Update the sizes of linked shader uniform arrays to the maximum
1847 * From page 81 (page 95 of the PDF) of the OpenGL 2.1 spec:
1849 * If one or more elements of an array are active,
1850 * GetActiveUniform will return the name of the array in name,
1851 * subject to the restrictions listed above. The type of the array
1852 * is returned in type. The size parameter contains the highest
1853 * array element index used, plus one. The compiler or linker
1854 * determines the highest index used. There will be only one
1855 * active uniform reported by the GL per uniform array.
1859 update_array_sizes(struct gl_shader_program
*prog
)
1861 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1862 if (prog
->_LinkedShaders
[i
] == NULL
)
1865 foreach_in_list(ir_instruction
, node
, prog
->_LinkedShaders
[i
]->ir
) {
1866 ir_variable
*const var
= node
->as_variable();
1868 if ((var
== NULL
) || (var
->data
.mode
!= ir_var_uniform
) ||
1869 !var
->type
->is_array())
1872 /* GL_ARB_uniform_buffer_object says that std140 uniforms
1873 * will not be eliminated. Since we always do std140, just
1874 * don't resize arrays in UBOs.
1876 * Atomic counters are supposed to get deterministic
1877 * locations assigned based on the declaration ordering and
1878 * sizes, array compaction would mess that up.
1880 if (var
->is_in_buffer_block() || var
->type
->contains_atomic())
1883 unsigned int size
= var
->data
.max_array_access
;
1884 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
1885 if (prog
->_LinkedShaders
[j
] == NULL
)
1888 foreach_in_list(ir_instruction
, node2
, prog
->_LinkedShaders
[j
]->ir
) {
1889 ir_variable
*other_var
= node2
->as_variable();
1893 if (strcmp(var
->name
, other_var
->name
) == 0 &&
1894 other_var
->data
.max_array_access
> size
) {
1895 size
= other_var
->data
.max_array_access
;
1900 if (size
+ 1 != var
->type
->length
) {
1901 /* If this is a built-in uniform (i.e., it's backed by some
1902 * fixed-function state), adjust the number of state slots to
1903 * match the new array size. The number of slots per array entry
1904 * is not known. It seems safe to assume that the total number of
1905 * slots is an integer multiple of the number of array elements.
1906 * Determine the number of slots per array element by dividing by
1907 * the old (total) size.
1909 const unsigned num_slots
= var
->get_num_state_slots();
1910 if (num_slots
> 0) {
1911 var
->set_num_state_slots((size
+ 1)
1912 * (num_slots
/ var
->type
->length
));
1915 var
->type
= glsl_type::get_array_instance(var
->type
->fields
.array
,
1917 /* FINISHME: We should update the types of array
1918 * dereferences of this variable now.
1926 * Find a contiguous set of available bits in a bitmask.
1928 * \param used_mask Bits representing used (1) and unused (0) locations
1929 * \param needed_count Number of contiguous bits needed.
1932 * Base location of the available bits on success or -1 on failure.
1935 find_available_slots(unsigned used_mask
, unsigned needed_count
)
1937 unsigned needed_mask
= (1 << needed_count
) - 1;
1938 const int max_bit_to_test
= (8 * sizeof(used_mask
)) - needed_count
;
1940 /* The comparison to 32 is redundant, but without it GCC emits "warning:
1941 * cannot optimize possibly infinite loops" for the loop below.
1943 if ((needed_count
== 0) || (max_bit_to_test
< 0) || (max_bit_to_test
> 32))
1946 for (int i
= 0; i
<= max_bit_to_test
; i
++) {
1947 if ((needed_mask
& ~used_mask
) == needed_mask
)
1958 * Assign locations for either VS inputs or FS outputs
1960 * \param prog Shader program whose variables need locations assigned
1961 * \param target_index Selector for the program target to receive location
1962 * assignmnets. Must be either \c MESA_SHADER_VERTEX or
1963 * \c MESA_SHADER_FRAGMENT.
1964 * \param max_index Maximum number of generic locations. This corresponds
1965 * to either the maximum number of draw buffers or the
1966 * maximum number of generic attributes.
1969 * If locations are successfully assigned, true is returned. Otherwise an
1970 * error is emitted to the shader link log and false is returned.
1973 assign_attribute_or_color_locations(gl_shader_program
*prog
,
1974 unsigned target_index
,
1977 /* Mark invalid locations as being used.
1979 unsigned used_locations
= (max_index
>= 32)
1980 ? ~0 : ~((1 << max_index
) - 1);
1982 assert((target_index
== MESA_SHADER_VERTEX
)
1983 || (target_index
== MESA_SHADER_FRAGMENT
));
1985 gl_shader
*const sh
= prog
->_LinkedShaders
[target_index
];
1989 /* Operate in a total of four passes.
1991 * 1. Invalidate the location assignments for all vertex shader inputs.
1993 * 2. Assign locations for inputs that have user-defined (via
1994 * glBindVertexAttribLocation) locations and outputs that have
1995 * user-defined locations (via glBindFragDataLocation).
1997 * 3. Sort the attributes without assigned locations by number of slots
1998 * required in decreasing order. Fragmentation caused by attribute
1999 * locations assigned by the application may prevent large attributes
2000 * from having enough contiguous space.
2002 * 4. Assign locations to any inputs without assigned locations.
2005 const int generic_base
= (target_index
== MESA_SHADER_VERTEX
)
2006 ? (int) VERT_ATTRIB_GENERIC0
: (int) FRAG_RESULT_DATA0
;
2008 const enum ir_variable_mode direction
=
2009 (target_index
== MESA_SHADER_VERTEX
)
2010 ? ir_var_shader_in
: ir_var_shader_out
;
2013 /* Temporary storage for the set of attributes that need locations assigned.
2019 /* Used below in the call to qsort. */
2020 static int compare(const void *a
, const void *b
)
2022 const temp_attr
*const l
= (const temp_attr
*) a
;
2023 const temp_attr
*const r
= (const temp_attr
*) b
;
2025 /* Reversed because we want a descending order sort below. */
2026 return r
->slots
- l
->slots
;
2030 unsigned num_attr
= 0;
2031 unsigned total_attribs_size
= 0;
2033 foreach_in_list(ir_instruction
, node
, sh
->ir
) {
2034 ir_variable
*const var
= node
->as_variable();
2036 if ((var
== NULL
) || (var
->data
.mode
!= (unsigned) direction
))
2039 if (var
->data
.explicit_location
) {
2040 if ((var
->data
.location
>= (int)(max_index
+ generic_base
))
2041 || (var
->data
.location
< 0)) {
2043 "invalid explicit location %d specified for `%s'\n",
2044 (var
->data
.location
< 0)
2045 ? var
->data
.location
2046 : var
->data
.location
- generic_base
,
2050 } else if (target_index
== MESA_SHADER_VERTEX
) {
2053 if (prog
->AttributeBindings
->get(binding
, var
->name
)) {
2054 assert(binding
>= VERT_ATTRIB_GENERIC0
);
2055 var
->data
.location
= binding
;
2056 var
->data
.is_unmatched_generic_inout
= 0;
2058 } else if (target_index
== MESA_SHADER_FRAGMENT
) {
2062 if (prog
->FragDataBindings
->get(binding
, var
->name
)) {
2063 assert(binding
>= FRAG_RESULT_DATA0
);
2064 var
->data
.location
= binding
;
2065 var
->data
.is_unmatched_generic_inout
= 0;
2067 if (prog
->FragDataIndexBindings
->get(index
, var
->name
)) {
2068 var
->data
.index
= index
;
2073 const unsigned slots
= var
->type
->count_attribute_slots();
2075 /* From GL4.5 core spec, section 11.1.1 (Vertex Attributes):
2077 * "A program with more than the value of MAX_VERTEX_ATTRIBS active
2078 * attribute variables may fail to link, unless device-dependent
2079 * optimizations are able to make the program fit within available
2080 * hardware resources. For the purposes of this test, attribute variables
2081 * of the type dvec3, dvec4, dmat2x3, dmat2x4, dmat3, dmat3x4, dmat4x3,
2082 * and dmat4 may count as consuming twice as many attributes as equivalent
2083 * single-precision types. While these types use the same number of
2084 * generic attributes as their single-precision equivalents,
2085 * implementations are permitted to consume two single-precision vectors
2086 * of internal storage for each three- or four-component double-precision
2088 * Until someone has a good reason in Mesa, enforce that now.
2090 if (target_index
== MESA_SHADER_VERTEX
) {
2091 total_attribs_size
+= slots
;
2092 if (var
->type
->without_array() == glsl_type::dvec3_type
||
2093 var
->type
->without_array() == glsl_type::dvec4_type
||
2094 var
->type
->without_array() == glsl_type::dmat2x3_type
||
2095 var
->type
->without_array() == glsl_type::dmat2x4_type
||
2096 var
->type
->without_array() == glsl_type::dmat3_type
||
2097 var
->type
->without_array() == glsl_type::dmat3x4_type
||
2098 var
->type
->without_array() == glsl_type::dmat4x3_type
||
2099 var
->type
->without_array() == glsl_type::dmat4_type
)
2100 total_attribs_size
+= slots
;
2103 /* If the variable is not a built-in and has a location statically
2104 * assigned in the shader (presumably via a layout qualifier), make sure
2105 * that it doesn't collide with other assigned locations. Otherwise,
2106 * add it to the list of variables that need linker-assigned locations.
2108 if (var
->data
.location
!= -1) {
2109 if (var
->data
.location
>= generic_base
&& var
->data
.index
< 1) {
2110 /* From page 61 of the OpenGL 4.0 spec:
2112 * "LinkProgram will fail if the attribute bindings assigned
2113 * by BindAttribLocation do not leave not enough space to
2114 * assign a location for an active matrix attribute or an
2115 * active attribute array, both of which require multiple
2116 * contiguous generic attributes."
2118 * I think above text prohibits the aliasing of explicit and
2119 * automatic assignments. But, aliasing is allowed in manual
2120 * assignments of attribute locations. See below comments for
2123 * From OpenGL 4.0 spec, page 61:
2125 * "It is possible for an application to bind more than one
2126 * attribute name to the same location. This is referred to as
2127 * aliasing. This will only work if only one of the aliased
2128 * attributes is active in the executable program, or if no
2129 * path through the shader consumes more than one attribute of
2130 * a set of attributes aliased to the same location. A link
2131 * error can occur if the linker determines that every path
2132 * through the shader consumes multiple aliased attributes,
2133 * but implementations are not required to generate an error
2136 * From GLSL 4.30 spec, page 54:
2138 * "A program will fail to link if any two non-vertex shader
2139 * input variables are assigned to the same location. For
2140 * vertex shaders, multiple input variables may be assigned
2141 * to the same location using either layout qualifiers or via
2142 * the OpenGL API. However, such aliasing is intended only to
2143 * support vertex shaders where each execution path accesses
2144 * at most one input per each location. Implementations are
2145 * permitted, but not required, to generate link-time errors
2146 * if they detect that every path through the vertex shader
2147 * executable accesses multiple inputs assigned to any single
2148 * location. For all shader types, a program will fail to link
2149 * if explicit location assignments leave the linker unable
2150 * to find space for other variables without explicit
2153 * From OpenGL ES 3.0 spec, page 56:
2155 * "Binding more than one attribute name to the same location
2156 * is referred to as aliasing, and is not permitted in OpenGL
2157 * ES Shading Language 3.00 vertex shaders. LinkProgram will
2158 * fail when this condition exists. However, aliasing is
2159 * possible in OpenGL ES Shading Language 1.00 vertex shaders.
2160 * This will only work if only one of the aliased attributes
2161 * is active in the executable program, or if no path through
2162 * the shader consumes more than one attribute of a set of
2163 * attributes aliased to the same location. A link error can
2164 * occur if the linker determines that every path through the
2165 * shader consumes multiple aliased attributes, but implemen-
2166 * tations are not required to generate an error in this case."
2168 * After looking at above references from OpenGL, OpenGL ES and
2169 * GLSL specifications, we allow aliasing of vertex input variables
2170 * in: OpenGL 2.0 (and above) and OpenGL ES 2.0.
2172 * NOTE: This is not required by the spec but its worth mentioning
2173 * here that we're not doing anything to make sure that no path
2174 * through the vertex shader executable accesses multiple inputs
2175 * assigned to any single location.
2178 /* Mask representing the contiguous slots that will be used by
2181 const unsigned attr
= var
->data
.location
- generic_base
;
2182 const unsigned use_mask
= (1 << slots
) - 1;
2183 const char *const string
= (target_index
== MESA_SHADER_VERTEX
)
2184 ? "vertex shader input" : "fragment shader output";
2186 /* Generate a link error if the requested locations for this
2187 * attribute exceed the maximum allowed attribute location.
2189 if (attr
+ slots
> max_index
) {
2191 "insufficient contiguous locations "
2192 "available for %s `%s' %d %d %d\n", string
,
2193 var
->name
, used_locations
, use_mask
, attr
);
2197 /* Generate a link error if the set of bits requested for this
2198 * attribute overlaps any previously allocated bits.
2200 if ((~(use_mask
<< attr
) & used_locations
) != used_locations
) {
2201 if (target_index
== MESA_SHADER_FRAGMENT
||
2202 (prog
->IsES
&& prog
->Version
>= 300)) {
2204 "overlapping location is assigned "
2205 "to %s `%s' %d %d %d\n", string
,
2206 var
->name
, used_locations
, use_mask
, attr
);
2209 linker_warning(prog
,
2210 "overlapping location is assigned "
2211 "to %s `%s' %d %d %d\n", string
,
2212 var
->name
, used_locations
, use_mask
, attr
);
2216 used_locations
|= (use_mask
<< attr
);
2222 to_assign
[num_attr
].slots
= slots
;
2223 to_assign
[num_attr
].var
= var
;
2227 if (target_index
== MESA_SHADER_VERTEX
) {
2228 if (total_attribs_size
> max_index
) {
2230 "attempt to use %d vertex attribute slots only %d available ",
2231 total_attribs_size
, max_index
);
2236 /* If all of the attributes were assigned locations by the application (or
2237 * are built-in attributes with fixed locations), return early. This should
2238 * be the common case.
2243 qsort(to_assign
, num_attr
, sizeof(to_assign
[0]), temp_attr::compare
);
2245 if (target_index
== MESA_SHADER_VERTEX
) {
2246 /* VERT_ATTRIB_GENERIC0 is a pseudo-alias for VERT_ATTRIB_POS. It can
2247 * only be explicitly assigned by via glBindAttribLocation. Mark it as
2248 * reserved to prevent it from being automatically allocated below.
2250 find_deref_visitor
find("gl_Vertex");
2252 if (find
.variable_found())
2253 used_locations
|= (1 << 0);
2256 for (unsigned i
= 0; i
< num_attr
; i
++) {
2257 /* Mask representing the contiguous slots that will be used by this
2260 const unsigned use_mask
= (1 << to_assign
[i
].slots
) - 1;
2262 int location
= find_available_slots(used_locations
, to_assign
[i
].slots
);
2265 const char *const string
= (target_index
== MESA_SHADER_VERTEX
)
2266 ? "vertex shader input" : "fragment shader output";
2269 "insufficient contiguous locations "
2270 "available for %s `%s'\n",
2271 string
, to_assign
[i
].var
->name
);
2275 to_assign
[i
].var
->data
.location
= generic_base
+ location
;
2276 to_assign
[i
].var
->data
.is_unmatched_generic_inout
= 0;
2277 used_locations
|= (use_mask
<< location
);
2285 * Demote shader inputs and outputs that are not used in other stages
2288 demote_shader_inputs_and_outputs(gl_shader
*sh
, enum ir_variable_mode mode
)
2290 foreach_in_list(ir_instruction
, node
, sh
->ir
) {
2291 ir_variable
*const var
= node
->as_variable();
2293 if ((var
== NULL
) || (var
->data
.mode
!= int(mode
)))
2296 /* A shader 'in' or 'out' variable is only really an input or output if
2297 * its value is used by other shader stages. This will cause the variable
2298 * to have a location assigned.
2300 if (var
->data
.is_unmatched_generic_inout
) {
2301 assert(var
->data
.mode
!= ir_var_temporary
);
2302 var
->data
.mode
= ir_var_auto
;
2309 * Store the gl_FragDepth layout in the gl_shader_program struct.
2312 store_fragdepth_layout(struct gl_shader_program
*prog
)
2314 if (prog
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
) {
2318 struct exec_list
*ir
= prog
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->ir
;
2320 /* We don't look up the gl_FragDepth symbol directly because if
2321 * gl_FragDepth is not used in the shader, it's removed from the IR.
2322 * However, the symbol won't be removed from the symbol table.
2324 * We're only interested in the cases where the variable is NOT removed
2327 foreach_in_list(ir_instruction
, node
, ir
) {
2328 ir_variable
*const var
= node
->as_variable();
2330 if (var
== NULL
|| var
->data
.mode
!= ir_var_shader_out
) {
2334 if (strcmp(var
->name
, "gl_FragDepth") == 0) {
2335 switch (var
->data
.depth_layout
) {
2336 case ir_depth_layout_none
:
2337 prog
->FragDepthLayout
= FRAG_DEPTH_LAYOUT_NONE
;
2339 case ir_depth_layout_any
:
2340 prog
->FragDepthLayout
= FRAG_DEPTH_LAYOUT_ANY
;
2342 case ir_depth_layout_greater
:
2343 prog
->FragDepthLayout
= FRAG_DEPTH_LAYOUT_GREATER
;
2345 case ir_depth_layout_less
:
2346 prog
->FragDepthLayout
= FRAG_DEPTH_LAYOUT_LESS
;
2348 case ir_depth_layout_unchanged
:
2349 prog
->FragDepthLayout
= FRAG_DEPTH_LAYOUT_UNCHANGED
;
2360 * Validate the resources used by a program versus the implementation limits
2363 check_resources(struct gl_context
*ctx
, struct gl_shader_program
*prog
)
2365 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2366 struct gl_shader
*sh
= prog
->_LinkedShaders
[i
];
2371 if (sh
->num_samplers
> ctx
->Const
.Program
[i
].MaxTextureImageUnits
) {
2372 linker_error(prog
, "Too many %s shader texture samplers\n",
2373 _mesa_shader_stage_to_string(i
));
2376 if (sh
->num_uniform_components
>
2377 ctx
->Const
.Program
[i
].MaxUniformComponents
) {
2378 if (ctx
->Const
.GLSLSkipStrictMaxUniformLimitCheck
) {
2379 linker_warning(prog
, "Too many %s shader default uniform block "
2380 "components, but the driver will try to optimize "
2381 "them out; this is non-portable out-of-spec "
2383 _mesa_shader_stage_to_string(i
));
2385 linker_error(prog
, "Too many %s shader default uniform block "
2387 _mesa_shader_stage_to_string(i
));
2391 if (sh
->num_combined_uniform_components
>
2392 ctx
->Const
.Program
[i
].MaxCombinedUniformComponents
) {
2393 if (ctx
->Const
.GLSLSkipStrictMaxUniformLimitCheck
) {
2394 linker_warning(prog
, "Too many %s shader uniform components, "
2395 "but the driver will try to optimize them out; "
2396 "this is non-portable out-of-spec behavior\n",
2397 _mesa_shader_stage_to_string(i
));
2399 linker_error(prog
, "Too many %s shader uniform components\n",
2400 _mesa_shader_stage_to_string(i
));
2405 unsigned blocks
[MESA_SHADER_STAGES
] = {0};
2406 unsigned total_uniform_blocks
= 0;
2408 for (unsigned i
= 0; i
< prog
->NumUniformBlocks
; i
++) {
2409 if (prog
->UniformBlocks
[i
].UniformBufferSize
> ctx
->Const
.MaxUniformBlockSize
) {
2410 linker_error(prog
, "Uniform block %s too big (%d/%d)\n",
2411 prog
->UniformBlocks
[i
].Name
,
2412 prog
->UniformBlocks
[i
].UniformBufferSize
,
2413 ctx
->Const
.MaxUniformBlockSize
);
2416 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
2417 if (prog
->UniformBlockStageIndex
[j
][i
] != -1) {
2419 total_uniform_blocks
++;
2423 if (total_uniform_blocks
> ctx
->Const
.MaxCombinedUniformBlocks
) {
2424 linker_error(prog
, "Too many combined uniform blocks (%d/%d)\n",
2425 prog
->NumUniformBlocks
,
2426 ctx
->Const
.MaxCombinedUniformBlocks
);
2428 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2429 const unsigned max_uniform_blocks
=
2430 ctx
->Const
.Program
[i
].MaxUniformBlocks
;
2431 if (blocks
[i
] > max_uniform_blocks
) {
2432 linker_error(prog
, "Too many %s uniform blocks (%d/%d)\n",
2433 _mesa_shader_stage_to_string(i
),
2435 max_uniform_blocks
);
2444 * Validate shader image resources.
2447 check_image_resources(struct gl_context
*ctx
, struct gl_shader_program
*prog
)
2449 unsigned total_image_units
= 0;
2450 unsigned fragment_outputs
= 0;
2452 if (!ctx
->Extensions
.ARB_shader_image_load_store
)
2455 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2456 struct gl_shader
*sh
= prog
->_LinkedShaders
[i
];
2459 if (sh
->NumImages
> ctx
->Const
.Program
[i
].MaxImageUniforms
)
2460 linker_error(prog
, "Too many %s shader image uniforms\n",
2461 _mesa_shader_stage_to_string(i
));
2463 total_image_units
+= sh
->NumImages
;
2465 if (i
== MESA_SHADER_FRAGMENT
) {
2466 foreach_in_list(ir_instruction
, node
, sh
->ir
) {
2467 ir_variable
*var
= node
->as_variable();
2468 if (var
&& var
->data
.mode
== ir_var_shader_out
)
2469 fragment_outputs
+= var
->type
->count_attribute_slots();
2475 if (total_image_units
> ctx
->Const
.MaxCombinedImageUniforms
)
2476 linker_error(prog
, "Too many combined image uniforms\n");
2478 if (total_image_units
+ fragment_outputs
>
2479 ctx
->Const
.MaxCombinedImageUnitsAndFragmentOutputs
)
2480 linker_error(prog
, "Too many combined image uniforms and fragment outputs\n");
2485 * Initializes explicit location slots to INACTIVE_UNIFORM_EXPLICIT_LOCATION
2486 * for a variable, checks for overlaps between other uniforms using explicit
2490 reserve_explicit_locations(struct gl_shader_program
*prog
,
2491 string_to_uint_map
*map
, ir_variable
*var
)
2493 unsigned slots
= var
->type
->uniform_locations();
2494 unsigned max_loc
= var
->data
.location
+ slots
- 1;
2496 /* Resize remap table if locations do not fit in the current one. */
2497 if (max_loc
+ 1 > prog
->NumUniformRemapTable
) {
2498 prog
->UniformRemapTable
=
2499 reralloc(prog
, prog
->UniformRemapTable
,
2500 gl_uniform_storage
*,
2503 if (!prog
->UniformRemapTable
) {
2504 linker_error(prog
, "Out of memory during linking.\n");
2508 /* Initialize allocated space. */
2509 for (unsigned i
= prog
->NumUniformRemapTable
; i
< max_loc
+ 1; i
++)
2510 prog
->UniformRemapTable
[i
] = NULL
;
2512 prog
->NumUniformRemapTable
= max_loc
+ 1;
2515 for (unsigned i
= 0; i
< slots
; i
++) {
2516 unsigned loc
= var
->data
.location
+ i
;
2518 /* Check if location is already used. */
2519 if (prog
->UniformRemapTable
[loc
] == INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
2521 /* Possibly same uniform from a different stage, this is ok. */
2523 if (map
->get(hash_loc
, var
->name
) && hash_loc
== loc
- i
)
2526 /* ARB_explicit_uniform_location specification states:
2528 * "No two default-block uniform variables in the program can have
2529 * the same location, even if they are unused, otherwise a compiler
2530 * or linker error will be generated."
2533 "location qualifier for uniform %s overlaps "
2534 "previously used location\n",
2539 /* Initialize location as inactive before optimization
2540 * rounds and location assignment.
2542 prog
->UniformRemapTable
[loc
] = INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
2545 /* Note, base location used for arrays. */
2546 map
->put(var
->data
.location
, var
->name
);
2552 * Check and reserve all explicit uniform locations, called before
2553 * any optimizations happen to handle also inactive uniforms and
2554 * inactive array elements that may get trimmed away.
2557 check_explicit_uniform_locations(struct gl_context
*ctx
,
2558 struct gl_shader_program
*prog
)
2560 if (!ctx
->Extensions
.ARB_explicit_uniform_location
)
2563 /* This map is used to detect if overlapping explicit locations
2564 * occur with the same uniform (from different stage) or a different one.
2566 string_to_uint_map
*uniform_map
= new string_to_uint_map
;
2569 linker_error(prog
, "Out of memory during linking.\n");
2573 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2574 struct gl_shader
*sh
= prog
->_LinkedShaders
[i
];
2579 foreach_in_list(ir_instruction
, node
, sh
->ir
) {
2580 ir_variable
*var
= node
->as_variable();
2581 if (var
&& (var
->data
.mode
== ir_var_uniform
|| var
->data
.mode
== ir_var_shader_storage
) &&
2582 var
->data
.explicit_location
) {
2583 if (!reserve_explicit_locations(prog
, uniform_map
, var
)) {
2595 add_program_resource(struct gl_shader_program
*prog
, GLenum type
,
2596 const void *data
, uint8_t stages
)
2600 /* If resource already exists, do not add it again. */
2601 for (unsigned i
= 0; i
< prog
->NumProgramResourceList
; i
++)
2602 if (prog
->ProgramResourceList
[i
].Data
== data
)
2605 prog
->ProgramResourceList
=
2607 prog
->ProgramResourceList
,
2608 gl_program_resource
,
2609 prog
->NumProgramResourceList
+ 1);
2611 if (!prog
->ProgramResourceList
) {
2612 linker_error(prog
, "Out of memory during linking.\n");
2616 struct gl_program_resource
*res
=
2617 &prog
->ProgramResourceList
[prog
->NumProgramResourceList
];
2621 res
->StageReferences
= stages
;
2623 prog
->NumProgramResourceList
++;
2629 * Function builds a stage reference bitmask from variable name.
2632 build_stageref(struct gl_shader_program
*shProg
, const char *name
)
2636 /* Note, that we assume MAX 8 stages, if there will be more stages, type
2637 * used for reference mask in gl_program_resource will need to be changed.
2639 assert(MESA_SHADER_STAGES
< 8);
2641 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2642 struct gl_shader
*sh
= shProg
->_LinkedShaders
[i
];
2646 /* Shader symbol table may contain variables that have
2647 * been optimized away. Search IR for the variable instead.
2649 foreach_in_list(ir_instruction
, node
, sh
->ir
) {
2650 ir_variable
*var
= node
->as_variable();
2651 if (var
&& strcmp(var
->name
, name
) == 0) {
2661 add_interface_variables(struct gl_shader_program
*shProg
,
2662 struct gl_shader
*sh
, GLenum programInterface
)
2664 foreach_in_list(ir_instruction
, node
, sh
->ir
) {
2665 ir_variable
*var
= node
->as_variable();
2671 switch (var
->data
.mode
) {
2672 /* From GL 4.3 core spec, section 11.1.1 (Vertex Attributes):
2673 * "For GetActiveAttrib, all active vertex shader input variables
2674 * are enumerated, including the special built-in inputs gl_VertexID
2675 * and gl_InstanceID."
2677 case ir_var_system_value
:
2678 if (var
->data
.location
!= SYSTEM_VALUE_VERTEX_ID
&&
2679 var
->data
.location
!= SYSTEM_VALUE_VERTEX_ID_ZERO_BASE
&&
2680 var
->data
.location
!= SYSTEM_VALUE_INSTANCE_ID
)
2682 /* Mark special built-in inputs referenced by the vertex stage so
2683 * that they are considered active by the shader queries.
2685 mask
= (1 << (MESA_SHADER_VERTEX
));
2687 case ir_var_shader_in
:
2688 if (programInterface
!= GL_PROGRAM_INPUT
)
2691 case ir_var_shader_out
:
2692 if (programInterface
!= GL_PROGRAM_OUTPUT
)
2699 if (!add_program_resource(shProg
, programInterface
, var
,
2700 build_stageref(shProg
, var
->name
) | mask
))
2707 * Builds up a list of program resources that point to existing
2711 build_program_resource_list(struct gl_context
*ctx
,
2712 struct gl_shader_program
*shProg
)
2714 /* Rebuild resource list. */
2715 if (shProg
->ProgramResourceList
) {
2716 ralloc_free(shProg
->ProgramResourceList
);
2717 shProg
->ProgramResourceList
= NULL
;
2718 shProg
->NumProgramResourceList
= 0;
2721 int input_stage
= MESA_SHADER_STAGES
, output_stage
= 0;
2723 /* Determine first input and final output stage. These are used to
2724 * detect which variables should be enumerated in the resource list
2725 * for GL_PROGRAM_INPUT and GL_PROGRAM_OUTPUT.
2727 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2728 if (!shProg
->_LinkedShaders
[i
])
2730 if (input_stage
== MESA_SHADER_STAGES
)
2735 /* Empty shader, no resources. */
2736 if (input_stage
== MESA_SHADER_STAGES
&& output_stage
== 0)
2739 /* Add inputs and outputs to the resource list. */
2740 if (!add_interface_variables(shProg
, shProg
->_LinkedShaders
[input_stage
],
2744 if (!add_interface_variables(shProg
, shProg
->_LinkedShaders
[output_stage
],
2748 /* Add transform feedback varyings. */
2749 if (shProg
->LinkedTransformFeedback
.NumVarying
> 0) {
2750 for (int i
= 0; i
< shProg
->LinkedTransformFeedback
.NumVarying
; i
++) {
2752 build_stageref(shProg
,
2753 shProg
->LinkedTransformFeedback
.Varyings
[i
].Name
);
2754 if (!add_program_resource(shProg
, GL_TRANSFORM_FEEDBACK_VARYING
,
2755 &shProg
->LinkedTransformFeedback
.Varyings
[i
],
2761 /* Add uniforms from uniform storage. */
2762 for (unsigned i
= 0; i
< shProg
->NumUniformStorage
; i
++) {
2763 /* Do not add uniforms internally used by Mesa. */
2764 if (shProg
->UniformStorage
[i
].hidden
)
2768 build_stageref(shProg
, shProg
->UniformStorage
[i
].name
);
2770 /* Add stagereferences for uniforms in a uniform block. */
2771 int block_index
= shProg
->UniformStorage
[i
].block_index
;
2772 if (block_index
!= -1) {
2773 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
2774 if (shProg
->UniformBlockStageIndex
[j
][block_index
] != -1)
2775 stageref
|= (1 << j
);
2779 if (!add_program_resource(shProg
, GL_UNIFORM
,
2780 &shProg
->UniformStorage
[i
], stageref
))
2784 /* Add program uniform blocks. */
2785 for (unsigned i
= 0; i
< shProg
->NumUniformBlocks
; i
++) {
2786 if (!add_program_resource(shProg
, GL_UNIFORM_BLOCK
,
2787 &shProg
->UniformBlocks
[i
], 0))
2791 /* Add atomic counter buffers. */
2792 for (unsigned i
= 0; i
< shProg
->NumAtomicBuffers
; i
++) {
2793 if (!add_program_resource(shProg
, GL_ATOMIC_COUNTER_BUFFER
,
2794 &shProg
->AtomicBuffers
[i
], 0))
2798 /* TODO - following extensions will require more resource types:
2800 * GL_ARB_shader_storage_buffer_object
2801 * GL_ARB_shader_subroutine
2806 * This check is done to make sure we allow only constant expression
2807 * indexing and "constant-index-expression" (indexing with an expression
2808 * that includes loop induction variable).
2811 validate_sampler_array_indexing(struct gl_context
*ctx
,
2812 struct gl_shader_program
*prog
)
2814 dynamic_sampler_array_indexing_visitor v
;
2815 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2816 if (prog
->_LinkedShaders
[i
] == NULL
)
2819 bool no_dynamic_indexing
=
2820 ctx
->Const
.ShaderCompilerOptions
[i
].EmitNoIndirectSampler
;
2822 /* Search for array derefs in shader. */
2823 v
.run(prog
->_LinkedShaders
[i
]->ir
);
2824 if (v
.uses_dynamic_sampler_array_indexing()) {
2825 const char *msg
= "sampler arrays indexed with non-constant "
2826 "expressions is forbidden in GLSL %s %u";
2827 /* Backend has indicated that it has no dynamic indexing support. */
2828 if (no_dynamic_indexing
) {
2829 linker_error(prog
, msg
, prog
->IsES
? "ES" : "", prog
->Version
);
2832 linker_warning(prog
, msg
, prog
->IsES
? "ES" : "", prog
->Version
);
2841 link_shaders(struct gl_context
*ctx
, struct gl_shader_program
*prog
)
2843 tfeedback_decl
*tfeedback_decls
= NULL
;
2844 unsigned num_tfeedback_decls
= prog
->TransformFeedback
.NumVarying
;
2846 void *mem_ctx
= ralloc_context(NULL
); // temporary linker context
2848 prog
->LinkStatus
= true; /* All error paths will set this to false */
2849 prog
->Validated
= false;
2850 prog
->_Used
= false;
2852 prog
->ARB_fragment_coord_conventions_enable
= false;
2854 /* Separate the shaders into groups based on their type.
2856 struct gl_shader
**shader_list
[MESA_SHADER_STAGES
];
2857 unsigned num_shaders
[MESA_SHADER_STAGES
];
2859 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2860 shader_list
[i
] = (struct gl_shader
**)
2861 calloc(prog
->NumShaders
, sizeof(struct gl_shader
*));
2865 unsigned min_version
= UINT_MAX
;
2866 unsigned max_version
= 0;
2867 const bool is_es_prog
=
2868 (prog
->NumShaders
> 0 && prog
->Shaders
[0]->IsES
) ? true : false;
2869 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
2870 min_version
= MIN2(min_version
, prog
->Shaders
[i
]->Version
);
2871 max_version
= MAX2(max_version
, prog
->Shaders
[i
]->Version
);
2873 if (prog
->Shaders
[i
]->IsES
!= is_es_prog
) {
2874 linker_error(prog
, "all shaders must use same shading "
2875 "language version\n");
2879 if (prog
->Shaders
[i
]->ARB_fragment_coord_conventions_enable
) {
2880 prog
->ARB_fragment_coord_conventions_enable
= true;
2883 gl_shader_stage shader_type
= prog
->Shaders
[i
]->Stage
;
2884 shader_list
[shader_type
][num_shaders
[shader_type
]] = prog
->Shaders
[i
];
2885 num_shaders
[shader_type
]++;
2888 /* In desktop GLSL, different shader versions may be linked together. In
2889 * GLSL ES, all shader versions must be the same.
2891 if (is_es_prog
&& min_version
!= max_version
) {
2892 linker_error(prog
, "all shaders must use same shading "
2893 "language version\n");
2897 prog
->Version
= max_version
;
2898 prog
->IsES
= is_es_prog
;
2900 /* Geometry shaders have to be linked with vertex shaders.
2902 if (num_shaders
[MESA_SHADER_GEOMETRY
] > 0 &&
2903 num_shaders
[MESA_SHADER_VERTEX
] == 0 &&
2904 !prog
->SeparateShader
) {
2905 linker_error(prog
, "Geometry shader must be linked with "
2910 /* Compute shaders have additional restrictions. */
2911 if (num_shaders
[MESA_SHADER_COMPUTE
] > 0 &&
2912 num_shaders
[MESA_SHADER_COMPUTE
] != prog
->NumShaders
) {
2913 linker_error(prog
, "Compute shaders may not be linked with any other "
2914 "type of shader\n");
2917 for (unsigned int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2918 if (prog
->_LinkedShaders
[i
] != NULL
)
2919 ctx
->Driver
.DeleteShader(ctx
, prog
->_LinkedShaders
[i
]);
2921 prog
->_LinkedShaders
[i
] = NULL
;
2924 /* Link all shaders for a particular stage and validate the result.
2926 for (int stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
2927 if (num_shaders
[stage
] > 0) {
2928 gl_shader
*const sh
=
2929 link_intrastage_shaders(mem_ctx
, ctx
, prog
, shader_list
[stage
],
2930 num_shaders
[stage
]);
2932 if (!prog
->LinkStatus
) {
2934 ctx
->Driver
.DeleteShader(ctx
, sh
);
2939 case MESA_SHADER_VERTEX
:
2940 validate_vertex_shader_executable(prog
, sh
);
2942 case MESA_SHADER_GEOMETRY
:
2943 validate_geometry_shader_executable(prog
, sh
);
2945 case MESA_SHADER_FRAGMENT
:
2946 validate_fragment_shader_executable(prog
, sh
);
2949 if (!prog
->LinkStatus
) {
2951 ctx
->Driver
.DeleteShader(ctx
, sh
);
2955 _mesa_reference_shader(ctx
, &prog
->_LinkedShaders
[stage
], sh
);
2959 if (num_shaders
[MESA_SHADER_GEOMETRY
] > 0)
2960 prog
->LastClipDistanceArraySize
= prog
->Geom
.ClipDistanceArraySize
;
2961 else if (num_shaders
[MESA_SHADER_VERTEX
] > 0)
2962 prog
->LastClipDistanceArraySize
= prog
->Vert
.ClipDistanceArraySize
;
2964 prog
->LastClipDistanceArraySize
= 0; /* Not used */
2966 /* Here begins the inter-stage linking phase. Some initial validation is
2967 * performed, then locations are assigned for uniforms, attributes, and
2970 cross_validate_uniforms(prog
);
2971 if (!prog
->LinkStatus
)
2976 for (prev
= 0; prev
<= MESA_SHADER_FRAGMENT
; prev
++) {
2977 if (prog
->_LinkedShaders
[prev
] != NULL
)
2981 check_explicit_uniform_locations(ctx
, prog
);
2982 if (!prog
->LinkStatus
)
2985 /* Validate the inputs of each stage with the output of the preceding
2988 for (unsigned i
= prev
+ 1; i
<= MESA_SHADER_FRAGMENT
; i
++) {
2989 if (prog
->_LinkedShaders
[i
] == NULL
)
2992 validate_interstage_inout_blocks(prog
, prog
->_LinkedShaders
[prev
],
2993 prog
->_LinkedShaders
[i
]);
2994 if (!prog
->LinkStatus
)
2997 cross_validate_outputs_to_inputs(prog
,
2998 prog
->_LinkedShaders
[prev
],
2999 prog
->_LinkedShaders
[i
]);
3000 if (!prog
->LinkStatus
)
3006 /* Cross-validate uniform blocks between shader stages */
3007 validate_interstage_uniform_blocks(prog
, prog
->_LinkedShaders
,
3008 MESA_SHADER_STAGES
);
3009 if (!prog
->LinkStatus
)
3012 for (unsigned int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
3013 if (prog
->_LinkedShaders
[i
] != NULL
)
3014 lower_named_interface_blocks(mem_ctx
, prog
->_LinkedShaders
[i
]);
3017 /* Implement the GLSL 1.30+ rule for discard vs infinite loops Do
3018 * it before optimization because we want most of the checks to get
3019 * dropped thanks to constant propagation.
3021 * This rule also applies to GLSL ES 3.00.
3023 if (max_version
>= (is_es_prog
? 300 : 130)) {
3024 struct gl_shader
*sh
= prog
->_LinkedShaders
[MESA_SHADER_FRAGMENT
];
3026 lower_discard_flow(sh
->ir
);
3030 if (!interstage_cross_validate_uniform_blocks(prog
))
3033 /* Do common optimization before assigning storage for attributes,
3034 * uniforms, and varyings. Later optimization could possibly make
3035 * some of that unused.
3037 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
3038 if (prog
->_LinkedShaders
[i
] == NULL
)
3041 detect_recursion_linked(prog
, prog
->_LinkedShaders
[i
]->ir
);
3042 if (!prog
->LinkStatus
)
3045 if (ctx
->Const
.ShaderCompilerOptions
[i
].LowerClipDistance
) {
3046 lower_clip_distance(prog
->_LinkedShaders
[i
]);
3049 while (do_common_optimization(prog
->_LinkedShaders
[i
]->ir
, true, false,
3050 &ctx
->Const
.ShaderCompilerOptions
[i
],
3051 ctx
->Const
.NativeIntegers
))
3054 lower_const_arrays_to_uniforms(prog
->_LinkedShaders
[i
]->ir
);
3057 /* Validation for special cases where we allow sampler array indexing
3058 * with loop induction variable. This check emits a warning or error
3059 * depending if backend can handle dynamic indexing.
3061 if ((!prog
->IsES
&& prog
->Version
< 130) ||
3062 (prog
->IsES
&& prog
->Version
< 300)) {
3063 if (!validate_sampler_array_indexing(ctx
, prog
))
3067 /* Check and validate stream emissions in geometry shaders */
3068 validate_geometry_shader_emissions(ctx
, prog
);
3070 /* Mark all generic shader inputs and outputs as unpaired. */
3071 for (unsigned i
= MESA_SHADER_VERTEX
; i
<= MESA_SHADER_FRAGMENT
; i
++) {
3072 if (prog
->_LinkedShaders
[i
] != NULL
) {
3073 link_invalidate_variable_locations(prog
->_LinkedShaders
[i
]->ir
);
3077 if (!assign_attribute_or_color_locations(prog
, MESA_SHADER_VERTEX
,
3078 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxAttribs
)) {
3082 if (!assign_attribute_or_color_locations(prog
, MESA_SHADER_FRAGMENT
, MAX2(ctx
->Const
.MaxDrawBuffers
, ctx
->Const
.MaxDualSourceDrawBuffers
))) {
3086 unsigned first
, last
;
3088 first
= MESA_SHADER_STAGES
;
3091 /* Determine first and last stage. */
3092 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
3093 if (!prog
->_LinkedShaders
[i
])
3095 if (first
== MESA_SHADER_STAGES
)
3100 if (num_tfeedback_decls
!= 0) {
3101 /* From GL_EXT_transform_feedback:
3102 * A program will fail to link if:
3104 * * the <count> specified by TransformFeedbackVaryingsEXT is
3105 * non-zero, but the program object has no vertex or geometry
3108 if (first
== MESA_SHADER_FRAGMENT
) {
3109 linker_error(prog
, "Transform feedback varyings specified, but "
3110 "no vertex or geometry shader is present.\n");
3114 tfeedback_decls
= ralloc_array(mem_ctx
, tfeedback_decl
,
3115 prog
->TransformFeedback
.NumVarying
);
3116 if (!parse_tfeedback_decls(ctx
, prog
, mem_ctx
, num_tfeedback_decls
,
3117 prog
->TransformFeedback
.VaryingNames
,
3122 /* Linking the stages in the opposite order (from fragment to vertex)
3123 * ensures that inter-shader outputs written to in an earlier stage are
3124 * eliminated if they are (transitively) not used in a later stage.
3128 if (first
< MESA_SHADER_FRAGMENT
) {
3129 gl_shader
*const sh
= prog
->_LinkedShaders
[last
];
3131 if (first
== MESA_SHADER_GEOMETRY
) {
3132 /* There was no vertex shader, but we still have to assign varying
3133 * locations for use by geometry shader inputs in SSO.
3135 * If the shader is not separable (i.e., prog->SeparateShader is
3136 * false), linking will have already failed when first is
3137 * MESA_SHADER_GEOMETRY.
3139 if (!assign_varying_locations(ctx
, mem_ctx
, prog
,
3140 NULL
, prog
->_LinkedShaders
[first
],
3141 num_tfeedback_decls
, tfeedback_decls
,
3142 prog
->Geom
.VerticesIn
))
3146 if (last
!= MESA_SHADER_FRAGMENT
&&
3147 (num_tfeedback_decls
!= 0 || prog
->SeparateShader
)) {
3148 /* There was no fragment shader, but we still have to assign varying
3149 * locations for use by transform feedback.
3151 if (!assign_varying_locations(ctx
, mem_ctx
, prog
,
3153 num_tfeedback_decls
, tfeedback_decls
,
3158 do_dead_builtin_varyings(ctx
, sh
, NULL
,
3159 num_tfeedback_decls
, tfeedback_decls
);
3161 if (!prog
->SeparateShader
)
3162 demote_shader_inputs_and_outputs(sh
, ir_var_shader_out
);
3164 /* Eliminate code that is now dead due to unused outputs being demoted.
3166 while (do_dead_code(sh
->ir
, false))
3169 else if (first
== MESA_SHADER_FRAGMENT
) {
3170 /* If the program only contains a fragment shader...
3172 gl_shader
*const sh
= prog
->_LinkedShaders
[first
];
3174 do_dead_builtin_varyings(ctx
, NULL
, sh
,
3175 num_tfeedback_decls
, tfeedback_decls
);
3177 if (prog
->SeparateShader
) {
3178 if (!assign_varying_locations(ctx
, mem_ctx
, prog
,
3179 NULL
/* producer */,
3181 0 /* num_tfeedback_decls */,
3182 NULL
/* tfeedback_decls */,
3183 0 /* gs_input_vertices */))
3186 demote_shader_inputs_and_outputs(sh
, ir_var_shader_in
);
3188 while (do_dead_code(sh
->ir
, false))
3193 for (int i
= next
- 1; i
>= 0; i
--) {
3194 if (prog
->_LinkedShaders
[i
] == NULL
)
3197 gl_shader
*const sh_i
= prog
->_LinkedShaders
[i
];
3198 gl_shader
*const sh_next
= prog
->_LinkedShaders
[next
];
3199 unsigned gs_input_vertices
=
3200 next
== MESA_SHADER_GEOMETRY
? prog
->Geom
.VerticesIn
: 0;
3202 if (!assign_varying_locations(ctx
, mem_ctx
, prog
, sh_i
, sh_next
,
3203 next
== MESA_SHADER_FRAGMENT
? num_tfeedback_decls
: 0,
3204 tfeedback_decls
, gs_input_vertices
))
3207 do_dead_builtin_varyings(ctx
, sh_i
, sh_next
,
3208 next
== MESA_SHADER_FRAGMENT
? num_tfeedback_decls
: 0,
3211 demote_shader_inputs_and_outputs(sh_i
, ir_var_shader_out
);
3212 demote_shader_inputs_and_outputs(sh_next
, ir_var_shader_in
);
3214 /* Eliminate code that is now dead due to unused outputs being demoted.
3216 while (do_dead_code(sh_i
->ir
, false))
3218 while (do_dead_code(sh_next
->ir
, false))
3221 /* This must be done after all dead varyings are eliminated. */
3222 if (!check_against_output_limit(ctx
, prog
, sh_i
))
3224 if (!check_against_input_limit(ctx
, prog
, sh_next
))
3230 if (!store_tfeedback_info(ctx
, prog
, num_tfeedback_decls
, tfeedback_decls
))
3233 update_array_sizes(prog
);
3234 link_assign_uniform_locations(prog
, ctx
->Const
.UniformBooleanTrue
);
3235 link_assign_atomic_counter_resources(ctx
, prog
);
3236 store_fragdepth_layout(prog
);
3238 check_resources(ctx
, prog
);
3239 check_image_resources(ctx
, prog
);
3240 link_check_atomic_counter_resources(ctx
, prog
);
3242 if (!prog
->LinkStatus
)
3245 /* OpenGL ES requires that a vertex shader and a fragment shader both be
3246 * present in a linked program. GL_ARB_ES2_compatibility doesn't say
3247 * anything about shader linking when one of the shaders (vertex or
3248 * fragment shader) is absent. So, the extension shouldn't change the
3249 * behavior specified in GLSL specification.
3251 if (!prog
->SeparateShader
&& ctx
->API
== API_OPENGLES2
) {
3252 if (prog
->_LinkedShaders
[MESA_SHADER_VERTEX
] == NULL
) {
3253 linker_error(prog
, "program lacks a vertex shader\n");
3254 } else if (prog
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
) {
3255 linker_error(prog
, "program lacks a fragment shader\n");
3259 /* FINISHME: Assign fragment shader output locations. */
3262 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
3263 free(shader_list
[i
]);
3264 if (prog
->_LinkedShaders
[i
] == NULL
)
3267 /* Do a final validation step to make sure that the IR wasn't
3268 * invalidated by any modifications performed after intrastage linking.
3270 validate_ir_tree(prog
->_LinkedShaders
[i
]->ir
);
3272 /* Retain any live IR, but trash the rest. */
3273 reparent_ir(prog
->_LinkedShaders
[i
]->ir
, prog
->_LinkedShaders
[i
]->ir
);
3275 /* The symbol table in the linked shaders may contain references to
3276 * variables that were removed (e.g., unused uniforms). Since it may
3277 * contain junk, there is no possible valid use. Delete it and set the
3280 delete prog
->_LinkedShaders
[i
]->symbols
;
3281 prog
->_LinkedShaders
[i
]->symbols
= NULL
;
3284 ralloc_free(mem_ctx
);