05cf5107d6ef256cd875463302e5016ccaac8890
[mesa.git] / src / compiler / nir / nir_lower_system_values.c
1 /*
2 * Copyright © 2014 Intel Corporation
3 *
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:
10 *
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
13 * Software.
14 *
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
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Connor Abbott (cwabbott0@gmail.com)
25 *
26 */
27
28 #include "nir.h"
29 #include "nir_builder.h"
30
31 static nir_ssa_def *
32 sanitize_32bit_sysval(nir_builder *b, nir_intrinsic_instr *intrin)
33 {
34 assert(intrin->dest.is_ssa);
35 const unsigned bit_size = intrin->dest.ssa.bit_size;
36 if (bit_size == 32)
37 return NULL;
38
39 intrin->dest.ssa.bit_size = 32;
40 return nir_u2u(b, &intrin->dest.ssa, bit_size);
41 }
42
43 static nir_ssa_def*
44 build_global_group_size(nir_builder *b, unsigned bit_size)
45 {
46 nir_ssa_def *group_size = nir_load_local_group_size(b);
47 nir_ssa_def *num_work_groups = nir_load_num_work_groups(b);
48 return nir_imul(b, nir_u2u(b, group_size, bit_size),
49 nir_u2u(b, num_work_groups, bit_size));
50 }
51
52 static bool
53 lower_system_value_filter(const nir_instr *instr, const void *_state)
54 {
55 return instr->type == nir_instr_type_intrinsic;
56 }
57
58 static nir_ssa_def *
59 lower_system_value_instr(nir_builder *b, nir_instr *instr, void *_state)
60 {
61 nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
62
63 /* All the intrinsics we care about are loads */
64 if (!nir_intrinsic_infos[intrin->intrinsic].has_dest)
65 return NULL;
66
67 assert(intrin->dest.is_ssa);
68 const unsigned bit_size = intrin->dest.ssa.bit_size;
69
70 switch (intrin->intrinsic) {
71 case nir_intrinsic_load_vertex_id:
72 if (b->shader->options->vertex_id_zero_based) {
73 return nir_iadd(b, nir_load_vertex_id_zero_base(b),
74 nir_load_first_vertex(b));
75 } else {
76 return NULL;
77 }
78
79 case nir_intrinsic_load_base_vertex:
80 /**
81 * From the OpenGL 4.6 (11.1.3.9 Shader Inputs) specification:
82 *
83 * "gl_BaseVertex holds the integer value passed to the baseVertex
84 * parameter to the command that resulted in the current shader
85 * invocation. In the case where the command has no baseVertex
86 * parameter, the value of gl_BaseVertex is zero."
87 */
88 if (b->shader->options->lower_base_vertex) {
89 return nir_iand(b, nir_load_is_indexed_draw(b),
90 nir_load_first_vertex(b));
91 } else {
92 return NULL;
93 }
94
95 case nir_intrinsic_load_local_invocation_id:
96 /* If lower_cs_local_id_from_index is true, then we derive the local
97 * index from the local id.
98 */
99 if (b->shader->options->lower_cs_local_id_from_index) {
100 /* We lower gl_LocalInvocationID from gl_LocalInvocationIndex based
101 * on this formula:
102 *
103 * gl_LocalInvocationID.x =
104 * gl_LocalInvocationIndex % gl_WorkGroupSize.x;
105 * gl_LocalInvocationID.y =
106 * (gl_LocalInvocationIndex / gl_WorkGroupSize.x) %
107 * gl_WorkGroupSize.y;
108 * gl_LocalInvocationID.z =
109 * (gl_LocalInvocationIndex /
110 * (gl_WorkGroupSize.x * gl_WorkGroupSize.y)) %
111 * gl_WorkGroupSize.z;
112 *
113 * However, the final % gl_WorkGroupSize.z does nothing unless we
114 * accidentally end up with a gl_LocalInvocationIndex that is too
115 * large so it can safely be omitted.
116 */
117 nir_ssa_def *local_index = nir_load_local_invocation_index(b);
118 nir_ssa_def *local_size = nir_load_local_group_size(b);
119
120 /* Because no hardware supports a local workgroup size greater than
121 * about 1K, this calculation can be done in 32-bit and can save some
122 * 64-bit arithmetic.
123 */
124 nir_ssa_def *id_x, *id_y, *id_z;
125 id_x = nir_umod(b, local_index,
126 nir_channel(b, local_size, 0));
127 id_y = nir_umod(b, nir_udiv(b, local_index,
128 nir_channel(b, local_size, 0)),
129 nir_channel(b, local_size, 1));
130 id_z = nir_udiv(b, local_index,
131 nir_imul(b, nir_channel(b, local_size, 0),
132 nir_channel(b, local_size, 1)));
133 return nir_u2u(b, nir_vec3(b, id_x, id_y, id_z), bit_size);
134 } else {
135 return sanitize_32bit_sysval(b, intrin);
136 }
137
138 case nir_intrinsic_load_local_invocation_index:
139 /* If lower_cs_local_index_from_id is true, then we derive the local
140 * index from the local id.
141 */
142 if (b->shader->options->lower_cs_local_index_from_id) {
143 /* From the GLSL man page for gl_LocalInvocationIndex:
144 *
145 * "The value of gl_LocalInvocationIndex is equal to
146 * gl_LocalInvocationID.z * gl_WorkGroupSize.x *
147 * gl_WorkGroupSize.y + gl_LocalInvocationID.y *
148 * gl_WorkGroupSize.x + gl_LocalInvocationID.x"
149 */
150 nir_ssa_def *local_id = nir_load_local_invocation_id(b);
151
152 nir_ssa_def *size_x =
153 nir_imm_int(b, b->shader->info.cs.local_size[0]);
154 nir_ssa_def *size_y =
155 nir_imm_int(b, b->shader->info.cs.local_size[1]);
156
157 /* Because no hardware supports a local workgroup size greater than
158 * about 1K, this calculation can be done in 32-bit and can save some
159 * 64-bit arithmetic.
160 */
161 nir_ssa_def *index;
162 index = nir_imul(b, nir_channel(b, local_id, 2),
163 nir_imul(b, size_x, size_y));
164 index = nir_iadd(b, index,
165 nir_imul(b, nir_channel(b, local_id, 1), size_x));
166 index = nir_iadd(b, index, nir_channel(b, local_id, 0));
167 return nir_u2u(b, index, bit_size);
168 } else {
169 return sanitize_32bit_sysval(b, intrin);
170 }
171
172 case nir_intrinsic_load_local_group_size:
173 if (b->shader->info.cs.local_size_variable) {
174 /* If the local work group size is variable it can't be lowered at
175 * this point. We do, however, have to make sure that the intrinsic
176 * is only 32-bit.
177 */
178 return sanitize_32bit_sysval(b, intrin);
179 } else {
180 /* using a 32 bit constant is safe here as no device/driver needs more
181 * than 32 bits for the local size */
182 nir_const_value local_size_const[3];
183 memset(local_size_const, 0, sizeof(local_size_const));
184 local_size_const[0].u32 = b->shader->info.cs.local_size[0];
185 local_size_const[1].u32 = b->shader->info.cs.local_size[1];
186 local_size_const[2].u32 = b->shader->info.cs.local_size[2];
187 return nir_u2u(b, nir_build_imm(b, 3, 32, local_size_const), bit_size);
188 }
189
190 case nir_intrinsic_load_global_invocation_id: {
191 nir_ssa_def *group_size = nir_load_local_group_size(b);
192 nir_ssa_def *group_id = nir_load_work_group_id(b);
193 nir_ssa_def *local_id = nir_load_local_invocation_id(b);
194
195 return nir_iadd(b, nir_imul(b, nir_u2u(b, group_id, bit_size),
196 nir_u2u(b, group_size, bit_size)),
197 nir_u2u(b, local_id, bit_size));
198 }
199
200 case nir_intrinsic_load_global_invocation_index: {
201 nir_ssa_def *global_id = nir_load_global_invocation_id(b, bit_size);
202 nir_ssa_def *global_size = build_global_group_size(b, bit_size);
203
204 /* index = id.x + ((id.y + (id.z * size.y)) * size.x) */
205 nir_ssa_def *index;
206 index = nir_imul(b, nir_channel(b, global_id, 2),
207 nir_channel(b, global_size, 1));
208 index = nir_iadd(b, nir_channel(b, global_id, 1), index);
209 index = nir_imul(b, nir_channel(b, global_size, 0), index);
210 index = nir_iadd(b, nir_channel(b, global_id, 0), index);
211 return index;
212 }
213
214 case nir_intrinsic_load_helper_invocation:
215 if (b->shader->options->lower_helper_invocation) {
216 nir_ssa_def *tmp;
217 tmp = nir_ishl(b, nir_imm_int(b, 1),
218 nir_load_sample_id_no_per_sample(b));
219 tmp = nir_iand(b, nir_load_sample_mask_in(b), tmp);
220 return nir_inot(b, nir_i2b(b, tmp));
221 } else {
222 return NULL;
223 }
224
225 case nir_intrinsic_load_num_work_groups:
226 case nir_intrinsic_load_work_group_id:
227 return sanitize_32bit_sysval(b, intrin);
228
229 case nir_intrinsic_load_deref: {
230 nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
231 if (deref->mode != nir_var_system_value)
232 return NULL;
233
234 if (deref->deref_type != nir_deref_type_var) {
235 /* The only one system value that is an array and that is
236 * gl_SampleMask which is always an array of one element.
237 */
238 assert(deref->deref_type == nir_deref_type_array);
239 deref = nir_deref_instr_parent(deref);
240 assert(deref->deref_type == nir_deref_type_var);
241 assert(deref->var->data.location == SYSTEM_VALUE_SAMPLE_MASK_IN);
242 }
243 nir_variable *var = deref->var;
244
245 switch (var->data.location) {
246 case SYSTEM_VALUE_INSTANCE_INDEX:
247 return nir_iadd(b, nir_load_instance_id(b),
248 nir_load_base_instance(b));
249
250 case SYSTEM_VALUE_SUBGROUP_EQ_MASK:
251 case SYSTEM_VALUE_SUBGROUP_GE_MASK:
252 case SYSTEM_VALUE_SUBGROUP_GT_MASK:
253 case SYSTEM_VALUE_SUBGROUP_LE_MASK:
254 case SYSTEM_VALUE_SUBGROUP_LT_MASK: {
255 nir_intrinsic_op op =
256 nir_intrinsic_from_system_value(var->data.location);
257 nir_intrinsic_instr *load = nir_intrinsic_instr_create(b->shader, op);
258 nir_ssa_dest_init_for_type(&load->instr, &load->dest,
259 var->type, NULL);
260 load->num_components = load->dest.ssa.num_components;
261 nir_builder_instr_insert(b, &load->instr);
262 return &load->dest.ssa;
263 }
264
265 case SYSTEM_VALUE_DEVICE_INDEX:
266 if (b->shader->options->lower_device_index_to_zero)
267 return nir_imm_int(b, 0);
268 break;
269
270 case SYSTEM_VALUE_GLOBAL_GROUP_SIZE:
271 return build_global_group_size(b, bit_size);
272
273 case SYSTEM_VALUE_BARYCENTRIC_LINEAR_PIXEL:
274 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_pixel,
275 INTERP_MODE_NOPERSPECTIVE);
276
277 case SYSTEM_VALUE_BARYCENTRIC_LINEAR_CENTROID:
278 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_centroid,
279 INTERP_MODE_NOPERSPECTIVE);
280
281 case SYSTEM_VALUE_BARYCENTRIC_LINEAR_SAMPLE:
282 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_sample,
283 INTERP_MODE_NOPERSPECTIVE);
284
285 case SYSTEM_VALUE_BARYCENTRIC_PERSP_PIXEL:
286 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_pixel,
287 INTERP_MODE_SMOOTH);
288
289 case SYSTEM_VALUE_BARYCENTRIC_PERSP_CENTROID:
290 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_centroid,
291 INTERP_MODE_SMOOTH);
292
293 case SYSTEM_VALUE_BARYCENTRIC_PERSP_SAMPLE:
294 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_sample,
295 INTERP_MODE_SMOOTH);
296
297 case SYSTEM_VALUE_BARYCENTRIC_PULL_MODEL:
298 return nir_load_barycentric(b, nir_intrinsic_load_barycentric_model,
299 INTERP_MODE_NONE);
300
301 default:
302 break;
303 }
304
305 nir_intrinsic_op sysval_op =
306 nir_intrinsic_from_system_value(var->data.location);
307 return nir_load_system_value(b, sysval_op, 0,
308 intrin->dest.ssa.num_components,
309 intrin->dest.ssa.bit_size);
310 }
311
312 default:
313 return NULL;
314 }
315 }
316
317 bool
318 nir_lower_system_values(nir_shader *shader)
319 {
320 bool progress = nir_shader_lower_instructions(shader,
321 lower_system_value_filter,
322 lower_system_value_instr,
323 NULL);
324
325 /* We're going to delete the variables so we need to clean up all those
326 * derefs we left lying around.
327 */
328 if (progress)
329 nir_remove_dead_derefs(shader);
330
331 nir_foreach_variable_with_modes_safe(var, shader, nir_var_system_value)
332 exec_node_remove(&var->node);
333
334 return progress;
335 }