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 link_shaders(struct glsl_program
*prog
)
176 prog
->LinkStatus
= false;
177 prog
->Validated
= false;
180 /* Separate the shaders into groups based on their type.
182 struct glsl_shader
**vert_shader_list
;
183 unsigned num_vert_shaders
= 0;
184 struct glsl_shader
**frag_shader_list
;
185 unsigned num_frag_shaders
= 0;
187 vert_shader_list
= (struct glsl_shader
**)
188 calloc(2 * prog
->NumShaders
, sizeof(struct glsl_shader
*));
189 frag_shader_list
= &vert_shader_list
[prog
->NumShaders
];
191 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
192 switch (prog
->Shaders
[i
]->Type
) {
193 case GL_VERTEX_SHADER
:
194 vert_shader_list
[num_vert_shaders
] = prog
->Shaders
[i
];
197 case GL_FRAGMENT_SHADER
:
198 frag_shader_list
[num_frag_shaders
] = prog
->Shaders
[i
];
201 case GL_GEOMETRY_SHADER
:
202 /* FINISHME: Support geometry shaders. */
203 assert(prog
->Shaders
[i
]->Type
!= GL_GEOMETRY_SHADER
);
208 /* FINISHME: Implement intra-stage linking. */
209 assert(num_vert_shaders
<= 1);
210 assert(num_frag_shaders
<= 1);
212 /* Verify that each of the per-target executables is valid.
214 if (!validate_vertex_shader_executable(vert_shader_list
[0])
215 || !validate_fragment_shader_executable(frag_shader_list
[0]))
219 /* FINISHME: Perform inter-stage linking. */
221 prog
->LinkStatus
= true;
224 free(vert_shader_list
);