vtn_glsl450.c revision b8e80941
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 <math.h> 29 30#include "nir/nir_builtin_builder.h" 31 32#include "vtn_private.h" 33#include "GLSL.std.450.h" 34 35#define M_PIf ((float) M_PI) 36#define M_PI_2f ((float) M_PI_2) 37#define M_PI_4f ((float) M_PI_4) 38 39static nir_ssa_def * 40build_mat2_det(nir_builder *b, nir_ssa_def *col[2]) 41{ 42 unsigned swiz[2] = {1, 0 }; 43 nir_ssa_def *p = nir_fmul(b, col[0], nir_swizzle(b, col[1], swiz, 2, true)); 44 return nir_fsub(b, nir_channel(b, p, 0), nir_channel(b, p, 1)); 45} 46 47static nir_ssa_def * 48build_mat3_det(nir_builder *b, nir_ssa_def *col[3]) 49{ 50 unsigned yzx[3] = {1, 2, 0 }; 51 unsigned zxy[3] = {2, 0, 1 }; 52 53 nir_ssa_def *prod0 = 54 nir_fmul(b, col[0], 55 nir_fmul(b, nir_swizzle(b, col[1], yzx, 3, true), 56 nir_swizzle(b, col[2], zxy, 3, true))); 57 nir_ssa_def *prod1 = 58 nir_fmul(b, col[0], 59 nir_fmul(b, nir_swizzle(b, col[1], zxy, 3, true), 60 nir_swizzle(b, col[2], yzx, 3, true))); 61 62 nir_ssa_def *diff = nir_fsub(b, prod0, prod1); 63 64 return nir_fadd(b, nir_channel(b, diff, 0), 65 nir_fadd(b, nir_channel(b, diff, 1), 66 nir_channel(b, diff, 2))); 67} 68 69static nir_ssa_def * 70build_mat4_det(nir_builder *b, nir_ssa_def **col) 71{ 72 nir_ssa_def *subdet[4]; 73 for (unsigned i = 0; i < 4; i++) { 74 unsigned swiz[3]; 75 for (unsigned j = 0; j < 3; j++) 76 swiz[j] = j + (j >= i); 77 78 nir_ssa_def *subcol[3]; 79 subcol[0] = nir_swizzle(b, col[1], swiz, 3, true); 80 subcol[1] = nir_swizzle(b, col[2], swiz, 3, true); 81 subcol[2] = nir_swizzle(b, col[3], swiz, 3, true); 82 83 subdet[i] = build_mat3_det(b, subcol); 84 } 85 86 nir_ssa_def *prod = nir_fmul(b, col[0], nir_vec(b, subdet, 4)); 87 88 return nir_fadd(b, nir_fsub(b, nir_channel(b, prod, 0), 89 nir_channel(b, prod, 1)), 90 nir_fsub(b, nir_channel(b, prod, 2), 91 nir_channel(b, prod, 3))); 92} 93 94static nir_ssa_def * 95build_mat_det(struct vtn_builder *b, struct vtn_ssa_value *src) 96{ 97 unsigned size = glsl_get_vector_elements(src->type); 98 99 nir_ssa_def *cols[4]; 100 for (unsigned i = 0; i < size; i++) 101 cols[i] = src->elems[i]->def; 102 103 switch(size) { 104 case 2: return build_mat2_det(&b->nb, cols); 105 case 3: return build_mat3_det(&b->nb, cols); 106 case 4: return build_mat4_det(&b->nb, cols); 107 default: 108 vtn_fail("Invalid matrix size"); 109 } 110} 111 112/* Computes the determinate of the submatrix given by taking src and 113 * removing the specified row and column. 114 */ 115static nir_ssa_def * 116build_mat_subdet(struct nir_builder *b, struct vtn_ssa_value *src, 117 unsigned size, unsigned row, unsigned col) 118{ 119 assert(row < size && col < size); 120 if (size == 2) { 121 return nir_channel(b, src->elems[1 - col]->def, 1 - row); 122 } else { 123 /* Swizzle to get all but the specified row */ 124 unsigned swiz[3]; 125 for (unsigned j = 0; j < 3; j++) 126 swiz[j] = j + (j >= row); 127 128 /* Grab all but the specified column */ 129 nir_ssa_def *subcol[3]; 130 for (unsigned j = 0; j < size; j++) { 131 if (j != col) { 132 subcol[j - (j > col)] = nir_swizzle(b, src->elems[j]->def, 133 swiz, size - 1, true); 134 } 135 } 136 137 if (size == 3) { 138 return build_mat2_det(b, subcol); 139 } else { 140 assert(size == 4); 141 return build_mat3_det(b, subcol); 142 } 143 } 144} 145 146static struct vtn_ssa_value * 147matrix_inverse(struct vtn_builder *b, struct vtn_ssa_value *src) 148{ 149 nir_ssa_def *adj_col[4]; 150 unsigned size = glsl_get_vector_elements(src->type); 151 152 /* Build up an adjugate matrix */ 153 for (unsigned c = 0; c < size; c++) { 154 nir_ssa_def *elem[4]; 155 for (unsigned r = 0; r < size; r++) { 156 elem[r] = build_mat_subdet(&b->nb, src, size, c, r); 157 158 if ((r + c) % 2) 159 elem[r] = nir_fneg(&b->nb, elem[r]); 160 } 161 162 adj_col[c] = nir_vec(&b->nb, elem, size); 163 } 164 165 nir_ssa_def *det_inv = nir_frcp(&b->nb, build_mat_det(b, src)); 166 167 struct vtn_ssa_value *val = vtn_create_ssa_value(b, src->type); 168 for (unsigned i = 0; i < size; i++) 169 val->elems[i]->def = nir_fmul(&b->nb, adj_col[i], det_inv); 170 171 return val; 172} 173 174/** 175 * Return e^x. 176 */ 177static nir_ssa_def * 178build_exp(nir_builder *b, nir_ssa_def *x) 179{ 180 return nir_fexp2(b, nir_fmul_imm(b, x, M_LOG2E)); 181} 182 183/** 184 * Return ln(x) - the natural logarithm of x. 185 */ 186static nir_ssa_def * 187build_log(nir_builder *b, nir_ssa_def *x) 188{ 189 return nir_fmul_imm(b, nir_flog2(b, x), 1.0 / M_LOG2E); 190} 191 192/** 193 * Approximate asin(x) by the formula: 194 * asin~(x) = sign(x) * (pi/2 - sqrt(1 - |x|) * (pi/2 + |x|(pi/4 - 1 + |x|(p0 + |x|p1)))) 195 * 196 * which is correct to first order at x=0 and x=±1 regardless of the p 197 * coefficients but can be made second-order correct at both ends by selecting 198 * the fit coefficients appropriately. Different p coefficients can be used 199 * in the asin and acos implementation to minimize some relative error metric 200 * in each case. 201 */ 202static nir_ssa_def * 203build_asin(nir_builder *b, nir_ssa_def *x, float p0, float p1) 204{ 205 if (x->bit_size == 16) { 206 /* The polynomial approximation isn't precise enough to meet half-float 207 * precision requirements. Alternatively, we could implement this using 208 * the formula: 209 * 210 * asin(x) = atan2(x, sqrt(1 - x*x)) 211 * 212 * But that is very expensive, so instead we just do the polynomial 213 * approximation in 32-bit math and then we convert the result back to 214 * 16-bit. 215 */ 216 return nir_f2f16(b, build_asin(b, nir_f2f32(b, x), p0, p1)); 217 } 218 219 nir_ssa_def *one = nir_imm_floatN_t(b, 1.0f, x->bit_size); 220 nir_ssa_def *abs_x = nir_fabs(b, x); 221 222 nir_ssa_def *p0_plus_xp1 = nir_fadd_imm(b, nir_fmul_imm(b, abs_x, p1), p0); 223 224 nir_ssa_def *expr_tail = 225 nir_fadd_imm(b, nir_fmul(b, abs_x, 226 nir_fadd_imm(b, nir_fmul(b, abs_x, 227 p0_plus_xp1), 228 M_PI_4f - 1.0f)), 229 M_PI_2f); 230 231 return nir_fmul(b, nir_fsign(b, x), 232 nir_fsub(b, nir_imm_floatN_t(b, M_PI_2f, x->bit_size), 233 nir_fmul(b, nir_fsqrt(b, nir_fsub(b, one, abs_x)), 234 expr_tail))); 235} 236 237/** 238 * Compute xs[0] + xs[1] + xs[2] + ... using fadd. 239 */ 240static nir_ssa_def * 241build_fsum(nir_builder *b, nir_ssa_def **xs, int terms) 242{ 243 nir_ssa_def *accum = xs[0]; 244 245 for (int i = 1; i < terms; i++) 246 accum = nir_fadd(b, accum, xs[i]); 247 248 return accum; 249} 250 251static nir_ssa_def * 252build_atan(nir_builder *b, nir_ssa_def *y_over_x) 253{ 254 const uint32_t bit_size = y_over_x->bit_size; 255 256 nir_ssa_def *abs_y_over_x = nir_fabs(b, y_over_x); 257 nir_ssa_def *one = nir_imm_floatN_t(b, 1.0f, bit_size); 258 259 /* 260 * range-reduction, first step: 261 * 262 * / y_over_x if |y_over_x| <= 1.0; 263 * x = < 264 * \ 1.0 / y_over_x otherwise 265 */ 266 nir_ssa_def *x = nir_fdiv(b, nir_fmin(b, abs_y_over_x, one), 267 nir_fmax(b, abs_y_over_x, one)); 268 269 /* 270 * approximate atan by evaluating polynomial: 271 * 272 * x * 0.9999793128310355 - x^3 * 0.3326756418091246 + 273 * x^5 * 0.1938924977115610 - x^7 * 0.1173503194786851 + 274 * x^9 * 0.0536813784310406 - x^11 * 0.0121323213173444 275 */ 276 nir_ssa_def *x_2 = nir_fmul(b, x, x); 277 nir_ssa_def *x_3 = nir_fmul(b, x_2, x); 278 nir_ssa_def *x_5 = nir_fmul(b, x_3, x_2); 279 nir_ssa_def *x_7 = nir_fmul(b, x_5, x_2); 280 nir_ssa_def *x_9 = nir_fmul(b, x_7, x_2); 281 nir_ssa_def *x_11 = nir_fmul(b, x_9, x_2); 282 283 nir_ssa_def *polynomial_terms[] = { 284 nir_fmul_imm(b, x, 0.9999793128310355f), 285 nir_fmul_imm(b, x_3, -0.3326756418091246f), 286 nir_fmul_imm(b, x_5, 0.1938924977115610f), 287 nir_fmul_imm(b, x_7, -0.1173503194786851f), 288 nir_fmul_imm(b, x_9, 0.0536813784310406f), 289 nir_fmul_imm(b, x_11, -0.0121323213173444f), 290 }; 291 292 nir_ssa_def *tmp = 293 build_fsum(b, polynomial_terms, ARRAY_SIZE(polynomial_terms)); 294 295 /* range-reduction fixup */ 296 tmp = nir_fadd(b, tmp, 297 nir_fmul(b, nir_b2f(b, nir_flt(b, one, abs_y_over_x), bit_size), 298 nir_fadd_imm(b, nir_fmul_imm(b, tmp, -2.0f), M_PI_2f))); 299 300 /* sign fixup */ 301 return nir_fmul(b, tmp, nir_fsign(b, y_over_x)); 302} 303 304static nir_ssa_def * 305build_atan2(nir_builder *b, nir_ssa_def *y, nir_ssa_def *x) 306{ 307 assert(y->bit_size == x->bit_size); 308 const uint32_t bit_size = x->bit_size; 309 310 nir_ssa_def *zero = nir_imm_floatN_t(b, 0, bit_size); 311 nir_ssa_def *one = nir_imm_floatN_t(b, 1, bit_size); 312 313 /* If we're on the left half-plane rotate the coordinates π/2 clock-wise 314 * for the y=0 discontinuity to end up aligned with the vertical 315 * discontinuity of atan(s/t) along t=0. This also makes sure that we 316 * don't attempt to divide by zero along the vertical line, which may give 317 * unspecified results on non-GLSL 4.1-capable hardware. 318 */ 319 nir_ssa_def *flip = nir_fge(b, zero, x); 320 nir_ssa_def *s = nir_bcsel(b, flip, nir_fabs(b, x), y); 321 nir_ssa_def *t = nir_bcsel(b, flip, y, nir_fabs(b, x)); 322 323 /* If the magnitude of the denominator exceeds some huge value, scale down 324 * the arguments in order to prevent the reciprocal operation from flushing 325 * its result to zero, which would cause precision problems, and for s 326 * infinite would cause us to return a NaN instead of the correct finite 327 * value. 328 * 329 * If fmin and fmax are respectively the smallest and largest positive 330 * normalized floating point values representable by the implementation, 331 * the constants below should be in agreement with: 332 * 333 * huge <= 1 / fmin 334 * scale <= 1 / fmin / fmax (for |t| >= huge) 335 * 336 * In addition scale should be a negative power of two in order to avoid 337 * loss of precision. The values chosen below should work for most usual 338 * floating point representations with at least the dynamic range of ATI's 339 * 24-bit representation. 340 */ 341 const double huge_val = bit_size >= 32 ? 1e18 : 16384; 342 nir_ssa_def *huge = nir_imm_floatN_t(b, huge_val, bit_size); 343 nir_ssa_def *scale = nir_bcsel(b, nir_fge(b, nir_fabs(b, t), huge), 344 nir_imm_floatN_t(b, 0.25, bit_size), one); 345 nir_ssa_def *rcp_scaled_t = nir_frcp(b, nir_fmul(b, t, scale)); 346 nir_ssa_def *s_over_t = nir_fmul(b, nir_fmul(b, s, scale), rcp_scaled_t); 347 348 /* For |x| = |y| assume tan = 1 even if infinite (i.e. pretend momentarily 349 * that ∞/∞ = 1) in order to comply with the rather artificial rules 350 * inherited from IEEE 754-2008, namely: 351 * 352 * "atan2(±∞, −∞) is ±3π/4 353 * atan2(±∞, +∞) is ±π/4" 354 * 355 * Note that this is inconsistent with the rules for the neighborhood of 356 * zero that are based on iterated limits: 357 * 358 * "atan2(±0, −0) is ±π 359 * atan2(±0, +0) is ±0" 360 * 361 * but GLSL specifically allows implementations to deviate from IEEE rules 362 * at (0,0), so we take that license (i.e. pretend that 0/0 = 1 here as 363 * well). 364 */ 365 nir_ssa_def *tan = nir_bcsel(b, nir_feq(b, nir_fabs(b, x), nir_fabs(b, y)), 366 one, nir_fabs(b, s_over_t)); 367 368 /* Calculate the arctangent and fix up the result if we had flipped the 369 * coordinate system. 370 */ 371 nir_ssa_def *arc = 372 nir_fadd(b, nir_fmul_imm(b, nir_b2f(b, flip, bit_size), M_PI_2f), 373 build_atan(b, tan)); 374 375 /* Rather convoluted calculation of the sign of the result. When x < 0 we 376 * cannot use fsign because we need to be able to distinguish between 377 * negative and positive zero. We don't use bitwise arithmetic tricks for 378 * consistency with the GLSL front-end. When x >= 0 rcp_scaled_t will 379 * always be non-negative so this won't be able to distinguish between 380 * negative and positive zero, but we don't care because atan2 is 381 * continuous along the whole positive y = 0 half-line, so it won't affect 382 * the result significantly. 383 */ 384 return nir_bcsel(b, nir_flt(b, nir_fmin(b, y, rcp_scaled_t), zero), 385 nir_fneg(b, arc), arc); 386} 387 388static nir_op 389vtn_nir_alu_op_for_spirv_glsl_opcode(struct vtn_builder *b, 390 enum GLSLstd450 opcode) 391{ 392 switch (opcode) { 393 case GLSLstd450Round: return nir_op_fround_even; 394 case GLSLstd450RoundEven: return nir_op_fround_even; 395 case GLSLstd450Trunc: return nir_op_ftrunc; 396 case GLSLstd450FAbs: return nir_op_fabs; 397 case GLSLstd450SAbs: return nir_op_iabs; 398 case GLSLstd450FSign: return nir_op_fsign; 399 case GLSLstd450SSign: return nir_op_isign; 400 case GLSLstd450Floor: return nir_op_ffloor; 401 case GLSLstd450Ceil: return nir_op_fceil; 402 case GLSLstd450Fract: return nir_op_ffract; 403 case GLSLstd450Sin: return nir_op_fsin; 404 case GLSLstd450Cos: return nir_op_fcos; 405 case GLSLstd450Pow: return nir_op_fpow; 406 case GLSLstd450Exp2: return nir_op_fexp2; 407 case GLSLstd450Log2: return nir_op_flog2; 408 case GLSLstd450Sqrt: return nir_op_fsqrt; 409 case GLSLstd450InverseSqrt: return nir_op_frsq; 410 case GLSLstd450NMin: return nir_op_fmin; 411 case GLSLstd450FMin: return nir_op_fmin; 412 case GLSLstd450UMin: return nir_op_umin; 413 case GLSLstd450SMin: return nir_op_imin; 414 case GLSLstd450NMax: return nir_op_fmax; 415 case GLSLstd450FMax: return nir_op_fmax; 416 case GLSLstd450UMax: return nir_op_umax; 417 case GLSLstd450SMax: return nir_op_imax; 418 case GLSLstd450FMix: return nir_op_flrp; 419 case GLSLstd450Fma: return nir_op_ffma; 420 case GLSLstd450Ldexp: return nir_op_ldexp; 421 case GLSLstd450FindILsb: return nir_op_find_lsb; 422 case GLSLstd450FindSMsb: return nir_op_ifind_msb; 423 case GLSLstd450FindUMsb: return nir_op_ufind_msb; 424 425 /* Packing/Unpacking functions */ 426 case GLSLstd450PackSnorm4x8: return nir_op_pack_snorm_4x8; 427 case GLSLstd450PackUnorm4x8: return nir_op_pack_unorm_4x8; 428 case GLSLstd450PackSnorm2x16: return nir_op_pack_snorm_2x16; 429 case GLSLstd450PackUnorm2x16: return nir_op_pack_unorm_2x16; 430 case GLSLstd450PackHalf2x16: return nir_op_pack_half_2x16; 431 case GLSLstd450PackDouble2x32: return nir_op_pack_64_2x32; 432 case GLSLstd450UnpackSnorm4x8: return nir_op_unpack_snorm_4x8; 433 case GLSLstd450UnpackUnorm4x8: return nir_op_unpack_unorm_4x8; 434 case GLSLstd450UnpackSnorm2x16: return nir_op_unpack_snorm_2x16; 435 case GLSLstd450UnpackUnorm2x16: return nir_op_unpack_unorm_2x16; 436 case GLSLstd450UnpackHalf2x16: return nir_op_unpack_half_2x16; 437 case GLSLstd450UnpackDouble2x32: return nir_op_unpack_64_2x32; 438 439 default: 440 vtn_fail("No NIR equivalent"); 441 } 442} 443 444#define NIR_IMM_FP(n, v) (nir_imm_floatN_t(n, v, src[0]->bit_size)) 445 446static void 447handle_glsl450_alu(struct vtn_builder *b, enum GLSLstd450 entrypoint, 448 const uint32_t *w, unsigned count) 449{ 450 struct nir_builder *nb = &b->nb; 451 const struct glsl_type *dest_type = 452 vtn_value(b, w[1], vtn_value_type_type)->type->type; 453 454 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa); 455 val->ssa = vtn_create_ssa_value(b, dest_type); 456 457 /* Collect the various SSA sources */ 458 unsigned num_inputs = count - 5; 459 nir_ssa_def *src[3] = { NULL, }; 460 for (unsigned i = 0; i < num_inputs; i++) { 461 /* These are handled specially below */ 462 if (vtn_untyped_value(b, w[i + 5])->value_type == vtn_value_type_pointer) 463 continue; 464 465 src[i] = vtn_ssa_value(b, w[i + 5])->def; 466 } 467 468 switch (entrypoint) { 469 case GLSLstd450Radians: 470 val->ssa->def = nir_radians(nb, src[0]); 471 return; 472 case GLSLstd450Degrees: 473 val->ssa->def = nir_degrees(nb, src[0]); 474 return; 475 case GLSLstd450Tan: 476 val->ssa->def = nir_fdiv(nb, nir_fsin(nb, src[0]), 477 nir_fcos(nb, src[0])); 478 return; 479 480 case GLSLstd450Modf: { 481 nir_ssa_def *sign = nir_fsign(nb, src[0]); 482 nir_ssa_def *abs = nir_fabs(nb, src[0]); 483 val->ssa->def = nir_fmul(nb, sign, nir_ffract(nb, abs)); 484 nir_store_deref(nb, vtn_nir_deref(b, w[6]), 485 nir_fmul(nb, sign, nir_ffloor(nb, abs)), 0xf); 486 return; 487 } 488 489 case GLSLstd450ModfStruct: { 490 nir_ssa_def *sign = nir_fsign(nb, src[0]); 491 nir_ssa_def *abs = nir_fabs(nb, src[0]); 492 vtn_assert(glsl_type_is_struct_or_ifc(val->ssa->type)); 493 val->ssa->elems[0]->def = nir_fmul(nb, sign, nir_ffract(nb, abs)); 494 val->ssa->elems[1]->def = nir_fmul(nb, sign, nir_ffloor(nb, abs)); 495 return; 496 } 497 498 case GLSLstd450Step: 499 val->ssa->def = nir_sge(nb, src[1], src[0]); 500 return; 501 502 case GLSLstd450Length: 503 val->ssa->def = nir_fast_length(nb, src[0]); 504 return; 505 case GLSLstd450Distance: 506 val->ssa->def = nir_fast_distance(nb, src[0], src[1]); 507 return; 508 case GLSLstd450Normalize: 509 val->ssa->def = nir_fast_normalize(nb, src[0]); 510 return; 511 512 case GLSLstd450Exp: 513 val->ssa->def = build_exp(nb, src[0]); 514 return; 515 516 case GLSLstd450Log: 517 val->ssa->def = build_log(nb, src[0]); 518 return; 519 520 case GLSLstd450FClamp: 521 case GLSLstd450NClamp: 522 val->ssa->def = nir_fclamp(nb, src[0], src[1], src[2]); 523 return; 524 case GLSLstd450UClamp: 525 val->ssa->def = nir_uclamp(nb, src[0], src[1], src[2]); 526 return; 527 case GLSLstd450SClamp: 528 val->ssa->def = nir_iclamp(nb, src[0], src[1], src[2]); 529 return; 530 531 case GLSLstd450Cross: { 532 val->ssa->def = nir_cross3(nb, src[0], src[1]); 533 return; 534 } 535 536 case GLSLstd450SmoothStep: { 537 val->ssa->def = nir_smoothstep(nb, src[0], src[1], src[2]); 538 return; 539 } 540 541 case GLSLstd450FaceForward: 542 val->ssa->def = 543 nir_bcsel(nb, nir_flt(nb, nir_fdot(nb, src[2], src[1]), 544 NIR_IMM_FP(nb, 0.0)), 545 src[0], nir_fneg(nb, src[0])); 546 return; 547 548 case GLSLstd450Reflect: 549 /* I - 2 * dot(N, I) * N */ 550 val->ssa->def = 551 nir_fsub(nb, src[0], nir_fmul(nb, NIR_IMM_FP(nb, 2.0), 552 nir_fmul(nb, nir_fdot(nb, src[0], src[1]), 553 src[1]))); 554 return; 555 556 case GLSLstd450Refract: { 557 nir_ssa_def *I = src[0]; 558 nir_ssa_def *N = src[1]; 559 nir_ssa_def *eta = src[2]; 560 nir_ssa_def *n_dot_i = nir_fdot(nb, N, I); 561 nir_ssa_def *one = NIR_IMM_FP(nb, 1.0); 562 nir_ssa_def *zero = NIR_IMM_FP(nb, 0.0); 563 /* According to the SPIR-V and GLSL specs, eta is always a float 564 * regardless of the type of the other operands. However in practice it 565 * seems that if you try to pass it a float then glslang will just 566 * promote it to a double and generate invalid SPIR-V. In order to 567 * support a hypothetical fixed version of glslang we’ll promote eta to 568 * double if the other operands are double also. 569 */ 570 if (I->bit_size != eta->bit_size) { 571 nir_op conversion_op = 572 nir_type_conversion_op(nir_type_float | eta->bit_size, 573 nir_type_float | I->bit_size, 574 nir_rounding_mode_undef); 575 eta = nir_build_alu(nb, conversion_op, eta, NULL, NULL, NULL); 576 } 577 /* k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I)) */ 578 nir_ssa_def *k = 579 nir_fsub(nb, one, nir_fmul(nb, eta, nir_fmul(nb, eta, 580 nir_fsub(nb, one, nir_fmul(nb, n_dot_i, n_dot_i))))); 581 nir_ssa_def *result = 582 nir_fsub(nb, nir_fmul(nb, eta, I), 583 nir_fmul(nb, nir_fadd(nb, nir_fmul(nb, eta, n_dot_i), 584 nir_fsqrt(nb, k)), N)); 585 /* XXX: bcsel, or if statement? */ 586 val->ssa->def = nir_bcsel(nb, nir_flt(nb, k, zero), zero, result); 587 return; 588 } 589 590 case GLSLstd450Sinh: 591 /* 0.5 * (e^x - e^(-x)) */ 592 val->ssa->def = 593 nir_fmul_imm(nb, nir_fsub(nb, build_exp(nb, src[0]), 594 build_exp(nb, nir_fneg(nb, src[0]))), 595 0.5f); 596 return; 597 598 case GLSLstd450Cosh: 599 /* 0.5 * (e^x + e^(-x)) */ 600 val->ssa->def = 601 nir_fmul_imm(nb, nir_fadd(nb, build_exp(nb, src[0]), 602 build_exp(nb, nir_fneg(nb, src[0]))), 603 0.5f); 604 return; 605 606 case GLSLstd450Tanh: { 607 /* tanh(x) := (0.5 * (e^x - e^(-x))) / (0.5 * (e^x + e^(-x))) 608 * 609 * With a little algebra this reduces to (e^2x - 1) / (e^2x + 1) 610 * 611 * We clamp x to (-inf, +10] to avoid precision problems. When x > 10, 612 * e^2x is so much larger than 1.0 that 1.0 gets flushed to zero in the 613 * computation e^2x +/- 1 so it can be ignored. 614 * 615 * For 16-bit precision we clamp x to (-inf, +4.2] since the maximum 616 * representable number is only 65,504 and e^(2*6) exceeds that. Also, 617 * if x > 4.2, tanh(x) will return 1.0 in fp16. 618 */ 619 const uint32_t bit_size = src[0]->bit_size; 620 const double clamped_x = bit_size > 16 ? 10.0 : 4.2; 621 nir_ssa_def *x = nir_fmin(nb, src[0], 622 nir_imm_floatN_t(nb, clamped_x, bit_size)); 623 nir_ssa_def *exp2x = build_exp(nb, nir_fmul_imm(nb, x, 2.0)); 624 val->ssa->def = nir_fdiv(nb, nir_fadd_imm(nb, exp2x, -1.0), 625 nir_fadd_imm(nb, exp2x, 1.0)); 626 return; 627 } 628 629 case GLSLstd450Asinh: 630 val->ssa->def = nir_fmul(nb, nir_fsign(nb, src[0]), 631 build_log(nb, nir_fadd(nb, nir_fabs(nb, src[0]), 632 nir_fsqrt(nb, nir_fadd_imm(nb, nir_fmul(nb, src[0], src[0]), 633 1.0f))))); 634 return; 635 case GLSLstd450Acosh: 636 val->ssa->def = build_log(nb, nir_fadd(nb, src[0], 637 nir_fsqrt(nb, nir_fadd_imm(nb, nir_fmul(nb, src[0], src[0]), 638 -1.0f)))); 639 return; 640 case GLSLstd450Atanh: { 641 nir_ssa_def *one = nir_imm_floatN_t(nb, 1.0, src[0]->bit_size); 642 val->ssa->def = 643 nir_fmul_imm(nb, build_log(nb, nir_fdiv(nb, nir_fadd(nb, src[0], one), 644 nir_fsub(nb, one, src[0]))), 645 0.5f); 646 return; 647 } 648 649 case GLSLstd450Asin: 650 val->ssa->def = build_asin(nb, src[0], 0.086566724, -0.03102955); 651 return; 652 653 case GLSLstd450Acos: 654 val->ssa->def = 655 nir_fsub(nb, nir_imm_floatN_t(nb, M_PI_2f, src[0]->bit_size), 656 build_asin(nb, src[0], 0.08132463, -0.02363318)); 657 return; 658 659 case GLSLstd450Atan: 660 val->ssa->def = build_atan(nb, src[0]); 661 return; 662 663 case GLSLstd450Atan2: 664 val->ssa->def = build_atan2(nb, src[0], src[1]); 665 return; 666 667 case GLSLstd450Frexp: { 668 nir_ssa_def *exponent = nir_frexp_exp(nb, src[0]); 669 val->ssa->def = nir_frexp_sig(nb, src[0]); 670 nir_store_deref(nb, vtn_nir_deref(b, w[6]), exponent, 0xf); 671 return; 672 } 673 674 case GLSLstd450FrexpStruct: { 675 vtn_assert(glsl_type_is_struct_or_ifc(val->ssa->type)); 676 val->ssa->elems[0]->def = nir_frexp_sig(nb, src[0]); 677 val->ssa->elems[1]->def = nir_frexp_exp(nb, src[0]); 678 return; 679 } 680 681 default: 682 val->ssa->def = 683 nir_build_alu(&b->nb, 684 vtn_nir_alu_op_for_spirv_glsl_opcode(b, entrypoint), 685 src[0], src[1], src[2], NULL); 686 return; 687 } 688} 689 690static void 691handle_glsl450_interpolation(struct vtn_builder *b, enum GLSLstd450 opcode, 692 const uint32_t *w, unsigned count) 693{ 694 const struct glsl_type *dest_type = 695 vtn_value(b, w[1], vtn_value_type_type)->type->type; 696 697 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa); 698 val->ssa = vtn_create_ssa_value(b, dest_type); 699 700 nir_intrinsic_op op; 701 switch (opcode) { 702 case GLSLstd450InterpolateAtCentroid: 703 op = nir_intrinsic_interp_deref_at_centroid; 704 break; 705 case GLSLstd450InterpolateAtSample: 706 op = nir_intrinsic_interp_deref_at_sample; 707 break; 708 case GLSLstd450InterpolateAtOffset: 709 op = nir_intrinsic_interp_deref_at_offset; 710 break; 711 default: 712 vtn_fail("Invalid opcode"); 713 } 714 715 nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->nb.shader, op); 716 717 struct vtn_pointer *ptr = 718 vtn_value(b, w[5], vtn_value_type_pointer)->pointer; 719 nir_deref_instr *deref = vtn_pointer_to_deref(b, ptr); 720 721 /* If the value we are interpolating has an index into a vector then 722 * interpolate the vector and index the result of that instead. This is 723 * necessary because the index will get generated as a series of nir_bcsel 724 * instructions so it would no longer be an input variable. 725 */ 726 const bool vec_array_deref = deref->deref_type == nir_deref_type_array && 727 glsl_type_is_vector(nir_deref_instr_parent(deref)->type); 728 729 nir_deref_instr *vec_deref = NULL; 730 if (vec_array_deref) { 731 vec_deref = deref; 732 deref = nir_deref_instr_parent(deref); 733 } 734 intrin->src[0] = nir_src_for_ssa(&deref->dest.ssa); 735 736 switch (opcode) { 737 case GLSLstd450InterpolateAtCentroid: 738 break; 739 case GLSLstd450InterpolateAtSample: 740 case GLSLstd450InterpolateAtOffset: 741 intrin->src[1] = nir_src_for_ssa(vtn_ssa_value(b, w[6])->def); 742 break; 743 default: 744 vtn_fail("Invalid opcode"); 745 } 746 747 intrin->num_components = glsl_get_vector_elements(deref->type); 748 nir_ssa_dest_init(&intrin->instr, &intrin->dest, 749 glsl_get_vector_elements(deref->type), 750 glsl_get_bit_size(deref->type), NULL); 751 752 nir_builder_instr_insert(&b->nb, &intrin->instr); 753 754 if (vec_array_deref) { 755 assert(vec_deref); 756 if (nir_src_is_const(vec_deref->arr.index)) { 757 val->ssa->def = vtn_vector_extract(b, &intrin->dest.ssa, 758 nir_src_as_uint(vec_deref->arr.index)); 759 } else { 760 val->ssa->def = vtn_vector_extract_dynamic(b, &intrin->dest.ssa, 761 vec_deref->arr.index.ssa); 762 } 763 } else { 764 val->ssa->def = &intrin->dest.ssa; 765 } 766} 767 768bool 769vtn_handle_glsl450_instruction(struct vtn_builder *b, SpvOp ext_opcode, 770 const uint32_t *w, unsigned count) 771{ 772 switch ((enum GLSLstd450)ext_opcode) { 773 case GLSLstd450Determinant: { 774 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa); 775 val->ssa = rzalloc(b, struct vtn_ssa_value); 776 val->ssa->type = vtn_value(b, w[1], vtn_value_type_type)->type->type; 777 val->ssa->def = build_mat_det(b, vtn_ssa_value(b, w[5])); 778 break; 779 } 780 781 case GLSLstd450MatrixInverse: { 782 struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_ssa); 783 val->ssa = matrix_inverse(b, vtn_ssa_value(b, w[5])); 784 break; 785 } 786 787 case GLSLstd450InterpolateAtCentroid: 788 case GLSLstd450InterpolateAtSample: 789 case GLSLstd450InterpolateAtOffset: 790 handle_glsl450_interpolation(b, (enum GLSLstd450)ext_opcode, w, count); 791 break; 792 793 default: 794 handle_glsl450_alu(b, (enum GLSLstd450)ext_opcode, w, count); 795 } 796 797 return true; 798} 799