2 * Copyright © 2013 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.
25 * \file link_interface_blocks.cpp
26 * Linker support for GLSL's interface blocks.
30 #include "glsl_symbol_table.h"
32 #include "main/macros.h"
33 #include "program/hash_table.h"
39 * Information about a single interface block definition that we need to keep
40 * track of in order to check linkage rules.
42 * Note: this class is expected to be short lived, so it doesn't make copies
43 * of the strings it references; it simply borrows the pointers from the
46 struct interface_block_definition
49 * Extract an interface block definition from an ir_variable that
50 * represents either the interface instance (for named interfaces), or a
51 * member of the interface (for unnamed interfaces).
53 explicit interface_block_definition(const ir_variable
*var
)
54 : type(var
->get_interface_type()),
58 if (var
->is_interface_instance()) {
59 instance_name
= var
->name
;
60 if (var
->type
->is_array())
61 array_size
= var
->type
->length
;
63 explicitly_declared
= (var
->how_declared
!= ir_var_declared_implicitly
);
67 * Interface block type
69 const glsl_type
*type
;
72 * For a named interface block, the instance name. Otherwise NULL.
74 const char *instance_name
;
77 * For an interface block array, the array size (or 0 if unsized).
83 * True if this interface block was explicitly declared in the shader;
84 * false if it was an implicitly declared built-in interface block.
86 bool explicitly_declared
;
91 * Check if two interfaces match, according to intrastage interface matching
92 * rules. If they do, and the first interface uses an unsized array, it will
93 * be updated to reflect the array size declared in the second interface.
96 intrastage_match(interface_block_definition
*a
,
97 const interface_block_definition
*b
,
98 ir_variable_mode mode
)
100 /* Types must match. */
101 if (a
->type
!= b
->type
) {
102 /* Exception: if both the interface blocks are implicitly declared,
103 * don't force their types to match. They might mismatch due to the two
104 * shaders using different GLSL versions, and that's ok.
106 if (a
->explicitly_declared
|| b
->explicitly_declared
)
110 /* Presence/absence of interface names must match. */
111 if ((a
->instance_name
== NULL
) != (b
->instance_name
== NULL
))
114 /* For uniforms, instance names need not match. For shader ins/outs,
115 * it's not clear from the spec whether they need to match, but
116 * Mesa's implementation relies on them matching.
118 if (a
->instance_name
!= NULL
&& mode
!= ir_var_uniform
&&
119 strcmp(a
->instance_name
, b
->instance_name
) != 0) {
123 /* Array vs. nonarray must be consistent, and sizes must be
124 * consistent, with the exception that unsized arrays match sized
127 if ((a
->array_size
== -1) != (b
->array_size
== -1))
129 if (b
->array_size
!= 0) {
130 if (a
->array_size
== 0)
131 a
->array_size
= b
->array_size
;
132 else if (a
->array_size
!= b
->array_size
)
141 * Check if two interfaces match, according to interstage (in/out) interface
144 * If \c extra_array_level is true, then vertex-to-geometry shader matching
145 * rules are enforced (i.e. a successful match requires the consumer interface
146 * to be an array and the producer interface to be a non-array).
149 interstage_match(const interface_block_definition
*producer
,
150 const interface_block_definition
*consumer
,
151 bool extra_array_level
)
153 /* Unsized arrays should not occur during interstage linking. They
154 * should have all been assigned a size by link_intrastage_shaders.
156 assert(consumer
->array_size
!= 0);
157 assert(producer
->array_size
!= 0);
159 /* Types must match. */
160 if (consumer
->type
!= producer
->type
) {
161 /* Exception: if both the interface blocks are implicitly declared,
162 * don't force their types to match. They might mismatch due to the two
163 * shaders using different GLSL versions, and that's ok.
165 if (consumer
->explicitly_declared
|| producer
->explicitly_declared
)
168 if (extra_array_level
) {
169 /* Consumer must be an array, and producer must not. */
170 if (consumer
->array_size
== -1)
172 if (producer
->array_size
!= -1)
175 /* Array vs. nonarray must be consistent, and sizes must be consistent.
176 * Since unsized arrays have been ruled out, we can check this by just
177 * making sure the sizes are equal.
179 if (consumer
->array_size
!= producer
->array_size
)
187 * This class keeps track of a mapping from an interface block name to the
188 * necessary information about that interface block to determine whether to
189 * generate a link error.
191 * Note: this class is expected to be short lived, so it doesn't make copies
192 * of the strings it references; it simply borrows the pointers from the
195 class interface_block_definitions
198 interface_block_definitions()
199 : mem_ctx(ralloc_context(NULL
)),
200 ht(hash_table_ctor(0, hash_table_string_hash
,
201 hash_table_string_compare
))
205 ~interface_block_definitions()
208 ralloc_free(mem_ctx
);
212 * Lookup the interface definition having the given block name. Return
213 * NULL if none is found.
215 interface_block_definition
*lookup(const char *block_name
)
217 return (interface_block_definition
*) hash_table_find(ht
, block_name
);
221 * Add a new interface definition.
223 void store(const interface_block_definition
&def
)
225 interface_block_definition
*hash_entry
=
226 rzalloc(mem_ctx
, interface_block_definition
);
228 hash_table_insert(ht
, hash_entry
, def
.type
->name
);
233 * Ralloc context for data structures allocated by this class.
238 * Hash table mapping interface block name to an \c
239 * interface_block_definition struct. interface_block_definition structs
240 * are allocated using \c mem_ctx.
246 }; /* anonymous namespace */
250 validate_intrastage_interface_blocks(struct gl_shader_program
*prog
,
251 const gl_shader
**shader_list
,
252 unsigned num_shaders
)
254 interface_block_definitions in_interfaces
;
255 interface_block_definitions out_interfaces
;
256 interface_block_definitions uniform_interfaces
;
258 for (unsigned int i
= 0; i
< num_shaders
; i
++) {
259 if (shader_list
[i
] == NULL
)
262 foreach_list(node
, shader_list
[i
]->ir
) {
263 ir_variable
*var
= ((ir_instruction
*) node
)->as_variable();
267 const glsl_type
*iface_type
= var
->get_interface_type();
269 if (iface_type
== NULL
)
272 interface_block_definitions
*definitions
;
274 case ir_var_shader_in
:
275 definitions
= &in_interfaces
;
277 case ir_var_shader_out
:
278 definitions
= &out_interfaces
;
281 definitions
= &uniform_interfaces
;
284 /* Only in, out, and uniform interfaces are legal, so we should
287 assert(!"illegal interface type");
291 const interface_block_definition
def(var
);
292 interface_block_definition
*prev_def
=
293 definitions
->lookup(iface_type
->name
);
295 if (prev_def
== NULL
) {
296 /* This is the first time we've seen the interface, so save
297 * it into the appropriate data structure.
299 definitions
->store(def
);
300 } else if (!intrastage_match(prev_def
, &def
,
301 (ir_variable_mode
) var
->mode
)) {
302 linker_error(prog
, "definitions of interface block `%s' do not"
303 " match\n", iface_type
->name
);
311 validate_interstage_inout_blocks(struct gl_shader_program
*prog
,
312 const gl_shader
*producer
,
313 const gl_shader
*consumer
)
315 interface_block_definitions definitions
;
316 const bool extra_array_level
= consumer
->Type
== GL_GEOMETRY_SHADER
;
318 /* Add input interfaces from the consumer to the symbol table. */
319 foreach_list(node
, consumer
->ir
) {
320 ir_variable
*var
= ((ir_instruction
*) node
)->as_variable();
321 if (!var
|| !var
->get_interface_type() || var
->mode
!= ir_var_shader_in
)
324 definitions
.store(interface_block_definition(var
));
327 /* Verify that the producer's output interfaces match. */
328 foreach_list(node
, producer
->ir
) {
329 ir_variable
*var
= ((ir_instruction
*) node
)->as_variable();
330 if (!var
|| !var
->get_interface_type() || var
->mode
!= ir_var_shader_out
)
333 interface_block_definition
*consumer_def
=
334 definitions
.lookup(var
->get_interface_type()->name
);
336 /* The consumer doesn't use this output block. Ignore it. */
337 if (consumer_def
== NULL
)
340 const interface_block_definition
producer_def(var
);
342 if (!interstage_match(&producer_def
, consumer_def
, extra_array_level
)) {
343 linker_error(prog
, "definitions of interface block `%s' do not "
344 "match\n", var
->get_interface_type()->name
);
352 validate_interstage_uniform_blocks(struct gl_shader_program
*prog
,
353 gl_shader
**stages
, int num_stages
)
355 interface_block_definitions definitions
;
357 for (int i
= 0; i
< num_stages
; i
++) {
358 if (stages
[i
] == NULL
)
361 const gl_shader
*stage
= stages
[i
];
362 foreach_list(node
, stage
->ir
) {
363 ir_variable
*var
= ((ir_instruction
*) node
)->as_variable();
364 if (!var
|| !var
->get_interface_type() || var
->mode
!= ir_var_uniform
)
367 interface_block_definition
*old_def
=
368 definitions
.lookup(var
->get_interface_type()->name
);
369 const interface_block_definition
new_def(var
);
370 if (old_def
== NULL
) {
371 definitions
.store(new_def
);
373 /* Interstage uniform matching rules are the same as intrastage
374 * uniform matchin rules (for uniforms, it is as though all
375 * shaders are in the same shader stage).
377 if (!intrastage_match(old_def
, &new_def
, ir_var_uniform
)) {
378 linker_error(prog
, "definitions of interface block `%s' do not "
379 "match\n", var
->get_interface_type()->name
);