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.
24 #include "link_uniform_block_active_visitor.h"
27 static link_uniform_block_active
*
28 process_block(void *mem_ctx
, struct hash_table
*ht
, ir_variable
*var
)
30 const hash_entry
*const existing_block
=
31 _mesa_hash_table_search(ht
, var
->get_interface_type()->name
);
33 const glsl_type
*const block_type
= var
->is_interface_instance()
34 ? var
->type
: var
->get_interface_type();
37 /* If a block with this block-name has not previously been seen, add it.
38 * If a block with this block-name has been seen, it must be identical to
39 * the block currently being examined.
41 if (existing_block
== NULL
) {
42 link_uniform_block_active
*const b
=
43 rzalloc(mem_ctx
, struct link_uniform_block_active
);
46 b
->has_instance_name
= var
->is_interface_instance();
47 b
->is_shader_storage
= var
->data
.mode
== ir_var_shader_storage
;
49 if (var
->data
.explicit_binding
) {
50 b
->has_binding
= true;
51 b
->binding
= var
->data
.binding
;
53 b
->has_binding
= false;
57 _mesa_hash_table_insert(ht
, var
->get_interface_type()->name
, (void *) b
);
60 link_uniform_block_active
*const b
=
61 (link_uniform_block_active
*) existing_block
->data
;
63 if (b
->type
!= block_type
64 || b
->has_instance_name
!= var
->is_interface_instance())
70 assert(!"Should not get here.");
74 /* For arrays of arrays this function will give us a middle ground between
75 * detecting inactive uniform blocks and structuring them in a way that makes
76 * it easy to calculate the offset for indirect indexing.
78 * For example given the shader:
80 * uniform ArraysOfArraysBlock
87 * vec4 b = i[0][1][1].a;
88 * gl_Position = i[2][2][3].a + b;
91 * There are only 2 active blocks above but for the sake of indirect indexing
92 * and not over complicating the code we will end up with a count of 8.
93 * Here each dimension has 2 different indices counted so we end up with 2*2*2
95 static struct uniform_block_array_elements
**
96 process_arrays(void *mem_ctx
, ir_dereference_array
*ir
,
97 struct link_uniform_block_active
*block
)
100 struct uniform_block_array_elements
**ub_array_ptr
=
101 process_arrays(mem_ctx
, ir
->array
->as_dereference_array(), block
);
102 if (*ub_array_ptr
== NULL
) {
103 *ub_array_ptr
= rzalloc(mem_ctx
, struct uniform_block_array_elements
);
104 (*ub_array_ptr
)->ir
= ir
;
107 struct uniform_block_array_elements
*ub_array
= *ub_array_ptr
;
108 ir_constant
*c
= ir
->array_index
->as_constant();
110 /* Index is a constant, so mark just that element used,
113 const unsigned idx
= c
->get_uint_component(0);
116 for (i
= 0; i
< ub_array
->num_array_elements
; i
++) {
117 if (ub_array
->array_elements
[i
] == idx
)
121 assert(i
<= ub_array
->num_array_elements
);
123 if (i
== ub_array
->num_array_elements
) {
124 ub_array
->array_elements
= reralloc(mem_ctx
,
125 ub_array
->array_elements
,
127 ub_array
->num_array_elements
+ 1);
129 ub_array
->array_elements
[ub_array
->num_array_elements
] = idx
;
131 ub_array
->num_array_elements
++;
134 /* The array index is not a constant,
135 * so mark the entire array used.
137 assert(ir
->array
->type
->is_array());
138 if (ub_array
->num_array_elements
< ir
->array
->type
->length
) {
139 ub_array
->num_array_elements
= ir
->array
->type
->length
;
140 ub_array
->array_elements
= reralloc(mem_ctx
,
141 ub_array
->array_elements
,
143 ub_array
->num_array_elements
);
145 for (unsigned i
= 0; i
< ub_array
->num_array_elements
; i
++) {
146 ub_array
->array_elements
[i
] = i
;
150 return &ub_array
->array
;
152 return &block
->array
;
157 link_uniform_block_active_visitor::visit(ir_variable
*var
)
159 if (!var
->is_in_buffer_block())
160 return visit_continue
;
162 /* Section 2.11.6 (Uniform Variables) of the OpenGL ES 3.0.3 spec says:
164 * "All members of a named uniform block declared with a shared or
165 * std140 layout qualifier are considered active, even if they are not
166 * referenced in any shader in the program. The uniform block itself is
167 * also considered active, even if no member of the block is
170 if (var
->get_interface_type_packing() == GLSL_INTERFACE_PACKING_PACKED
)
171 return visit_continue
;
173 /* Process the block. Bail if there was an error.
175 link_uniform_block_active
*const b
=
176 process_block(this->mem_ctx
, this->ht
, var
);
178 linker_error(this->prog
,
179 "uniform block `%s' has mismatching definitions",
180 var
->get_interface_type()->name
);
181 this->success
= false;
185 assert(b
->array
== NULL
);
186 assert(b
->type
!= NULL
);
187 assert(!b
->type
->is_array() || b
->has_instance_name
);
189 /* For uniform block arrays declared with a shared or std140 layout
190 * qualifier, mark all its instances as used.
192 const glsl_type
*type
= b
->type
;
193 struct uniform_block_array_elements
**ub_array
= &b
->array
;
194 while (type
->is_array()) {
195 assert(b
->type
->length
> 0);
197 *ub_array
= rzalloc(this->mem_ctx
, struct uniform_block_array_elements
);
198 (*ub_array
)->num_array_elements
= type
->length
;
199 (*ub_array
)->array_elements
= reralloc(this->mem_ctx
,
200 (*ub_array
)->array_elements
,
202 (*ub_array
)->num_array_elements
);
204 for (unsigned i
= 0; i
< (*ub_array
)->num_array_elements
; i
++) {
205 (*ub_array
)->array_elements
[i
] = i
;
207 ub_array
= &(*ub_array
)->array
;
208 type
= type
->fields
.array
;
211 return visit_continue
;
215 link_uniform_block_active_visitor::visit_enter(ir_dereference_array
*ir
)
217 /* cycle through arrays of arrays */
218 ir_dereference_array
*base_ir
= ir
;
219 while (base_ir
->array
->ir_type
== ir_type_dereference_array
)
220 base_ir
= base_ir
->array
->as_dereference_array();
222 ir_dereference_variable
*const d
=
223 base_ir
->array
->as_dereference_variable();
224 ir_variable
*const var
= (d
== NULL
) ? NULL
: d
->var
;
226 /* If the r-value being dereferenced is not a variable (e.g., a field of a
227 * structure) or is not a uniform block instance, continue.
229 * WARNING: It is not enough for the variable to be part of uniform block.
230 * It must represent the entire block. Arrays (or matrices) inside blocks
231 * that lack an instance name are handled by the ir_dereference_variable
235 || !var
->is_in_buffer_block()
236 || !var
->is_interface_instance())
237 return visit_continue
;
239 /* Process the block. Bail if there was an error.
241 link_uniform_block_active
*const b
=
242 process_block(this->mem_ctx
, this->ht
, var
);
245 "uniform block `%s' has mismatching definitions",
246 var
->get_interface_type()->name
);
247 this->success
= false;
251 /* Block arrays must be declared with an instance name.
253 assert(b
->has_instance_name
);
254 assert(b
->type
!= NULL
);
256 /* If the block array was declared with a shared or
257 * std140 layout qualifier, all its instances have been already marked
258 * as used in link_uniform_block_active_visitor::visit(ir_variable *).
260 if (var
->get_interface_type_packing() == GLSL_INTERFACE_PACKING_PACKED
) {
262 process_arrays(this->mem_ctx
, ir
, b
);
265 return visit_continue_with_parent
;
269 link_uniform_block_active_visitor::visit(ir_dereference_variable
*ir
)
271 ir_variable
*var
= ir
->var
;
273 if (!var
->is_in_buffer_block())
274 return visit_continue
;
276 assert(!var
->is_interface_instance() || !var
->type
->is_array());
278 /* Process the block. Bail if there was an error.
280 link_uniform_block_active
*const b
=
281 process_block(this->mem_ctx
, this->ht
, var
);
283 linker_error(this->prog
,
284 "uniform block `%s' has mismatching definitions",
285 var
->get_interface_type()->name
);
286 this->success
= false;
290 assert(b
->array
== NULL
);
291 assert(b
->type
!= NULL
);
293 return visit_continue
;