1 /*
2 * Copyright © 2015 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 * Jason Ekstrand (jason@jlekstrand.net)
25 *
26 */
27
28 #include "vtn_private.h"
29 #include "GLSL.std.450.h"
30
31 #define M_PIf ((float) M_PI)
32 #define M_PI_2f ((float) M_PI_2)
33 #define M_PI_4f ((float) M_PI_4)
34
35 static nir_ssa_def *
build_mat2_det(nir_builder * b,nir_ssa_def * col[2])36 build_mat2_det(nir_builder *b, nir_ssa_def *col[2])
37 {
38 unsigned swiz[4] = {1, 0, 0, 0};
39 nir_ssa_def *p = nir_fmul(b, col[0], nir_swizzle(b, col[1], swiz, 2, true));
40 return nir_fsub(b, nir_channel(b, p, 0), nir_channel(b, p, 1));
41 }
42
43 static nir_ssa_def *
build_mat3_det(nir_builder * b,nir_ssa_def * col[3])44 build_mat3_det(nir_builder *b, nir_ssa_def *col[3])
45 {
46 unsigned yzx[4] = {1, 2, 0, 0};
47 unsigned zxy[4] = {2, 0, 1, 0};
48
49 nir_ssa_def *prod0 =
50 nir_fmul(b, col[0],
51 nir_fmul(b, nir_swizzle(b, col[1], yzx, 3, true),
52 nir_swizzle(b, col[2], zxy, 3, true)));
53 nir_ssa_def *prod1 =
54 nir_fmul(b, col[0],
55 nir_fmul(b, nir_swizzle(b, col[1], zxy, 3, true),
56 nir_swizzle(b, col[2], yzx, 3, true)));
57
58 nir_ssa_def *diff = nir_fsub(b, prod0, prod1);
59
60 return nir_fadd(b, nir_channel(b, diff, 0),
61 nir_fadd(b, nir_channel(b, diff, 1),
62 nir_channel(b, diff, 2)));
63 }
64
65 static nir_ssa_def *
build_mat4_det(nir_builder * b,nir_ssa_def ** col)66 build_mat4_det(nir_builder *b, nir_ssa_def **col)
67 {
68 nir_ssa_def *subdet[4];
69 for (unsigned i = 0; i < 4; i++) {
70 unsigned swiz[3];
71 for (unsigned j = 0; j < 3; j++)
72 swiz[j] = j + (j >= i);
73
74 nir_ssa_def *subcol[3];
75 subcol[0] = nir_swizzle(b, col[1], swiz, 3, true);
76 subcol[1] = nir_swizzle(b, col[2], swiz, 3, true);
77 subcol[2] = nir_swizzle(b, col[3], swiz, 3, true);
78
79 subdet[i] = build_mat3_det(b, subcol);
80 }
81
82 nir_ssa_def *prod = nir_fmul(b, col[0], nir_vec(b, subdet, 4));
83
84 return nir_fadd(b, nir_fsub(b, nir_channel(b, prod, 0),
85 nir_channel(b, prod, 1)),
86 nir_fsub(b, nir_channel(b, prod, 2),
87 nir_channel(b, prod, 3)));
88 }
89
90 static nir_ssa_def *
build_mat_det(struct vtn_builder * b,struct vtn_ssa_value * src)91 build_mat_det(struct vtn_builder *b, struct vtn_ssa_value *src)
92 {
93 unsigned size = glsl_get_vector_elements(src->type);
94
95 nir_ssa_def *cols[4];
96 for (unsigned i = 0; i < size; i++)
97 cols[i] = src->elems[i]->def;
98
99 switch(size) {
100 case 2: return build_mat2_det(&b->nb, cols);
101 case 3: return build_mat3_det(&b->nb, cols);
102 case 4: return build_mat4_det(&b->nb, cols);
103 default:
104 unreachable("Invalid matrix size");
105 }
106 }
107
108 /* Computes the determinate of the submatrix given by taking src and
109 * removing the specified row and column.
110 */
111 static nir_ssa_def *
build_mat_subdet(struct nir_builder * b,struct vtn_ssa_value * src,unsigned size,unsigned row,unsigned col)112 build_mat_subdet(struct nir_builder *b, struct vtn_ssa_value *src,
113 unsigned size, unsigned row, unsigned col)
114 {
115 assert(row < size && col < size);
116 if (size == 2) {
117 return nir_channel(b, src->elems[1 - col]->def, 1 - row);
118 } else {
119 /* Swizzle to get all but the specified row */
120 unsigned swiz[3];
121 for (unsigned j = 0; j < 3; j++)
122 swiz[j] = j + (j >= row);
123
124 /* Grab all but the specified column */
125 nir_ssa_def *subcol[3];
126 for (unsigned j = 0; j < size; j++) {
127 if (j != col) {
128 subcol[j - (j > col)] = nir_swizzle(b, src->elems[j]->def,
129 swiz, size - 1, true);
130 }
131 }
132
133 if (size == 3) {
134 return build_mat2_det(b, subcol);
135 } else {
136 assert(size == 4);
137 return build_mat3_det(b, subcol);
138 }
139 }
140 }
141
142 static struct vtn_ssa_value *
matrix_inverse(struct vtn_builder * b,struct vtn_ssa_value * src)143 matrix_inverse(struct vtn_builder *b, struct vtn_ssa_value *src)
144 {
145 nir_ssa_def *adj_col[4];
146 unsigned size = glsl_get_vector_elements(src->type);
147
148 /* Build up an adjugate matrix */
149 for (unsigned c = 0; c < size; c++) {
150 nir_ssa_def *elem[4];
151 for (unsigned r = 0; r < size; r++) {
152 elem[r] = build_mat_subdet(&b->nb, src, size, c, r);
153
154 if ((r + c) % 2)
155 elem[r] = nir_fneg(&b->nb, elem[r]);
156 }
157
158 adj_col[c] = nir_vec(&b->nb, elem, size);
159 }
160
161 nir_ssa_def *det_inv = nir_frcp(&b->nb, build_mat_det(b, src));
162
163 struct vtn_ssa_value *val = vtn_create_ssa_value(b, src->type);
164 for (unsigned i = 0; i < size; i++)
165 val->elems[i]->def = nir_fmul(&b->nb, adj_col[i], det_inv);
166
167 return val;
168 }
169
170 static nir_ssa_def*
build_length(nir_builder * b,nir_ssa_def * vec)171 build_length(nir_builder *b, nir_ssa_def *vec)
172 {
173 switch (vec->num_components) {
174 case 1: return nir_fsqrt(b, nir_fmul(b, vec, vec));
175 case 2: return nir_fsqrt(b, nir_fdot2(b, vec, vec));
176 case 3: return nir_fsqrt(b, nir_fdot3(b, vec, vec));
177 case 4: return nir_fsqrt(b, nir_fdot4(b, vec, vec));
178 default:
179 unreachable("Invalid number of components");
180 }
181 }
182
183 static inline nir_ssa_def *
build_fclamp(nir_builder * b,nir_ssa_def * x,nir_ssa_def * min_val,nir_ssa_def * max_val)184 build_fclamp(nir_builder *b,
185 nir_ssa_def *x, nir_ssa_def *min_val, nir_ssa_def *max_val)
186 {
187 return nir_fmin(b, nir_fmax(b, x, min_val), max_val);
188 }
189
190 /**
191 * Return e^x.
192 */
193 static nir_ssa_def *
build_exp(nir_builder * b,nir_ssa_def * x)194 build_exp(nir_builder *b, nir_ssa_def *x)
195 {
196 return nir_fexp2(b, nir_fmul(b, x, nir_imm_float(b, M_LOG2E)));
197 }
198
199 /**
200 * Return ln(x) - the natural logarithm of x.
201 */
202 static nir_ssa_def *
build_log(nir_builder * b,nir_ssa_def * x)203 build_log(nir_builder *b, nir_ssa_def *x)
204 {
205 return nir_fmul(b, nir_flog2(b, x), nir_imm_float(b, 1.0 / M_LOG2E));
206 }
207
208 /**
209 * Approximate asin(x) by the formula:
210 * asin~(x) = sign(x) * (pi/2 - sqrt(1 - |x|) * (pi/2 + |x|(pi/4 - 1 + |x|(p0 + |x|p1))))
211 *
212 * which is correct to first order at x=0 and x=±1 regardless of the p
213 * coefficients but can be made second-order correct at both ends by selecting
214 * the fit coefficients appropriately. Different p coefficients can be used
215 * in the asin and acos implementation to minimize some relative error metric
216 * in each case.
217 */
218 static nir_ssa_def *
build_asin(nir_builder * b,nir_ssa_def * x,float p0,float p1)219 build_asin(nir_builder *b, nir_ssa_def *x, float p0, float p1)
220 {
221 nir_ssa_def *abs_x = nir_fabs(b, x);
222 return nir_fmul(b, nir_fsign(b, x),
223 nir_fsub(b, nir_imm_float(b, M_PI_2f),
224 nir_fmul(b, nir_fsqrt(b, nir_fsub(b, nir_imm_float(b, 1.0f), abs_x)),
225 nir_fadd(b, nir_imm_float(b, M_PI_2f),
226 nir_fmul(b, abs_x,
227 nir_fadd(b, nir_imm_float(b, M_PI_4f - 1.0f),
228 nir_fmul(b, abs_x,
229 nir_fadd(b, nir_imm_float(b, p0),
230 nir_fmul(b, abs_x,
231 nir_imm_float(b, p1))))))))));
232 }
233
234 /**
235 * Compute xs[0] + xs[1] + xs[2] + ... using fadd.
236 */
237 static nir_ssa_def *
build_fsum(nir_builder * b,nir_ssa_def ** xs,int terms)238 build_fsum(nir_builder *b, nir_ssa_def **xs, int terms)
239 {
240 nir_ssa_def *accum = xs[0];
241
242 for (int i = 1; i < terms; i++)
243 accum = nir_fadd(b, accum, xs[i]);
244
245 return accum;
246 }
247
248 static nir_ssa_def *
build_atan(nir_builder * b,nir_ssa_def * y_over_x)249 build_atan(nir_builder *b, nir_ssa_def *y_over_x)
250 {
251 nir_ssa_def *abs_y_over_x = nir_fabs(b, y_over_x);
252 nir_ssa_def *one = nir_imm_float(b, 1.0f);
253
254 /*
255 * range-reduction, first step:
256 *
257 * / y_over_x if |y_over_x| <= 1.0;
258 * x = <
259 * \ 1.0 / y_over_x otherwise
260 */
261 nir_ssa_def *x = nir_fdiv(b, nir_fmin(b, abs_y_over_x, one),
262 nir_fmax(b, abs_y_over_x, one));
263
264 /*
265 * approximate atan by evaluating polynomial:
266 *
267 * x * 0.9999793128310355 - x^3 * 0.3326756418091246 +
268 * x^5 * 0.1938924977115610 - x^7 * 0.1173503194786851 +
269 * x^9 * 0.0536813784310406 - x^11 * 0.0121323213173444
270 */
271 nir_ssa_def *x_2 = nir_fmul(b, x, x);
272 nir_ssa_def *x_3 = nir_fmul(b, x_2, x);
273 nir_ssa_def *x_5 = nir_fmul(b, x_3, x_2);
274 nir_ssa_def *x_7 = nir_fmul(b, x_5, x_2);
275 nir_ssa_def *x_9 = nir_fmul(b, x_7, x_2);
276 nir_ssa_def *x_11 = nir_fmul(b, x_9, x_2);
277
278 nir_ssa_def *polynomial_terms[] = {
279 nir_fmul(b, x, nir_imm_float(b, 0.9999793128310355f)),
280 nir_fmul(b, x_3, nir_imm_float(b, -0.3326756418091246f)),
281 nir_fmul(b, x_5, nir_imm_float(b, 0.1938924977115610f)),
282 nir_fmul(b, x_7, nir_imm_float(b, -0.1173503194786851f)),
283 nir_fmul(b, x_9, nir_imm_float(b, 0.0536813784310406f)),
284 nir_fmul(b, x_11, nir_imm_float(b, -0.0121323213173444f)),
285 };
286
287 nir_ssa_def *tmp =
288 build_fsum(b, polynomial_terms, ARRAY_SIZE(polynomial_terms));
289
290 /* range-reduction fixup */
291 tmp = nir_fadd(b, tmp,
292 nir_fmul(b,
293 nir_b2f(b, nir_flt(b, one, abs_y_over_x)),
294 nir_fadd(b, nir_fmul(b, tmp,
295 nir_imm_float(b, -2.0f)),
296 nir_imm_float(b, M_PI_2f))));
297
298 /* sign fixup */
299 return nir_fmul(b, tmp, nir_fsign(b, y_over_x));
300 }
301
302 static nir_ssa_def *
build_atan2(nir_builder * b,nir_ssa_def * y,nir_ssa_def * x)303 build_atan2(nir_builder *b, nir_ssa_def *y, nir_ssa_def *x)
304 {
305 nir_ssa_def *zero = nir_imm_float(b, 0.0f);
306
307 /* If |x| >= 1.0e-8 * |y|: */
308 nir_ssa_def *condition =
309 nir_fge(b, nir_fabs(b, x),
310 nir_fmul(b, nir_imm_float(b, 1.0e-8f), nir_fabs(b, y)));
311
312 /* Then...call atan(y/x) and fix it up: */
313 nir_ssa_def *atan1 = build_atan(b, nir_fdiv(b, y, x));
314 nir_ssa_def *r_then =
315 nir_bcsel(b, nir_flt(b, x, zero),
316 nir_fadd(b, atan1,
317 nir_bcsel(b, nir_fge(b, y, zero),
318 nir_imm_float(b, M_PIf),
319 nir_imm_float(b, -M_PIf))),
320 atan1);
321
322 /* Else... */
323 nir_ssa_def *r_else =
324 nir_fmul(b, nir_fsign(b, y), nir_imm_float(b, M_PI_2f));
325
326 return nir_bcsel(b, condition, r_then, r_else);
327 }
328
329 static nir_ssa_def *
build_frexp(nir_builder * b,nir_ssa_def * x,nir_ssa_def ** exponent)330 build_frexp(nir_builder *b, nir_ssa_def *x, nir_ssa_def **exponent)
331 {
332 nir_ssa_def *abs_x = nir_fabs(b, x);
333 nir_ssa_def *zero = nir_imm_float(b, 0.0f);
334
335 /* Single-precision floating-point values are stored as
336 * 1 sign bit;
337 * 8 exponent bits;
338 * 23 mantissa bits.
339 *
340 * An exponent shift of 23 will shift the mantissa out, leaving only the
341 * exponent and sign bit (which itself may be zero, if the absolute value
342 * was taken before the bitcast and shift.
343 */
344 nir_ssa_def *exponent_shift = nir_imm_int(b, 23);
345 nir_ssa_def *exponent_bias = nir_imm_int(b, -126);
346
347 nir_ssa_def *sign_mantissa_mask = nir_imm_int(b, 0x807fffffu);
348
349 /* Exponent of floating-point values in the range [0.5, 1.0). */
350 nir_ssa_def *exponent_value = nir_imm_int(b, 0x3f000000u);
351
352 nir_ssa_def *is_not_zero = nir_fne(b, abs_x, zero);
353
354 *exponent =
355 nir_iadd(b, nir_ushr(b, abs_x, exponent_shift),
356 nir_bcsel(b, is_not_zero, exponent_bias, zero));
357
358 return nir_ior(b, nir_iand(b, x, sign_mantissa_mask),
359 nir_bcsel(b, is_not_zero, exponent_value, zero));
360 }
361
362 static nir_op
vtn_nir_alu_op_for_spirv_glsl_opcode(enum GLSLstd450 opcode)363 vtn_nir_alu_op_for_spirv_glsl_opcode(enum GLSLstd450 opcode)
364 {
365 switch (opcode) {
366 case GLSLstd450Round: return nir_op_fround_even;
367 case GLSLstd450RoundEven: return nir_op_fround_even;
368 case GLSLstd450Trunc: return nir_op_ftrunc;
369 case GLSLstd450FAbs: return nir_op_fabs;
370 case GLSLstd450SAbs: return nir_op_iabs;
371 case GLSLstd450FSign: return nir_op_fsign;
372 case GLSLstd450SSign: return nir_op_isign;
373 case GLSLstd450Floor: return nir_op_ffloor;
374 case GLSLstd450Ceil: return nir_op_fceil;
375 case GLSLstd450Fract: return nir_op_ffract;
376 case GLSLstd450Sin: return nir_op_fsin;
377 case GLSLstd450Cos: return nir_op_fcos;
378 case GLSLstd450Pow: return nir_op_fpow;
379 case GLSLstd450Exp2: return nir_op_fexp2;
380 case GLSLstd450Log2: return nir_op_flog2;
381 case GLSLstd450Sqrt: return nir_op_fsqrt;
382 case GLSLstd450InverseSqrt: return nir_op_frsq;
383 case GLSLstd450FMin: return nir_op_fmin;
384 case GLSLstd450UMin: return nir_op_umin;
385 case GLSLstd450SMin: return nir_op_imin;
386 case GLSLstd450FMax: return nir_op_fmax;
387 case GLSLstd450UMax: return nir_op_umax;
388 case GLSLstd450SMax: return nir_op_imax;
389 case GLSLstd450FMix: return nir_op_flrp;
390 case GLSLstd450Fma: return nir_op_ffma;
391 case GLSLstd450Ldexp: return nir_op_ldexp;
392 case GLSLstd450FindILsb: return nir_op_find_lsb;
393 case GLSLstd450FindSMsb: return nir_op_ifind_msb;
394 case GLSLstd450FindUMsb: return nir_op_ufind_msb;
395
396 /* Packing/Unpacking functions */
397 case GLSLstd450PackSnorm4x8: return nir_op_pack_snorm_4x8;
398 case GLSLstd450PackUnorm4x8: return nir_op_pack_unorm_4x8;
399 case GLSLstd450PackSnorm2x16: return nir_op_pack_snorm_2x16;
400 case GLSLstd450PackUnorm2x16: return nir_op_pack_unorm_2x16;
401 case GLSLstd450PackHalf2x16: return nir_op_pack_half_2x16;
402 case GLSLstd450PackDouble2x32: return nir_op_pack_double_2x32;
403 case GLSLstd450UnpackSnorm4x8: return nir_op_unpack_snorm_4x8;
404 case GLSLstd450UnpackUnorm4x8: return nir_op_unpack_unorm_4x8;
405 case GLSLstd450UnpackSnorm2x16: return nir_op_unpack_snorm_2x16;
406 case GLSLstd450UnpackUnorm2x16: return nir_op_unpack_unorm_2x16;
407 case GLSLstd450UnpackHalf2x16: return nir_op_unpack_half_2x16;
408 case GLSLstd450UnpackDouble2x32: return nir_op_unpack_double_2x32;
409
410 default:
411 unreachable("No NIR equivalent");
412 }
413 }
414
415 static void
handle_glsl450_alu(struct vtn_builder * b,enum GLSLstd450 entrypoint,const uint32_t * w,unsigned count)416 handle_glsl450_alu(struct vtn_builder *b, enum GLSLstd450 entrypoint,
417 const uint32_t *w, unsigned count)
418 {
419 struct nir_builder *nb = &b->nb;
420 const struct glsl_type *dest_type =
421 vtn_value(b, w[1], vtn_value_type_type)->type->type;
422
423 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
424 val->ssa = vtn_create_ssa_value(b, dest_type);
425
426 /* Collect the various SSA sources */
427 unsigned num_inputs = count - 5;
428 nir_ssa_def *src[3] = { NULL, };
429 for (unsigned i = 0; i < num_inputs; i++)
430 src[i] = vtn_ssa_value(b, w[i + 5])->def;
431
432 switch (entrypoint) {
433 case GLSLstd450Radians:
434 val->ssa->def = nir_fmul(nb, src[0], nir_imm_float(nb, 0.01745329251));
435 return;
436 case GLSLstd450Degrees:
437 val->ssa->def = nir_fmul(nb, src[0], nir_imm_float(nb, 57.2957795131));
438 return;
439 case GLSLstd450Tan:
440 val->ssa->def = nir_fdiv(nb, nir_fsin(nb, src[0]),
441 nir_fcos(nb, src[0]));
442 return;
443
444 case GLSLstd450Modf: {
445 nir_ssa_def *sign = nir_fsign(nb, src[0]);
446 nir_ssa_def *abs = nir_fabs(nb, src[0]);
447 val->ssa->def = nir_fmul(nb, sign, nir_ffract(nb, abs));
448 nir_store_deref_var(nb, vtn_nir_deref(b, w[6]),
449 nir_fmul(nb, sign, nir_ffloor(nb, abs)), 0xf);
450 return;
451 }
452
453 case GLSLstd450ModfStruct: {
454 nir_ssa_def *sign = nir_fsign(nb, src[0]);
455 nir_ssa_def *abs = nir_fabs(nb, src[0]);
456 assert(glsl_type_is_struct(val->ssa->type));
457 val->ssa->elems[0]->def = nir_fmul(nb, sign, nir_ffract(nb, abs));
458 val->ssa->elems[1]->def = nir_fmul(nb, sign, nir_ffloor(nb, abs));
459 return;
460 }
461
462 case GLSLstd450Step:
463 val->ssa->def = nir_sge(nb, src[1], src[0]);
464 return;
465
466 case GLSLstd450Length:
467 val->ssa->def = build_length(nb, src[0]);
468 return;
469 case GLSLstd450Distance:
470 val->ssa->def = build_length(nb, nir_fsub(nb, src[0], src[1]));
471 return;
472 case GLSLstd450Normalize:
473 val->ssa->def = nir_fdiv(nb, src[0], build_length(nb, src[0]));
474 return;
475
476 case GLSLstd450Exp:
477 val->ssa->def = build_exp(nb, src[0]);
478 return;
479
480 case GLSLstd450Log:
481 val->ssa->def = build_log(nb, src[0]);
482 return;
483
484 case GLSLstd450FClamp:
485 val->ssa->def = build_fclamp(nb, src[0], src[1], src[2]);
486 return;
487 case GLSLstd450UClamp:
488 val->ssa->def = nir_umin(nb, nir_umax(nb, src[0], src[1]), src[2]);
489 return;
490 case GLSLstd450SClamp:
491 val->ssa->def = nir_imin(nb, nir_imax(nb, src[0], src[1]), src[2]);
492 return;
493
494 case GLSLstd450Cross: {
495 unsigned yzx[4] = { 1, 2, 0, 0 };
496 unsigned zxy[4] = { 2, 0, 1, 0 };
497 val->ssa->def =
498 nir_fsub(nb, nir_fmul(nb, nir_swizzle(nb, src[0], yzx, 3, true),
499 nir_swizzle(nb, src[1], zxy, 3, true)),
500 nir_fmul(nb, nir_swizzle(nb, src[0], zxy, 3, true),
501 nir_swizzle(nb, src[1], yzx, 3, true)));
502 return;
503 }
504
505 case GLSLstd450SmoothStep: {
506 /* t = clamp((x - edge0) / (edge1 - edge0), 0, 1) */
507 nir_ssa_def *t =
508 build_fclamp(nb, nir_fdiv(nb, nir_fsub(nb, src[2], src[0]),
509 nir_fsub(nb, src[1], src[0])),
510 nir_imm_float(nb, 0.0), nir_imm_float(nb, 1.0));
511 /* result = t * t * (3 - 2 * t) */
512 val->ssa->def =
513 nir_fmul(nb, t, nir_fmul(nb, t,
514 nir_fsub(nb, nir_imm_float(nb, 3.0),
515 nir_fmul(nb, nir_imm_float(nb, 2.0), t))));
516 return;
517 }
518
519 case GLSLstd450FaceForward:
520 val->ssa->def =
521 nir_bcsel(nb, nir_flt(nb, nir_fdot(nb, src[2], src[1]),
522 nir_imm_float(nb, 0.0)),
523 src[0], nir_fneg(nb, src[0]));
524 return;
525
526 case GLSLstd450Reflect:
527 /* I - 2 * dot(N, I) * N */
528 val->ssa->def =
529 nir_fsub(nb, src[0], nir_fmul(nb, nir_imm_float(nb, 2.0),
530 nir_fmul(nb, nir_fdot(nb, src[0], src[1]),
531 src[1])));
532 return;
533
534 case GLSLstd450Refract: {
535 nir_ssa_def *I = src[0];
536 nir_ssa_def *N = src[1];
537 nir_ssa_def *eta = src[2];
538 nir_ssa_def *n_dot_i = nir_fdot(nb, N, I);
539 nir_ssa_def *one = nir_imm_float(nb, 1.0);
540 nir_ssa_def *zero = nir_imm_float(nb, 0.0);
541 /* k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I)) */
542 nir_ssa_def *k =
543 nir_fsub(nb, one, nir_fmul(nb, eta, nir_fmul(nb, eta,
544 nir_fsub(nb, one, nir_fmul(nb, n_dot_i, n_dot_i)))));
545 nir_ssa_def *result =
546 nir_fsub(nb, nir_fmul(nb, eta, I),
547 nir_fmul(nb, nir_fadd(nb, nir_fmul(nb, eta, n_dot_i),
548 nir_fsqrt(nb, k)), N));
549 /* XXX: bcsel, or if statement? */
550 val->ssa->def = nir_bcsel(nb, nir_flt(nb, k, zero), zero, result);
551 return;
552 }
553
554 case GLSLstd450Sinh:
555 /* 0.5 * (e^x - e^(-x)) */
556 val->ssa->def =
557 nir_fmul(nb, nir_imm_float(nb, 0.5f),
558 nir_fsub(nb, build_exp(nb, src[0]),
559 build_exp(nb, nir_fneg(nb, src[0]))));
560 return;
561
562 case GLSLstd450Cosh:
563 /* 0.5 * (e^x + e^(-x)) */
564 val->ssa->def =
565 nir_fmul(nb, nir_imm_float(nb, 0.5f),
566 nir_fadd(nb, build_exp(nb, src[0]),
567 build_exp(nb, nir_fneg(nb, src[0]))));
568 return;
569
570 case GLSLstd450Tanh: {
571 /* tanh(x) := (0.5 * (e^x - e^(-x))) / (0.5 * (e^x + e^(-x)))
572 *
573 * With a little algebra this reduces to (e^2x - 1) / (e^2x + 1)
574 *
575 * We clamp x to (-inf, +10] to avoid precision problems. When x > 10,
576 * e^2x is so much larger than 1.0 that 1.0 gets flushed to zero in the
577 * computation e^2x +/- 1 so it can be ignored.
578 */
579 nir_ssa_def *x = nir_fmin(nb, src[0], nir_imm_float(nb, 10));
580 nir_ssa_def *exp2x = build_exp(nb, nir_fmul(nb, x, nir_imm_float(nb, 2)));
581 val->ssa->def = nir_fdiv(nb, nir_fsub(nb, exp2x, nir_imm_float(nb, 1)),
582 nir_fadd(nb, exp2x, nir_imm_float(nb, 1)));
583 return;
584 }
585
586 case GLSLstd450Asinh:
587 val->ssa->def = nir_fmul(nb, nir_fsign(nb, src[0]),
588 build_log(nb, nir_fadd(nb, nir_fabs(nb, src[0]),
589 nir_fsqrt(nb, nir_fadd(nb, nir_fmul(nb, src[0], src[0]),
590 nir_imm_float(nb, 1.0f))))));
591 return;
592 case GLSLstd450Acosh:
593 val->ssa->def = build_log(nb, nir_fadd(nb, src[0],
594 nir_fsqrt(nb, nir_fsub(nb, nir_fmul(nb, src[0], src[0]),
595 nir_imm_float(nb, 1.0f)))));
596 return;
597 case GLSLstd450Atanh: {
598 nir_ssa_def *one = nir_imm_float(nb, 1.0);
599 val->ssa->def = nir_fmul(nb, nir_imm_float(nb, 0.5f),
600 build_log(nb, nir_fdiv(nb, nir_fadd(nb, one, src[0]),
601 nir_fsub(nb, one, src[0]))));
602 return;
603 }
604
605 case GLSLstd450Asin:
606 val->ssa->def = build_asin(nb, src[0], 0.086566724, -0.03102955);
607 return;
608
609 case GLSLstd450Acos:
610 val->ssa->def = nir_fsub(nb, nir_imm_float(nb, M_PI_2f),
611 build_asin(nb, src[0], 0.08132463, -0.02363318));
612 return;
613
614 case GLSLstd450Atan:
615 val->ssa->def = build_atan(nb, src[0]);
616 return;
617
618 case GLSLstd450Atan2:
619 val->ssa->def = build_atan2(nb, src[0], src[1]);
620 return;
621
622 case GLSLstd450Frexp: {
623 nir_ssa_def *exponent;
624 val->ssa->def = build_frexp(nb, src[0], &exponent);
625 nir_store_deref_var(nb, vtn_nir_deref(b, w[6]), exponent, 0xf);
626 return;
627 }
628
629 case GLSLstd450FrexpStruct: {
630 assert(glsl_type_is_struct(val->ssa->type));
631 val->ssa->elems[0]->def = build_frexp(nb, src[0],
632 &val->ssa->elems[1]->def);
633 return;
634 }
635
636 default:
637 val->ssa->def =
638 nir_build_alu(&b->nb, vtn_nir_alu_op_for_spirv_glsl_opcode(entrypoint),
639 src[0], src[1], src[2], NULL);
640 return;
641 }
642 }
643
644 static void
handle_glsl450_interpolation(struct vtn_builder * b,enum GLSLstd450 opcode,const uint32_t * w,unsigned count)645 handle_glsl450_interpolation(struct vtn_builder *b, enum GLSLstd450 opcode,
646 const uint32_t *w, unsigned count)
647 {
648 const struct glsl_type *dest_type =
649 vtn_value(b, w[1], vtn_value_type_type)->type->type;
650
651 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
652 val->ssa = vtn_create_ssa_value(b, dest_type);
653
654 nir_intrinsic_op op;
655 switch (opcode) {
656 case GLSLstd450InterpolateAtCentroid:
657 op = nir_intrinsic_interp_var_at_centroid;
658 break;
659 case GLSLstd450InterpolateAtSample:
660 op = nir_intrinsic_interp_var_at_sample;
661 break;
662 case GLSLstd450InterpolateAtOffset:
663 op = nir_intrinsic_interp_var_at_offset;
664 break;
665 default:
666 unreachable("Invalid opcode");
667 }
668
669 nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->nb.shader, op);
670
671 nir_deref_var *deref = vtn_nir_deref(b, w[5]);
672 intrin->variables[0] = nir_deref_var_clone(deref, intrin);
673
674 switch (opcode) {
675 case GLSLstd450InterpolateAtCentroid:
676 break;
677 case GLSLstd450InterpolateAtSample:
678 case GLSLstd450InterpolateAtOffset:
679 intrin->src[0] = nir_src_for_ssa(vtn_ssa_value(b, w[6])->def);
680 break;
681 default:
682 unreachable("Invalid opcode");
683 }
684
685 intrin->num_components = glsl_get_vector_elements(dest_type);
686 nir_ssa_dest_init(&intrin->instr, &intrin->dest,
687 glsl_get_vector_elements(dest_type),
688 glsl_get_bit_size(dest_type), NULL);
689 val->ssa->def = &intrin->dest.ssa;
690
691 nir_builder_instr_insert(&b->nb, &intrin->instr);
692 }
693
694 bool
vtn_handle_glsl450_instruction(struct vtn_builder * b,uint32_t ext_opcode,const uint32_t * w,unsigned count)695 vtn_handle_glsl450_instruction(struct vtn_builder *b, uint32_t ext_opcode,
696 const uint32_t *w, unsigned count)
697 {
698 switch ((enum GLSLstd450)ext_opcode) {
699 case GLSLstd450Determinant: {
700 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
701 val->ssa = rzalloc(b, struct vtn_ssa_value);
702 val->ssa->type = vtn_value(b, w[1], vtn_value_type_type)->type->type;
703 val->ssa->def = build_mat_det(b, vtn_ssa_value(b, w[5]));
704 break;
705 }
706
707 case GLSLstd450MatrixInverse: {
708 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa);
709 val->ssa = matrix_inverse(b, vtn_ssa_value(b, w[5]));
710 break;
711 }
712
713 case GLSLstd450InterpolateAtCentroid:
714 case GLSLstd450InterpolateAtSample:
715 case GLSLstd450InterpolateAtOffset:
716 handle_glsl450_interpolation(b, ext_opcode, w, count);
717 break;
718
719 default:
720 handle_glsl450_alu(b, (enum GLSLstd450)ext_opcode, w, count);
721 }
722
723 return true;
724 }
725