2 * Copyright © 2015 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 DEALINGS
24 #include "compiler/brw_nir.h"
25 #include "compiler/glsl/ir_uniform.h"
26 #include "brw_program.h"
29 brw_nir_setup_glsl_builtin_uniform(nir_variable
*var
,
30 const struct gl_program
*prog
,
31 struct brw_stage_prog_data
*stage_prog_data
,
34 const nir_state_slot
*const slots
= var
->state_slots
;
35 assert(var
->state_slots
!= NULL
);
37 unsigned uniform_index
= var
->data
.driver_location
/ 4;
38 for (unsigned int i
= 0; i
< var
->num_state_slots
; i
++) {
39 /* This state reference has already been setup by ir_to_mesa, but we'll
40 * get the same index back here.
42 int index
= _mesa_add_state_reference(prog
->Parameters
,
45 /* Add each of the unique swizzles of the element as a parameter.
46 * This'll end up matching the expected layout of the
47 * array/matrix/structure we're trying to fill in.
50 for (unsigned j
= 0; j
< 4; j
++) {
51 int swiz
= GET_SWZ(slots
[i
].swizzle
, j
);
53 /* If we hit a pair of identical swizzles, this means we've hit the
54 * end of the builtin variable. In scalar mode, we should just quit
55 * and move on to the next one. In vec4, we need to continue and pad
56 * it out to 4 components.
58 if (swiz
== last_swiz
&& is_scalar
)
63 stage_prog_data
->param
[uniform_index
++] =
64 BRW_PARAM_PARAMETER(index
, swiz
);
70 setup_vec4_image_param(uint32_t *params
, uint32_t idx
,
71 unsigned offset
, unsigned n
)
73 assert(offset
% sizeof(uint32_t) == 0);
74 for (unsigned i
= 0; i
< n
; ++i
)
75 params
[i
] = BRW_PARAM_IMAGE(idx
, offset
/ sizeof(uint32_t) + i
);
77 for (unsigned i
= n
; i
< 4; ++i
)
78 params
[i
] = BRW_PARAM_BUILTIN_ZERO
;
82 brw_setup_image_uniform_values(gl_shader_stage stage
,
83 struct brw_stage_prog_data
*stage_prog_data
,
84 unsigned param_start_index
,
85 const gl_uniform_storage
*storage
)
87 uint32_t *param
= &stage_prog_data
->param
[param_start_index
];
89 for (unsigned i
= 0; i
< MAX2(storage
->array_elements
, 1); i
++) {
90 const unsigned image_idx
= storage
->opaque
[stage
].index
+ i
;
92 /* Upload the brw_image_param structure. The order is expected to match
93 * the BRW_IMAGE_PARAM_*_OFFSET defines.
95 setup_vec4_image_param(param
+ BRW_IMAGE_PARAM_SURFACE_IDX_OFFSET
,
97 offsetof(brw_image_param
, surface_idx
), 1);
98 setup_vec4_image_param(param
+ BRW_IMAGE_PARAM_OFFSET_OFFSET
,
100 offsetof(brw_image_param
, offset
), 2);
101 setup_vec4_image_param(param
+ BRW_IMAGE_PARAM_SIZE_OFFSET
,
103 offsetof(brw_image_param
, size
), 3);
104 setup_vec4_image_param(param
+ BRW_IMAGE_PARAM_STRIDE_OFFSET
,
106 offsetof(brw_image_param
, stride
), 4);
107 setup_vec4_image_param(param
+ BRW_IMAGE_PARAM_TILING_OFFSET
,
109 offsetof(brw_image_param
, tiling
), 3);
110 setup_vec4_image_param(param
+ BRW_IMAGE_PARAM_SWIZZLING_OFFSET
,
112 offsetof(brw_image_param
, swizzling
), 2);
113 param
+= BRW_IMAGE_PARAM_SIZE
;
115 brw_mark_surface_used(
117 stage_prog_data
->binding_table
.image_start
+ image_idx
);
122 brw_nir_setup_glsl_uniform(gl_shader_stage stage
, nir_variable
*var
,
123 const struct gl_program
*prog
,
124 struct brw_stage_prog_data
*stage_prog_data
,
127 int namelen
= strlen(var
->name
);
129 /* The data for our (non-builtin) uniforms is stored in a series of
130 * gl_uniform_storage structs for each subcomponent that
131 * glGetUniformLocation() could name. We know it's been set up in the same
132 * order we'd walk the type, so walk the list of storage and find anything
133 * with our name, or the prefix of a component that starts with our name.
135 unsigned uniform_index
= var
->data
.driver_location
/ 4;
136 for (unsigned u
= 0; u
< prog
->sh
.data
->NumUniformStorage
; u
++) {
137 struct gl_uniform_storage
*storage
=
138 &prog
->sh
.data
->UniformStorage
[u
];
140 if (storage
->builtin
|| storage
->type
->is_sampler())
143 if (strncmp(var
->name
, storage
->name
, namelen
) != 0 ||
144 (storage
->name
[namelen
] != 0 &&
145 storage
->name
[namelen
] != '.' &&
146 storage
->name
[namelen
] != '[')) {
150 if (storage
->type
->is_image()) {
151 brw_setup_image_uniform_values(stage
, stage_prog_data
,
152 uniform_index
, storage
);
154 BRW_IMAGE_PARAM_SIZE
* MAX2(storage
->array_elements
, 1);
156 gl_constant_value
*components
= storage
->storage
;
157 unsigned vector_count
= (MAX2(storage
->array_elements
, 1) *
158 storage
->type
->matrix_columns
);
159 unsigned vector_size
= storage
->type
->vector_elements
;
160 unsigned max_vector_size
= 4;
161 if (storage
->type
->base_type
== GLSL_TYPE_DOUBLE
||
162 storage
->type
->base_type
== GLSL_TYPE_UINT64
||
163 storage
->type
->base_type
== GLSL_TYPE_INT64
) {
169 for (unsigned s
= 0; s
< vector_count
; s
++) {
171 for (i
= 0; i
< vector_size
; i
++) {
172 uint32_t idx
= components
- prog
->sh
.data
->UniformDataSlots
;
173 stage_prog_data
->param
[uniform_index
++] = BRW_PARAM_UNIFORM(idx
);
178 /* Pad out with zeros if needed (only needed for vec4) */
179 for (; i
< max_vector_size
; i
++) {
180 stage_prog_data
->param
[uniform_index
++] =
181 BRW_PARAM_BUILTIN_ZERO
;
190 brw_nir_setup_glsl_uniforms(void *mem_ctx
, nir_shader
*shader
,
191 const struct gl_program
*prog
,
192 struct brw_stage_prog_data
*stage_prog_data
,
195 unsigned nr_params
= shader
->num_uniforms
/ 4;
196 stage_prog_data
->nr_params
= nr_params
;
197 stage_prog_data
->param
= rzalloc_array(mem_ctx
, uint32_t, nr_params
);
199 nir_foreach_variable(var
, &shader
->uniforms
) {
200 /* UBO's, atomics and samplers don't take up space in the
202 if (var
->interface_type
!= NULL
|| var
->type
->contains_atomic())
205 if (strncmp(var
->name
, "gl_", 3) == 0) {
206 brw_nir_setup_glsl_builtin_uniform(var
, prog
, stage_prog_data
,
209 brw_nir_setup_glsl_uniform(shader
->info
.stage
, var
, prog
,
210 stage_prog_data
, is_scalar
);
216 brw_nir_setup_arb_uniforms(void *mem_ctx
, nir_shader
*shader
,
217 struct gl_program
*prog
,
218 struct brw_stage_prog_data
*stage_prog_data
)
220 struct gl_program_parameter_list
*plist
= prog
->Parameters
;
222 unsigned nr_params
= plist
->NumParameters
* 4;
223 stage_prog_data
->nr_params
= nr_params
;
224 stage_prog_data
->param
= rzalloc_array(mem_ctx
, uint32_t, nr_params
);
226 /* For ARB programs, prog_to_nir generates a single "parameters" variable
227 * for all uniform data. nir_lower_wpos_ytransform may also create an
228 * additional variable.
230 assert(shader
->uniforms
.length() <= 2);
232 for (unsigned p
= 0; p
< plist
->NumParameters
; p
++) {
233 /* Parameters should be either vec4 uniforms or single component
234 * constants; matrices and other larger types should have been broken
237 assert(plist
->Parameters
[p
].Size
<= 4);
240 for (i
= 0; i
< plist
->Parameters
[p
].Size
; i
++)
241 stage_prog_data
->param
[4 * p
+ i
] = BRW_PARAM_PARAMETER(p
, i
);
243 stage_prog_data
->param
[4 * p
+ i
] = BRW_PARAM_BUILTIN_ZERO
;
248 brw_nir_lower_patch_vertices_in_to_uniform(nir_shader
*nir
)
250 nir_foreach_variable_safe(var
, &nir
->system_values
) {
251 if (var
->data
.location
!= SYSTEM_VALUE_VERTICES_IN
)
254 gl_state_index16 tokens
[STATE_LENGTH
] = {
256 nir
->info
.stage
== MESA_SHADER_TESS_CTRL
?
257 STATE_TCS_PATCH_VERTICES_IN
: STATE_TES_PATCH_VERTICES_IN
,
259 var
->num_state_slots
= 1;
261 ralloc_array(var
, nir_state_slot
, var
->num_state_slots
);
262 memcpy(var
->state_slots
[0].tokens
, tokens
, sizeof(tokens
));
263 var
->state_slots
[0].swizzle
= SWIZZLE_XXXX
;
265 var
->data
.mode
= nir_var_uniform
;
266 var
->data
.location
= -1;
267 exec_node_remove(&var
->node
);
268 exec_list_push_tail(&nir
->uniforms
, &var
->node
);