*
*/
+#include <math.h>
+
+#include "nir/nir_builtin_builder.h"
+
#include "vtn_private.h"
#include "GLSL.std.450.h"
static nir_ssa_def *
build_mat2_det(nir_builder *b, nir_ssa_def *col[2])
{
- unsigned swiz[4] = {1, 0, 0, 0};
- nir_ssa_def *p = nir_fmul(b, col[0], nir_swizzle(b, col[1], swiz, 2, true));
+ unsigned swiz[2] = {1, 0 };
+ nir_ssa_def *p = nir_fmul(b, col[0], nir_swizzle(b, col[1], swiz, 2));
return nir_fsub(b, nir_channel(b, p, 0), nir_channel(b, p, 1));
}
static nir_ssa_def *
build_mat3_det(nir_builder *b, nir_ssa_def *col[3])
{
- unsigned yzx[4] = {1, 2, 0, 0};
- unsigned zxy[4] = {2, 0, 1, 0};
+ unsigned yzx[3] = {1, 2, 0 };
+ unsigned zxy[3] = {2, 0, 1 };
nir_ssa_def *prod0 =
nir_fmul(b, col[0],
- nir_fmul(b, nir_swizzle(b, col[1], yzx, 3, true),
- nir_swizzle(b, col[2], zxy, 3, true)));
+ nir_fmul(b, nir_swizzle(b, col[1], yzx, 3),
+ nir_swizzle(b, col[2], zxy, 3)));
nir_ssa_def *prod1 =
nir_fmul(b, col[0],
- nir_fmul(b, nir_swizzle(b, col[1], zxy, 3, true),
- nir_swizzle(b, col[2], yzx, 3, true)));
+ nir_fmul(b, nir_swizzle(b, col[1], zxy, 3),
+ nir_swizzle(b, col[2], yzx, 3)));
nir_ssa_def *diff = nir_fsub(b, prod0, prod1);
swiz[j] = j + (j >= i);
nir_ssa_def *subcol[3];
- subcol[0] = nir_swizzle(b, col[1], swiz, 3, true);
- subcol[1] = nir_swizzle(b, col[2], swiz, 3, true);
- subcol[2] = nir_swizzle(b, col[3], swiz, 3, true);
+ subcol[0] = nir_swizzle(b, col[1], swiz, 3);
+ subcol[1] = nir_swizzle(b, col[2], swiz, 3);
+ subcol[2] = nir_swizzle(b, col[3], swiz, 3);
subdet[i] = build_mat3_det(b, subcol);
}
case 3: return build_mat3_det(&b->nb, cols);
case 4: return build_mat4_det(&b->nb, cols);
default:
- unreachable("Invalid matrix size");
+ vtn_fail("Invalid matrix size");
}
}
return nir_channel(b, src->elems[1 - col]->def, 1 - row);
} else {
/* Swizzle to get all but the specified row */
- unsigned swiz[3];
+ unsigned swiz[NIR_MAX_VEC_COMPONENTS] = {0};
for (unsigned j = 0; j < 3; j++)
swiz[j] = j + (j >= row);
for (unsigned j = 0; j < size; j++) {
if (j != col) {
subcol[j - (j > col)] = nir_swizzle(b, src->elems[j]->def,
- swiz, size - 1, true);
+ swiz, size - 1);
}
}
return val;
}
-static nir_ssa_def*
-build_length(nir_builder *b, nir_ssa_def *vec)
-{
- switch (vec->num_components) {
- case 1: return nir_fsqrt(b, nir_fmul(b, vec, vec));
- case 2: return nir_fsqrt(b, nir_fdot2(b, vec, vec));
- case 3: return nir_fsqrt(b, nir_fdot3(b, vec, vec));
- case 4: return nir_fsqrt(b, nir_fdot4(b, vec, vec));
- default:
- unreachable("Invalid number of components");
- }
-}
-
-static inline nir_ssa_def *
-build_fclamp(nir_builder *b,
- nir_ssa_def *x, nir_ssa_def *min_val, nir_ssa_def *max_val)
-{
- return nir_fmin(b, nir_fmax(b, x, min_val), max_val);
-}
-
-/**
- * Return e^x.
- */
-static nir_ssa_def *
-build_exp(nir_builder *b, nir_ssa_def *x)
-{
- return nir_fexp2(b, nir_fmul(b, x, nir_imm_float(b, M_LOG2E)));
-}
-
/**
- * Return ln(x) - the natural logarithm of x.
- */
-static nir_ssa_def *
-build_log(nir_builder *b, nir_ssa_def *x)
-{
- return nir_fmul(b, nir_flog2(b, x), nir_imm_float(b, 1.0 / M_LOG2E));
-}
-
-/**
- * Approximate asin(x) by the formula:
- * asin~(x) = sign(x) * (pi/2 - sqrt(1 - |x|) * (pi/2 + |x|(pi/4 - 1 + |x|(p0 + |x|p1))))
+ * Approximate asin(x) by the piecewise formula:
+ * for |x| < 0.5, asin~(x) = x * (1 + x²(pS0 + x²(pS1 + x²*pS2)) / (1 + x²*qS1))
+ * for |x| ≥ 0.5, asin~(x) = sign(x) * (π/2 - sqrt(1 - |x|) * (π/2 + |x|(π/4 - 1 + |x|(p0 + |x|p1))))
*
- * which is correct to first order at x=0 and x=±1 regardless of the p
+ * The latter is correct to first order at x=0 and x=±1 regardless of the p
* coefficients but can be made second-order correct at both ends by selecting
* the fit coefficients appropriately. Different p coefficients can be used
* in the asin and acos implementation to minimize some relative error metric
* in each case.
*/
static nir_ssa_def *
-build_asin(nir_builder *b, nir_ssa_def *x, float p0, float p1)
-{
- nir_ssa_def *abs_x = nir_fabs(b, x);
- return nir_fmul(b, nir_fsign(b, x),
- nir_fsub(b, nir_imm_float(b, M_PI_2f),
- nir_fmul(b, nir_fsqrt(b, nir_fsub(b, nir_imm_float(b, 1.0f), abs_x)),
- nir_fadd(b, nir_imm_float(b, M_PI_2f),
- nir_fmul(b, abs_x,
- nir_fadd(b, nir_imm_float(b, M_PI_4f - 1.0f),
- nir_fmul(b, abs_x,
- nir_fadd(b, nir_imm_float(b, p0),
- nir_fmul(b, abs_x,
- nir_imm_float(b, p1))))))))));
-}
-
-/**
- * Compute xs[0] + xs[1] + xs[2] + ... using fadd.
- */
-static nir_ssa_def *
-build_fsum(nir_builder *b, nir_ssa_def **xs, int terms)
-{
- nir_ssa_def *accum = xs[0];
-
- for (int i = 1; i < terms; i++)
- accum = nir_fadd(b, accum, xs[i]);
-
- return accum;
-}
-
-static nir_ssa_def *
-build_atan(nir_builder *b, nir_ssa_def *y_over_x)
-{
- nir_ssa_def *abs_y_over_x = nir_fabs(b, y_over_x);
- nir_ssa_def *one = nir_imm_float(b, 1.0f);
-
- /*
- * range-reduction, first step:
- *
- * / y_over_x if |y_over_x| <= 1.0;
- * x = <
- * \ 1.0 / y_over_x otherwise
- */
- nir_ssa_def *x = nir_fdiv(b, nir_fmin(b, abs_y_over_x, one),
- nir_fmax(b, abs_y_over_x, one));
-
- /*
- * approximate atan by evaluating polynomial:
- *
- * x * 0.9999793128310355 - x^3 * 0.3326756418091246 +
- * x^5 * 0.1938924977115610 - x^7 * 0.1173503194786851 +
- * x^9 * 0.0536813784310406 - x^11 * 0.0121323213173444
- */
- nir_ssa_def *x_2 = nir_fmul(b, x, x);
- nir_ssa_def *x_3 = nir_fmul(b, x_2, x);
- nir_ssa_def *x_5 = nir_fmul(b, x_3, x_2);
- nir_ssa_def *x_7 = nir_fmul(b, x_5, x_2);
- nir_ssa_def *x_9 = nir_fmul(b, x_7, x_2);
- nir_ssa_def *x_11 = nir_fmul(b, x_9, x_2);
-
- nir_ssa_def *polynomial_terms[] = {
- nir_fmul(b, x, nir_imm_float(b, 0.9999793128310355f)),
- nir_fmul(b, x_3, nir_imm_float(b, -0.3326756418091246f)),
- nir_fmul(b, x_5, nir_imm_float(b, 0.1938924977115610f)),
- nir_fmul(b, x_7, nir_imm_float(b, -0.1173503194786851f)),
- nir_fmul(b, x_9, nir_imm_float(b, 0.0536813784310406f)),
- nir_fmul(b, x_11, nir_imm_float(b, -0.0121323213173444f)),
- };
-
- nir_ssa_def *tmp =
- build_fsum(b, polynomial_terms, ARRAY_SIZE(polynomial_terms));
-
- /* range-reduction fixup */
- tmp = nir_fadd(b, tmp,
- nir_fmul(b,
- nir_b2f(b, nir_flt(b, one, abs_y_over_x)),
- nir_fadd(b, nir_fmul(b, tmp,
- nir_imm_float(b, -2.0f)),
- nir_imm_float(b, M_PI_2f))));
-
- /* sign fixup */
- return nir_fmul(b, tmp, nir_fsign(b, y_over_x));
-}
-
-static nir_ssa_def *
-build_atan2(nir_builder *b, nir_ssa_def *y, nir_ssa_def *x)
-{
- nir_ssa_def *zero = nir_imm_float(b, 0.0f);
-
- /* If |x| >= 1.0e-8 * |y|: */
- nir_ssa_def *condition =
- nir_fge(b, nir_fabs(b, x),
- nir_fmul(b, nir_imm_float(b, 1.0e-8f), nir_fabs(b, y)));
-
- /* Then...call atan(y/x) and fix it up: */
- nir_ssa_def *atan1 = build_atan(b, nir_fdiv(b, y, x));
- nir_ssa_def *r_then =
- nir_bcsel(b, nir_flt(b, x, zero),
- nir_fadd(b, atan1,
- nir_bcsel(b, nir_fge(b, y, zero),
- nir_imm_float(b, M_PIf),
- nir_imm_float(b, -M_PIf))),
- atan1);
-
- /* Else... */
- nir_ssa_def *r_else =
- nir_fmul(b, nir_fsign(b, y), nir_imm_float(b, M_PI_2f));
-
- return nir_bcsel(b, condition, r_then, r_else);
-}
-
-static nir_ssa_def *
-build_frexp(nir_builder *b, nir_ssa_def *x, nir_ssa_def **exponent)
+build_asin(nir_builder *b, nir_ssa_def *x, float p0, float p1, bool piecewise)
{
+ if (x->bit_size == 16) {
+ /* The polynomial approximation isn't precise enough to meet half-float
+ * precision requirements. Alternatively, we could implement this using
+ * the formula:
+ *
+ * asin(x) = atan2(x, sqrt(1 - x*x))
+ *
+ * But that is very expensive, so instead we just do the polynomial
+ * approximation in 32-bit math and then we convert the result back to
+ * 16-bit.
+ */
+ return nir_f2f16(b, build_asin(b, nir_f2f32(b, x), p0, p1, piecewise));
+ }
+ nir_ssa_def *one = nir_imm_floatN_t(b, 1.0f, x->bit_size);
+ nir_ssa_def *half = nir_imm_floatN_t(b, 0.5f, x->bit_size);
nir_ssa_def *abs_x = nir_fabs(b, x);
- nir_ssa_def *zero = nir_imm_float(b, 0.0f);
-
- /* Single-precision floating-point values are stored as
- * 1 sign bit;
- * 8 exponent bits;
- * 23 mantissa bits.
- *
- * An exponent shift of 23 will shift the mantissa out, leaving only the
- * exponent and sign bit (which itself may be zero, if the absolute value
- * was taken before the bitcast and shift.
- */
- nir_ssa_def *exponent_shift = nir_imm_int(b, 23);
- nir_ssa_def *exponent_bias = nir_imm_int(b, -126);
-
- nir_ssa_def *sign_mantissa_mask = nir_imm_int(b, 0x807fffffu);
-
- /* Exponent of floating-point values in the range [0.5, 1.0). */
- nir_ssa_def *exponent_value = nir_imm_int(b, 0x3f000000u);
-
- nir_ssa_def *is_not_zero = nir_fne(b, abs_x, zero);
- *exponent =
- nir_iadd(b, nir_ushr(b, abs_x, exponent_shift),
- nir_bcsel(b, is_not_zero, exponent_bias, zero));
-
- return nir_ior(b, nir_iand(b, x, sign_mantissa_mask),
- nir_bcsel(b, is_not_zero, exponent_value, zero));
+ nir_ssa_def *p0_plus_xp1 = nir_fadd_imm(b, nir_fmul_imm(b, abs_x, p1), p0);
+
+ nir_ssa_def *expr_tail =
+ nir_fadd_imm(b, nir_fmul(b, abs_x,
+ nir_fadd_imm(b, nir_fmul(b, abs_x,
+ p0_plus_xp1),
+ M_PI_4f - 1.0f)),
+ M_PI_2f);
+
+ nir_ssa_def *result0 = nir_fmul(b, nir_fsign(b, x),
+ nir_fsub(b, nir_imm_floatN_t(b, M_PI_2f, x->bit_size),
+ nir_fmul(b, nir_fsqrt(b, nir_fsub(b, one, abs_x)),
+ expr_tail)));
+ if (piecewise) {
+ /* approximation for |x| < 0.5 */
+ const float pS0 = 1.6666586697e-01f;
+ const float pS1 = -4.2743422091e-02f;
+ const float pS2 = -8.6563630030e-03f;
+ const float qS1 = -7.0662963390e-01f;
+
+ nir_ssa_def *x2 = nir_fmul(b, x, x);
+ nir_ssa_def *p = nir_fmul(b,
+ x2,
+ nir_fadd_imm(b,
+ nir_fmul(b,
+ x2,
+ nir_fadd_imm(b, nir_fmul_imm(b, x2, pS2),
+ pS1)),
+ pS0));
+
+ nir_ssa_def *q = nir_fadd(b, one, nir_fmul_imm(b, x2, qS1));
+ nir_ssa_def *result1 = nir_fadd(b, x, nir_fmul(b, x, nir_fdiv(b, p, q)));
+ return nir_bcsel(b, nir_flt(b, abs_x, half), result1, result0);
+ } else {
+ return result0;
+ }
}
static nir_op
-vtn_nir_alu_op_for_spirv_glsl_opcode(enum GLSLstd450 opcode)
+vtn_nir_alu_op_for_spirv_glsl_opcode(struct vtn_builder *b,
+ enum GLSLstd450 opcode,
+ unsigned execution_mode,
+ bool *exact)
{
+ *exact = false;
switch (opcode) {
case GLSLstd450Round: return nir_op_fround_even;
case GLSLstd450RoundEven: return nir_op_fround_even;
case GLSLstd450Log2: return nir_op_flog2;
case GLSLstd450Sqrt: return nir_op_fsqrt;
case GLSLstd450InverseSqrt: return nir_op_frsq;
+ case GLSLstd450NMin: *exact = true; return nir_op_fmin;
case GLSLstd450FMin: return nir_op_fmin;
case GLSLstd450UMin: return nir_op_umin;
case GLSLstd450SMin: return nir_op_imin;
+ case GLSLstd450NMax: *exact = true; return nir_op_fmax;
case GLSLstd450FMax: return nir_op_fmax;
case GLSLstd450UMax: return nir_op_umax;
case GLSLstd450SMax: return nir_op_imax;
case GLSLstd450PackSnorm2x16: return nir_op_pack_snorm_2x16;
case GLSLstd450PackUnorm2x16: return nir_op_pack_unorm_2x16;
case GLSLstd450PackHalf2x16: return nir_op_pack_half_2x16;
+ case GLSLstd450PackDouble2x32: return nir_op_pack_64_2x32;
case GLSLstd450UnpackSnorm4x8: return nir_op_unpack_snorm_4x8;
case GLSLstd450UnpackUnorm4x8: return nir_op_unpack_unorm_4x8;
case GLSLstd450UnpackSnorm2x16: return nir_op_unpack_snorm_2x16;
case GLSLstd450UnpackUnorm2x16: return nir_op_unpack_unorm_2x16;
- case GLSLstd450UnpackHalf2x16: return nir_op_unpack_half_2x16;
+ case GLSLstd450UnpackHalf2x16:
+ if (execution_mode & FLOAT_CONTROLS_DENORM_FLUSH_TO_ZERO_FP16)
+ return nir_op_unpack_half_2x16_flush_to_zero;
+ else
+ return nir_op_unpack_half_2x16;
+ case GLSLstd450UnpackDouble2x32: return nir_op_unpack_64_2x32;
default:
- unreachable("No NIR equivalent");
+ vtn_fail("No NIR equivalent");
}
}
+#define NIR_IMM_FP(n, v) (nir_imm_floatN_t(n, v, src[0]->bit_size))
+
static void
handle_glsl450_alu(struct vtn_builder *b, enum GLSLstd450 entrypoint,
const uint32_t *w, unsigned count)
/* Collect the various SSA sources */
unsigned num_inputs = count - 5;
nir_ssa_def *src[3] = { NULL, };
- for (unsigned i = 0; i < num_inputs; i++)
+ for (unsigned i = 0; i < num_inputs; i++) {
+ /* These are handled specially below */
+ if (vtn_untyped_value(b, w[i + 5])->value_type == vtn_value_type_pointer)
+ continue;
+
src[i] = vtn_ssa_value(b, w[i + 5])->def;
+ }
switch (entrypoint) {
case GLSLstd450Radians:
- val->ssa->def = nir_fmul(nb, src[0], nir_imm_float(nb, 0.01745329251));
+ val->ssa->def = nir_radians(nb, src[0]);
return;
case GLSLstd450Degrees:
- val->ssa->def = nir_fmul(nb, src[0], nir_imm_float(nb, 57.2957795131));
+ val->ssa->def = nir_degrees(nb, src[0]);
return;
case GLSLstd450Tan:
- val->ssa->def = nir_fdiv(nb, nir_fsin(nb, src[0]),
- nir_fcos(nb, src[0]));
+ val->ssa->def = nir_ftan(nb, src[0]);
return;
case GLSLstd450Modf: {
nir_ssa_def *sign = nir_fsign(nb, src[0]);
nir_ssa_def *abs = nir_fabs(nb, src[0]);
val->ssa->def = nir_fmul(nb, sign, nir_ffract(nb, abs));
- nir_store_deref_var(nb, vtn_nir_deref(b, w[6]),
- nir_fmul(nb, sign, nir_ffloor(nb, abs)), 0xf);
+ nir_store_deref(nb, vtn_nir_deref(b, w[6]),
+ nir_fmul(nb, sign, nir_ffloor(nb, abs)), 0xf);
return;
}
case GLSLstd450ModfStruct: {
nir_ssa_def *sign = nir_fsign(nb, src[0]);
nir_ssa_def *abs = nir_fabs(nb, src[0]);
- assert(glsl_type_is_struct(val->ssa->type));
+ vtn_assert(glsl_type_is_struct_or_ifc(val->ssa->type));
val->ssa->elems[0]->def = nir_fmul(nb, sign, nir_ffract(nb, abs));
val->ssa->elems[1]->def = nir_fmul(nb, sign, nir_ffloor(nb, abs));
return;
return;
case GLSLstd450Length:
- val->ssa->def = build_length(nb, src[0]);
+ val->ssa->def = nir_fast_length(nb, src[0]);
return;
case GLSLstd450Distance:
- val->ssa->def = build_length(nb, nir_fsub(nb, src[0], src[1]));
+ val->ssa->def = nir_fast_distance(nb, src[0], src[1]);
return;
case GLSLstd450Normalize:
- val->ssa->def = nir_fdiv(nb, src[0], build_length(nb, src[0]));
+ val->ssa->def = nir_fast_normalize(nb, src[0]);
return;
case GLSLstd450Exp:
- val->ssa->def = build_exp(nb, src[0]);
+ val->ssa->def = nir_fexp(nb, src[0]);
return;
case GLSLstd450Log:
- val->ssa->def = build_log(nb, src[0]);
+ val->ssa->def = nir_flog(nb, src[0]);
return;
case GLSLstd450FClamp:
- val->ssa->def = build_fclamp(nb, src[0], src[1], src[2]);
+ val->ssa->def = nir_fclamp(nb, src[0], src[1], src[2]);
+ return;
+ case GLSLstd450NClamp:
+ nb->exact = true;
+ val->ssa->def = nir_fclamp(nb, src[0], src[1], src[2]);
+ nb->exact = false;
return;
case GLSLstd450UClamp:
- val->ssa->def = nir_umin(nb, nir_umax(nb, src[0], src[1]), src[2]);
+ val->ssa->def = nir_uclamp(nb, src[0], src[1], src[2]);
return;
case GLSLstd450SClamp:
- val->ssa->def = nir_imin(nb, nir_imax(nb, src[0], src[1]), src[2]);
+ val->ssa->def = nir_iclamp(nb, src[0], src[1], src[2]);
return;
case GLSLstd450Cross: {
- unsigned yzx[4] = { 1, 2, 0, 0 };
- unsigned zxy[4] = { 2, 0, 1, 0 };
- val->ssa->def =
- nir_fsub(nb, nir_fmul(nb, nir_swizzle(nb, src[0], yzx, 3, true),
- nir_swizzle(nb, src[1], zxy, 3, true)),
- nir_fmul(nb, nir_swizzle(nb, src[0], zxy, 3, true),
- nir_swizzle(nb, src[1], yzx, 3, true)));
+ val->ssa->def = nir_cross3(nb, src[0], src[1]);
return;
}
case GLSLstd450SmoothStep: {
- /* t = clamp((x - edge0) / (edge1 - edge0), 0, 1) */
- nir_ssa_def *t =
- build_fclamp(nb, nir_fdiv(nb, nir_fsub(nb, src[2], src[0]),
- nir_fsub(nb, src[1], src[0])),
- nir_imm_float(nb, 0.0), nir_imm_float(nb, 1.0));
- /* result = t * t * (3 - 2 * t) */
- val->ssa->def =
- nir_fmul(nb, t, nir_fmul(nb, t,
- nir_fsub(nb, nir_imm_float(nb, 3.0),
- nir_fmul(nb, nir_imm_float(nb, 2.0), t))));
+ val->ssa->def = nir_smoothstep(nb, src[0], src[1], src[2]);
return;
}
case GLSLstd450FaceForward:
val->ssa->def =
nir_bcsel(nb, nir_flt(nb, nir_fdot(nb, src[2], src[1]),
- nir_imm_float(nb, 0.0)),
+ NIR_IMM_FP(nb, 0.0)),
src[0], nir_fneg(nb, src[0]));
return;
case GLSLstd450Reflect:
/* I - 2 * dot(N, I) * N */
val->ssa->def =
- nir_fsub(nb, src[0], nir_fmul(nb, nir_imm_float(nb, 2.0),
+ nir_fsub(nb, src[0], nir_fmul(nb, NIR_IMM_FP(nb, 2.0),
nir_fmul(nb, nir_fdot(nb, src[0], src[1]),
src[1])));
return;
nir_ssa_def *N = src[1];
nir_ssa_def *eta = src[2];
nir_ssa_def *n_dot_i = nir_fdot(nb, N, I);
- nir_ssa_def *one = nir_imm_float(nb, 1.0);
- nir_ssa_def *zero = nir_imm_float(nb, 0.0);
+ nir_ssa_def *one = NIR_IMM_FP(nb, 1.0);
+ nir_ssa_def *zero = NIR_IMM_FP(nb, 0.0);
+ /* According to the SPIR-V and GLSL specs, eta is always a float
+ * regardless of the type of the other operands. However in practice it
+ * seems that if you try to pass it a float then glslang will just
+ * promote it to a double and generate invalid SPIR-V. In order to
+ * support a hypothetical fixed version of glslang we’ll promote eta to
+ * double if the other operands are double also.
+ */
+ if (I->bit_size != eta->bit_size) {
+ nir_op conversion_op =
+ nir_type_conversion_op(nir_type_float | eta->bit_size,
+ nir_type_float | I->bit_size,
+ nir_rounding_mode_undef);
+ eta = nir_build_alu(nb, conversion_op, eta, NULL, NULL, NULL);
+ }
/* k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I)) */
nir_ssa_def *k =
nir_fsub(nb, one, nir_fmul(nb, eta, nir_fmul(nb, eta,
case GLSLstd450Sinh:
/* 0.5 * (e^x - e^(-x)) */
val->ssa->def =
- nir_fmul(nb, nir_imm_float(nb, 0.5f),
- nir_fsub(nb, build_exp(nb, src[0]),
- build_exp(nb, nir_fneg(nb, src[0]))));
+ nir_fmul_imm(nb, nir_fsub(nb, nir_fexp(nb, src[0]),
+ nir_fexp(nb, nir_fneg(nb, src[0]))),
+ 0.5f);
return;
case GLSLstd450Cosh:
/* 0.5 * (e^x + e^(-x)) */
val->ssa->def =
- nir_fmul(nb, nir_imm_float(nb, 0.5f),
- nir_fadd(nb, build_exp(nb, src[0]),
- build_exp(nb, nir_fneg(nb, src[0]))));
+ nir_fmul_imm(nb, nir_fadd(nb, nir_fexp(nb, src[0]),
+ nir_fexp(nb, nir_fneg(nb, src[0]))),
+ 0.5f);
return;
case GLSLstd450Tanh: {
- /* tanh(x) := (0.5 * (e^x - e^(-x))) / (0.5 * (e^x + e^(-x)))
+ /* tanh(x) := (e^x - e^(-x)) / (e^x + e^(-x))
*
- * With a little algebra this reduces to (e^2x - 1) / (e^2x + 1)
+ * We clamp x to [-10, +10] to avoid precision problems. When x > 10,
+ * e^x dominates the sum, e^(-x) is lost and tanh(x) is 1.0 for 32 bit
+ * floating point.
*
- * We clamp x to (-inf, +10] to avoid precision problems. When x > 10,
- * e^2x is so much larger than 1.0 that 1.0 gets flushed to zero in the
- * computation e^2x +/- 1 so it can be ignored.
+ * For 16-bit precision this we clamp x to [-4.2, +4.2].
*/
- nir_ssa_def *x = nir_fmin(nb, src[0], nir_imm_float(nb, 10));
- nir_ssa_def *exp2x = build_exp(nb, nir_fmul(nb, x, nir_imm_float(nb, 2)));
- val->ssa->def = nir_fdiv(nb, nir_fsub(nb, exp2x, nir_imm_float(nb, 1)),
- nir_fadd(nb, exp2x, nir_imm_float(nb, 1)));
+ const uint32_t bit_size = src[0]->bit_size;
+ const double clamped_x = bit_size > 16 ? 10.0 : 4.2;
+ nir_ssa_def *x = nir_fclamp(nb, src[0],
+ nir_imm_floatN_t(nb, -clamped_x, bit_size),
+ nir_imm_floatN_t(nb, clamped_x, bit_size));
+ val->ssa->def =
+ nir_fdiv(nb, nir_fsub(nb, nir_fexp(nb, x),
+ nir_fexp(nb, nir_fneg(nb, x))),
+ nir_fadd(nb, nir_fexp(nb, x),
+ nir_fexp(nb, nir_fneg(nb, x))));
return;
}
case GLSLstd450Asinh:
val->ssa->def = nir_fmul(nb, nir_fsign(nb, src[0]),
- build_log(nb, nir_fadd(nb, nir_fabs(nb, src[0]),
- nir_fsqrt(nb, nir_fadd(nb, nir_fmul(nb, src[0], src[0]),
- nir_imm_float(nb, 1.0f))))));
+ nir_flog(nb, nir_fadd(nb, nir_fabs(nb, src[0]),
+ nir_fsqrt(nb, nir_fadd_imm(nb, nir_fmul(nb, src[0], src[0]),
+ 1.0f)))));
return;
case GLSLstd450Acosh:
- val->ssa->def = build_log(nb, nir_fadd(nb, src[0],
- nir_fsqrt(nb, nir_fsub(nb, nir_fmul(nb, src[0], src[0]),
- nir_imm_float(nb, 1.0f)))));
+ val->ssa->def = nir_flog(nb, nir_fadd(nb, src[0],
+ nir_fsqrt(nb, nir_fadd_imm(nb, nir_fmul(nb, src[0], src[0]),
+ -1.0f))));
return;
case GLSLstd450Atanh: {
- nir_ssa_def *one = nir_imm_float(nb, 1.0);
- val->ssa->def = nir_fmul(nb, nir_imm_float(nb, 0.5f),
- build_log(nb, nir_fdiv(nb, nir_fadd(nb, one, src[0]),
- nir_fsub(nb, one, src[0]))));
+ nir_ssa_def *one = nir_imm_floatN_t(nb, 1.0, src[0]->bit_size);
+ val->ssa->def =
+ nir_fmul_imm(nb, nir_flog(nb, nir_fdiv(nb, nir_fadd(nb, src[0], one),
+ nir_fsub(nb, one, src[0]))),
+ 0.5f);
return;
}
case GLSLstd450Asin:
- val->ssa->def = build_asin(nb, src[0], 0.086566724, -0.03102955);
+ val->ssa->def = build_asin(nb, src[0], 0.086566724, -0.03102955, true);
return;
case GLSLstd450Acos:
- val->ssa->def = nir_fsub(nb, nir_imm_float(nb, M_PI_2f),
- build_asin(nb, src[0], 0.08132463, -0.02363318));
+ val->ssa->def =
+ nir_fsub(nb, nir_imm_floatN_t(nb, M_PI_2f, src[0]->bit_size),
+ build_asin(nb, src[0], 0.08132463, -0.02363318, false));
return;
case GLSLstd450Atan:
- val->ssa->def = build_atan(nb, src[0]);
+ val->ssa->def = nir_atan(nb, src[0]);
return;
case GLSLstd450Atan2:
- val->ssa->def = build_atan2(nb, src[0], src[1]);
+ val->ssa->def = nir_atan2(nb, src[0], src[1]);
return;
case GLSLstd450Frexp: {
- nir_ssa_def *exponent;
- val->ssa->def = build_frexp(nb, src[0], &exponent);
- nir_store_deref_var(nb, vtn_nir_deref(b, w[6]), exponent, 0xf);
+ nir_ssa_def *exponent = nir_frexp_exp(nb, src[0]);
+ val->ssa->def = nir_frexp_sig(nb, src[0]);
+ nir_store_deref(nb, vtn_nir_deref(b, w[6]), exponent, 0xf);
return;
}
case GLSLstd450FrexpStruct: {
- assert(glsl_type_is_struct(val->ssa->type));
- val->ssa->elems[0]->def = build_frexp(nb, src[0],
- &val->ssa->elems[1]->def);
+ vtn_assert(glsl_type_is_struct_or_ifc(val->ssa->type));
+ val->ssa->elems[0]->def = nir_frexp_sig(nb, src[0]);
+ val->ssa->elems[1]->def = nir_frexp_exp(nb, src[0]);
return;
}
- default:
- val->ssa->def =
- nir_build_alu(&b->nb, vtn_nir_alu_op_for_spirv_glsl_opcode(entrypoint),
- src[0], src[1], src[2], NULL);
+ default: {
+ unsigned execution_mode =
+ b->shader->info.float_controls_execution_mode;
+ bool exact;
+ nir_op op = vtn_nir_alu_op_for_spirv_glsl_opcode(b, entrypoint, execution_mode, &exact);
+ b->nb.exact = exact;
+ val->ssa->def = nir_build_alu(&b->nb, op, src[0], src[1], src[2], NULL);
+ b->nb.exact = false;
return;
}
+ }
}
static void
nir_intrinsic_op op;
switch (opcode) {
case GLSLstd450InterpolateAtCentroid:
- op = nir_intrinsic_interp_var_at_centroid;
+ op = nir_intrinsic_interp_deref_at_centroid;
break;
case GLSLstd450InterpolateAtSample:
- op = nir_intrinsic_interp_var_at_sample;
+ op = nir_intrinsic_interp_deref_at_sample;
break;
case GLSLstd450InterpolateAtOffset:
- op = nir_intrinsic_interp_var_at_offset;
+ op = nir_intrinsic_interp_deref_at_offset;
break;
default:
- unreachable("Invalid opcode");
+ vtn_fail("Invalid opcode");
}
nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->nb.shader, op);
- nir_deref_var *deref = vtn_nir_deref(b, w[5]);
- intrin->variables[0] =
- nir_deref_as_var(nir_copy_deref(intrin, &deref->deref));
+ struct vtn_pointer *ptr =
+ vtn_value(b, w[5], vtn_value_type_pointer)->pointer;
+ nir_deref_instr *deref = vtn_pointer_to_deref(b, ptr);
+
+ /* If the value we are interpolating has an index into a vector then
+ * interpolate the vector and index the result of that instead. This is
+ * necessary because the index will get generated as a series of nir_bcsel
+ * instructions so it would no longer be an input variable.
+ */
+ const bool vec_array_deref = deref->deref_type == nir_deref_type_array &&
+ glsl_type_is_vector(nir_deref_instr_parent(deref)->type);
+
+ nir_deref_instr *vec_deref = NULL;
+ if (vec_array_deref) {
+ vec_deref = deref;
+ deref = nir_deref_instr_parent(deref);
+ }
+ intrin->src[0] = nir_src_for_ssa(&deref->dest.ssa);
switch (opcode) {
case GLSLstd450InterpolateAtCentroid:
break;
case GLSLstd450InterpolateAtSample:
case GLSLstd450InterpolateAtOffset:
- intrin->src[0] = nir_src_for_ssa(vtn_ssa_value(b, w[6])->def);
+ intrin->src[1] = nir_src_for_ssa(vtn_ssa_value(b, w[6])->def);
break;
default:
- unreachable("Invalid opcode");
+ vtn_fail("Invalid opcode");
}
- intrin->num_components = glsl_get_vector_elements(dest_type);
+ intrin->num_components = glsl_get_vector_elements(deref->type);
nir_ssa_dest_init(&intrin->instr, &intrin->dest,
- glsl_get_vector_elements(dest_type),
- glsl_get_bit_size(dest_type), NULL);
- val->ssa->def = &intrin->dest.ssa;
+ glsl_get_vector_elements(deref->type),
+ glsl_get_bit_size(deref->type), NULL);
nir_builder_instr_insert(&b->nb, &intrin->instr);
+
+ if (vec_array_deref) {
+ assert(vec_deref);
+ val->ssa->def = nir_vector_extract(&b->nb, &intrin->dest.ssa,
+ vec_deref->arr.index.ssa);
+ } else {
+ val->ssa->def = &intrin->dest.ssa;
+ }
}
bool
-vtn_handle_glsl450_instruction(struct vtn_builder *b, uint32_t ext_opcode,
+vtn_handle_glsl450_instruction(struct vtn_builder *b, SpvOp ext_opcode,
const uint32_t *w, unsigned count)
{
switch ((enum GLSLstd450)ext_opcode) {
case GLSLstd450InterpolateAtCentroid:
case GLSLstd450InterpolateAtSample:
case GLSLstd450InterpolateAtOffset:
- handle_glsl450_interpolation(b, ext_opcode, w, count);
+ handle_glsl450_interpolation(b, (enum GLSLstd450)ext_opcode, w, count);
break;
default:
projects / mesa.git / blobdiff