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>
69 #include "glsl_symbol_table.h"
70 #include "glsl_parser_extras.h"
75 * Visitor that determines whether or not a variable is ever written.
77 class find_assignment_visitor
: public ir_hierarchical_visitor
{
79 find_assignment_visitor(const char *name
)
80 : name(name
), found(false)
85 virtual ir_visitor_status
visit_enter(ir_assignment
*ir
)
87 ir_variable
*const var
= ir
->lhs
->variable_referenced();
89 if (strcmp(name
, var
->name
) == 0) {
94 return visit_continue_with_parent
;
103 const char *name
; /**< Find writes to a variable with this name. */
104 bool found
; /**< Was a write to the variable found? */
109 * Verify that a vertex shader executable meets all semantic requirements
111 * \param shader Vertex shader executable to be verified
114 validate_vertex_shader_executable(struct glsl_shader
*shader
)
119 if (!shader
->symbols
->get_function("main")) {
120 printf("error: vertex shader lacks `main'\n");
124 find_assignment_visitor
find("gl_Position");
125 find
.run(&shader
->ir
);
126 if (!find
.variable_found()) {
127 printf("error: vertex shader does not write to `gl_Position'\n");
136 * Verify that a fragment shader executable meets all semantic requirements
138 * \param shader Fragment shader executable to be verified
141 validate_fragment_shader_executable(struct glsl_shader
*shader
)
146 if (!shader
->symbols
->get_function("main")) {
147 printf("error: fragment shader lacks `main'\n");
151 find_assignment_visitor
frag_color("gl_FragColor");
152 find_assignment_visitor
frag_data("gl_FragData");
154 frag_color
.run(&shader
->ir
);
155 frag_data
.run(&shader
->ir
);
157 if (!frag_color
.variable_found() && !frag_data
.variable_found()) {
158 printf("error: fragment shader does not write to `gl_FragColor' or "
163 if (frag_color
.variable_found() && frag_data
.variable_found()) {
164 printf("error: fragment shader write to both `gl_FragColor' and "
174 * Perform validation of uniforms used across multiple shader stages
177 cross_validate_uniforms(struct glsl_shader
**shaders
, unsigned num_shaders
)
179 /* Examine all of the uniforms in all of the shaders and cross validate
182 glsl_symbol_table uniforms
;
183 for (unsigned i
= 0; i
< num_shaders
; i
++) {
184 foreach_list(node
, &shaders
[i
]->ir
) {
185 ir_variable
*const var
= ((ir_instruction
*) node
)->as_variable();
187 if ((var
== NULL
) || (var
->mode
!= ir_var_uniform
))
190 /* If a uniform with this name has already been seen, verify that the
191 * new instance has the same type. In addition, if the uniforms have
192 * initializers, the values of the initializers must be the same.
194 ir_variable
*const existing
= uniforms
.get_variable(var
->name
);
195 if (existing
!= NULL
) {
196 if (var
->type
!= existing
->type
) {
197 printf("error: uniform `%s' declared as type `%s' and "
199 var
->name
, var
->type
->name
, existing
->type
->name
);
203 if (var
->constant_value
!= NULL
) {
204 if (existing
->constant_value
!= NULL
) {
205 if (!var
->constant_value
->has_value(existing
->constant_value
)) {
206 printf("error: initializers for uniform `%s' have "
207 "differing values\n",
212 /* If the first-seen instance of a particular uniform did not
213 * have an initializer but a later instance does, copy the
214 * initializer to the version stored in the symbol table.
216 existing
->constant_value
= var
->constant_value
->clone();
219 uniforms
.add_variable(var
->name
, var
);
228 * Validate that outputs from one stage match inputs of another
231 cross_validate_outputs_to_inputs(glsl_shader
*producer
, glsl_shader
*consumer
)
233 glsl_symbol_table parameters
;
234 /* FINISHME: Figure these out dynamically. */
235 const char *const producer_stage
= "vertex";
236 const char *const consumer_stage
= "fragment";
238 /* Find all shader outputs in the "producer" stage.
240 foreach_list(node
, &producer
->ir
) {
241 ir_variable
*const var
= ((ir_instruction
*) node
)->as_variable();
243 /* FINISHME: For geometry shaders, this should also look for inout
244 * FINISHME: variables.
246 if ((var
== NULL
) || (var
->mode
!= ir_var_out
))
249 parameters
.add_variable(var
->name
, var
);
253 /* Find all shader inputs in the "consumer" stage. Any variables that have
254 * matching outputs already in the symbol table must have the same type and
257 foreach_list(node
, &consumer
->ir
) {
258 ir_variable
*const input
= ((ir_instruction
*) node
)->as_variable();
260 /* FINISHME: For geometry shaders, this should also look for inout
261 * FINISHME: variables.
263 if ((input
== NULL
) || (input
->mode
!= ir_var_in
))
266 ir_variable
*const output
= parameters
.get_variable(input
->name
);
267 if (output
!= NULL
) {
268 /* Check that the types match between stages.
270 if (input
->type
!= output
->type
) {
271 printf("error: %s shader output `%s' delcared as type `%s', but "
272 "%s shader input declared as type `%s'\n",
273 producer_stage
, output
->name
, output
->type
->name
,
274 consumer_stage
, input
->type
->name
);
278 /* Check that all of the qualifiers match between stages.
280 if (input
->centroid
!= output
->centroid
) {
281 printf("error: %s shader output `%s' %s centroid qualifier, but "
282 "%s shader input %s centroid qualifier\n",
285 (output
->centroid
) ? "has" : "lacks",
287 (input
->centroid
) ? "has" : "lacks");
291 if (input
->invariant
!= output
->invariant
) {
292 printf("error: %s shader output `%s' %s invariant qualifier, but "
293 "%s shader input %s invariant qualifier\n",
296 (output
->invariant
) ? "has" : "lacks",
298 (input
->invariant
) ? "has" : "lacks");
302 if (input
->interpolation
!= output
->interpolation
) {
303 printf("error: %s shader output `%s' specifies %s interpolation "
305 "but %s shader input specifies %s interpolation "
309 output
->interpolation_string(),
311 input
->interpolation_string());
322 link_shaders(struct glsl_program
*prog
)
324 prog
->LinkStatus
= false;
325 prog
->Validated
= false;
328 /* Separate the shaders into groups based on their type.
330 struct glsl_shader
**vert_shader_list
;
331 unsigned num_vert_shaders
= 0;
332 struct glsl_shader
**frag_shader_list
;
333 unsigned num_frag_shaders
= 0;
335 vert_shader_list
= (struct glsl_shader
**)
336 calloc(2 * prog
->NumShaders
, sizeof(struct glsl_shader
*));
337 frag_shader_list
= &vert_shader_list
[prog
->NumShaders
];
339 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
340 switch (prog
->Shaders
[i
]->Type
) {
341 case GL_VERTEX_SHADER
:
342 vert_shader_list
[num_vert_shaders
] = prog
->Shaders
[i
];
345 case GL_FRAGMENT_SHADER
:
346 frag_shader_list
[num_frag_shaders
] = prog
->Shaders
[i
];
349 case GL_GEOMETRY_SHADER
:
350 /* FINISHME: Support geometry shaders. */
351 assert(prog
->Shaders
[i
]->Type
!= GL_GEOMETRY_SHADER
);
356 /* FINISHME: Implement intra-stage linking. */
357 assert(num_vert_shaders
<= 1);
358 assert(num_frag_shaders
<= 1);
360 /* Verify that each of the per-target executables is valid.
362 if (!validate_vertex_shader_executable(vert_shader_list
[0])
363 || !validate_fragment_shader_executable(frag_shader_list
[0]))
367 /* FINISHME: Perform inter-stage linking. */
368 glsl_shader
*shader_executables
[2];
369 unsigned num_shader_executables
;
371 num_shader_executables
= 0;
372 if (num_vert_shaders
> 0) {
373 shader_executables
[num_shader_executables
] = vert_shader_list
[0];
374 num_shader_executables
++;
377 if (num_frag_shaders
> 0) {
378 shader_executables
[num_shader_executables
] = frag_shader_list
[0];
379 num_shader_executables
++;
382 if (cross_validate_uniforms(shader_executables
, num_shader_executables
)) {
383 /* Validate the inputs of each stage with the output of the preceeding
386 for (unsigned i
= 1; i
< num_shader_executables
; i
++) {
387 if (!cross_validate_outputs_to_inputs(shader_executables
[i
- 1],
388 shader_executables
[i
]))
392 prog
->LinkStatus
= true;
395 /* FINISHME: Perform whole-program optimization here. */
397 /* FINISHME: Assign uniform locations. */
399 /* FINISHME: Assign vertex shader input locations. */
401 /* FINISHME: Assign vertex shader output / fragment shader input
402 * FINISHME: locations.
405 /* FINISHME: Assign fragment shader output locations. */
407 /* FINISHME: Generate code here. */
410 free(vert_shader_list
);