On Mon, Mar 7, 2016 at 12:46 AM, Samuel Iglesias Gonsálvez <
sigles...@igalia.com> wrote:
> From: Connor Abbott <connor.w.abb...@intel.com>
>
> Some opcodes need explicit bitsizes, and sometimes we need to use the
> double version when constant folding.
>
> v2: fix output type for u2f (Iago)
>
> v3: do not change vecN opcodes to be float. The next commit will add
> infrastructure to enable 64-bit integer constant folding so this is
> isn't
> really necessary. Also, that created problems with source modifiers in
> some cases (Iago)
>
> Signed-off-by: Iago Toral Quiroga <ito...@igalia.com>
> ---
> src/compiler/nir/nir_opcodes.py | 144
> +++++++++++++++++++++-------------------
> 1 file changed, 74 insertions(+), 70 deletions(-)
>
> diff --git a/src/compiler/nir/nir_opcodes.py
> b/src/compiler/nir/nir_opcodes.py
> index a37fe2d..0c91c03 100644
> --- a/src/compiler/nir/nir_opcodes.py
> +++ b/src/compiler/nir/nir_opcodes.py
> @@ -90,8 +90,12 @@ class Opcode(object):
> # helper variables for strings
> tfloat = "float"
> tint = "int"
> -tbool = "bool"
> +tbool = "bool32"
> tuint = "uint"
> +tfloat32 = "float32"
> +tint32 = "int32"
> +tuint32 = "uint32"
> +tfloat64 = "float64"
>
> commutative = "commutative "
> associative = "associative "
> @@ -155,56 +159,56 @@ unop("frsq", tfloat, "1.0f / sqrtf(src0)")
> unop("fsqrt", tfloat, "sqrtf(src0)")
> unop("fexp2", tfloat, "exp2f(src0)")
> unop("flog2", tfloat, "log2f(src0)")
> -unop_convert("f2i", tint, tfloat, "src0") # Float-to-integer conversion.
> -unop_convert("f2u", tuint, tfloat, "src0") # Float-to-unsigned conversion
> -unop_convert("i2f", tfloat, tint, "src0") # Integer-to-float conversion.
> +unop_convert("f2i", tint32, tfloat32, "src0") # Float-to-integer
> conversion.
> +unop_convert("f2u", tuint32, tfloat32, "src0") # Float-to-unsigned
> conversion
> +unop_convert("i2f", tfloat32, tint32, "src0") # Integer-to-float
> conversion.
> # Float-to-boolean conversion
> -unop_convert("f2b", tbool, tfloat, "src0 != 0.0f")
> +unop_convert("f2b", tbool, tfloat32, "src0 != 0.0f")
> # Boolean-to-float conversion
> -unop_convert("b2f", tfloat, tbool, "src0 ? 1.0f : 0.0f")
> +unop_convert("b2f", tfloat32, tbool, "src0 ? 1.0f : 0.0f")
> # Int-to-boolean conversion
> -unop_convert("i2b", tbool, tint, "src0 != 0")
> -unop_convert("b2i", tint, tbool, "src0 ? 1 : 0") # Boolean-to-int
> conversion
> -unop_convert("u2f", tfloat, tuint, "src0") # Unsigned-to-float conversion.
> +unop_convert("i2b", tbool, tint32, "src0 != 0")
> +unop_convert("b2i", tint32, tbool, "src0 ? 1 : 0") # Boolean-to-int
> conversion
> +unop_convert("u2f", tfloat32, tuint32, "src0") # Unsigned-to-float
> conversion.
>
At one poing, Connor and I discussed leaving the conversions completely
generic so we can avoid the explosion of opcodes. Connor, do you remember
if there was a good reason why to *not* do that?
>
> # Unary floating-point rounding operations.
>
>
> -unop("ftrunc", tfloat, "truncf(src0)")
> -unop("fceil", tfloat, "ceilf(src0)")
> -unop("ffloor", tfloat, "floorf(src0)")
> -unop("ffract", tfloat, "src0 - floorf(src0)")
> -unop("fround_even", tfloat, "_mesa_roundevenf(src0)")
> +unop("ftrunc", tfloat, "bit_size == 64 ? trunc(src0) : truncf(src0)")
> +unop("fceil", tfloat, "bit_size == 64 ? ceil(src0) : ceilf(src0)")
> +unop("ffloor", tfloat, "bit_size == 64 ? floor(src0) : floorf(src0)")
> +unop("ffract", tfloat, "src0 - (bit_size == 64 ? floor(src0) :
> floorf(src0))")
> +unop("fround_even", tfloat, "bit_size == 64 ? _mesa_roundeven(src0) :
> _mesa_roundevenf(src0)")
>
>
> # Trigonometric operations.
>
>
> -unop("fsin", tfloat, "sinf(src0)")
> -unop("fcos", tfloat, "cosf(src0)")
> +unop("fsin", tfloat, "bit_size == 64 ? sin(src0) : sinf(src0)")
> +unop("fcos", tfloat, "bit_size == 64 ? cos(src0) : cosf(src0)")
>
>
> # Partial derivatives.
>
>
> -unop("fddx", tfloat, "0.0f") # the derivative of a constant is 0.
> -unop("fddy", tfloat, "0.0f")
> -unop("fddx_fine", tfloat, "0.0f")
> -unop("fddy_fine", tfloat, "0.0f")
> -unop("fddx_coarse", tfloat, "0.0f")
> -unop("fddy_coarse", tfloat, "0.0f")
> +unop("fddx", tfloat, "0.0") # the derivative of a constant is 0.
> +unop("fddy", tfloat, "0.0")
> +unop("fddx_fine", tfloat, "0.0")
> +unop("fddy_fine", tfloat, "0.0")
> +unop("fddx_coarse", tfloat, "0.0")
> +unop("fddy_coarse", tfloat, "0.0")
>
>
> # Floating point pack and unpack operations.
>
> def pack_2x16(fmt):
> - unop_horiz("pack_" + fmt + "_2x16", 1, tuint, 2, tfloat, """
> + unop_horiz("pack_" + fmt + "_2x16", 1, tuint32, 2, tfloat32, """
> dst.x = (uint32_t) pack_fmt_1x16(src0.x);
> dst.x |= ((uint32_t) pack_fmt_1x16(src0.y)) << 16;
> """.replace("fmt", fmt))
>
> def pack_4x8(fmt):
> - unop_horiz("pack_" + fmt + "_4x8", 1, tuint, 4, tfloat, """
> + unop_horiz("pack_" + fmt + "_4x8", 1, tuint32, 4, tfloat32, """
> dst.x = (uint32_t) pack_fmt_1x8(src0.x);
> dst.x |= ((uint32_t) pack_fmt_1x8(src0.y)) << 8;
> dst.x |= ((uint32_t) pack_fmt_1x8(src0.z)) << 16;
> @@ -212,13 +216,13 @@ dst.x |= ((uint32_t) pack_fmt_1x8(src0.w)) << 24;
> """.replace("fmt", fmt))
>
> def unpack_2x16(fmt):
> - unop_horiz("unpack_" + fmt + "_2x16", 2, tfloat, 1, tuint, """
> + unop_horiz("unpack_" + fmt + "_2x16", 2, tfloat32, 1, tuint32, """
> dst.x = unpack_fmt_1x16((uint16_t)(src0.x & 0xffff));
> dst.y = unpack_fmt_1x16((uint16_t)(src0.x << 16));
> """.replace("fmt", fmt))
>
> def unpack_4x8(fmt):
> - unop_horiz("unpack_" + fmt + "_4x8", 4, tfloat, 1, tuint, """
> + unop_horiz("unpack_" + fmt + "_4x8", 4, tfloat32, 1, tuint32, """
> dst.x = unpack_fmt_1x8((uint8_t)(src0.x & 0xff));
> dst.y = unpack_fmt_1x8((uint8_t)((src0.x >> 8) & 0xff));
> dst.z = unpack_fmt_1x8((uint8_t)((src0.x >> 16) & 0xff));
> @@ -237,11 +241,11 @@ unpack_2x16("unorm")
> unpack_4x8("unorm")
> unpack_2x16("half")
>
> -unop_horiz("pack_uvec2_to_uint", 1, tuint, 2, tuint, """
> +unop_horiz("pack_uvec2_to_uint", 1, tuint32, 2, tuint32, """
> dst.x = (src0.x & 0xffff) | (src0.y >> 16);
> """)
>
> -unop_horiz("pack_uvec4_to_uint", 1, tuint, 4, tuint, """
> +unop_horiz("pack_uvec4_to_uint", 1, tuint32, 4, tuint32, """
> dst.x = (src0.x << 0) |
> (src0.y << 8) |
> (src0.z << 16) |
> @@ -251,22 +255,22 @@ dst.x = (src0.x << 0) |
> # Lowered floating point unpacking operations.
>
>
> -unop_horiz("unpack_half_2x16_split_x", 1, tfloat, 1, tuint,
> +unop_horiz("unpack_half_2x16_split_x", 1, tfloat32, 1, tuint32,
> "unpack_half_1x16((uint16_t)(src0.x & 0xffff))")
> -unop_horiz("unpack_half_2x16_split_y", 1, tfloat, 1, tuint,
> +unop_horiz("unpack_half_2x16_split_y", 1, tfloat32, 1, tuint32,
> "unpack_half_1x16((uint16_t)(src0.x >> 16))")
>
>
> # Bit operations, part of ARB_gpu_shader5.
>
>
> -unop("bitfield_reverse", tuint, """
> +unop("bitfield_reverse", tuint32, """
> /* we're not winning any awards for speed here, but that's ok */
> dst = 0;
> for (unsigned bit = 0; bit < 32; bit++)
> dst |= ((src0 >> bit) & 1) << (31 - bit);
> """)
> -unop("bit_count", tuint, """
> +unop("bit_count", tuint32, """
> dst = 0;
> for (unsigned bit = 0; bit < 32; bit++) {
> if ((src0 >> bit) & 1)
> @@ -274,7 +278,7 @@ for (unsigned bit = 0; bit < 32; bit++) {
> }
> """)
>
> -unop_convert("ufind_msb", tint, tuint, """
> +unop_convert("ufind_msb", tint32, tuint32, """
> dst = -1;
> for (int bit = 31; bit > 0; bit--) {
> if ((src0 >> bit) & 1) {
> @@ -284,7 +288,7 @@ for (int bit = 31; bit > 0; bit--) {
> }
> """)
>
> -unop("ifind_msb", tint, """
> +unop("ifind_msb", tint32, """
> dst = -1;
> for (int bit = 31; bit >= 0; bit--) {
> /* If src0 < 0, we're looking for the first 0 bit.
> @@ -298,7 +302,7 @@ for (int bit = 31; bit >= 0; bit--) {
> }
> """)
>
> -unop("find_lsb", tint, """
> +unop("find_lsb", tint32, """
> dst = -1;
> for (unsigned bit = 0; bit < 32; bit++) {
> if ((src0 >> bit) & 1) {
> @@ -358,10 +362,10 @@ binop("fmul", tfloat, commutative + associative,
> "src0 * src1")
> # low 32-bits of signed/unsigned integer multiply
> binop("imul", tint, commutative + associative, "src0 * src1")
> # high 32-bits of signed integer multiply
> -binop("imul_high", tint, commutative,
> +binop("imul_high", tint32, commutative,
> "(int32_t)(((int64_t) src0 * (int64_t) src1) >> 32)")
> # high 32-bits of unsigned integer multiply
> -binop("umul_high", tuint, commutative,
> +binop("umul_high", tuint32, commutative,
> "(uint32_t)(((uint64_t) src0 * (uint64_t) src1) >> 32)")
>
> binop("fdiv", tfloat, "", "src0 / src1")
> @@ -412,18 +416,18 @@ binop_reduce("bany_inequal", 1, tbool, tint, "{src0}
> != {src1}",
>
> # non-integer-aware GLSL-style comparisons that return 0.0 or 1.0
>
> -binop_reduce("fall_equal", 1, tfloat, tfloat, "{src0} == {src1}",
> +binop_reduce("fall_equal", 1, tfloat32, tfloat32, "{src0} == {src1}",
> "{src0} && {src1}", "{src} ? 1.0f : 0.0f")
> -binop_reduce("fany_nequal", 1, tfloat, tfloat, "{src0} != {src1}",
> +binop_reduce("fany_nequal", 1, tfloat32, tfloat32, "{src0} != {src1}",
> "{src0} || {src1}", "{src} ? 1.0f : 0.0f")
>
> # These comparisons for integer-less hardware return 1.0 and 0.0 for true
> # and false respectively
>
> -binop("slt", tfloat, "", "(src0 < src1) ? 1.0f : 0.0f") # Set on Less Than
> -binop("sge", tfloat, "", "(src0 >= src1) ? 1.0f : 0.0f") # Set on Greater
> or Equal
> -binop("seq", tfloat, commutative, "(src0 == src1) ? 1.0f : 0.0f") # Set
> on Equal
> -binop("sne", tfloat, commutative, "(src0 != src1) ? 1.0f : 0.0f") # Set
> on Not Equal
> +binop("slt", tfloat32, "", "(src0 < src1) ? 1.0f : 0.0f") # Set on Less
> Than
> +binop("sge", tfloat32, "", "(src0 >= src1) ? 1.0f : 0.0f") # Set on
> Greater or Equal
> +binop("seq", tfloat32, commutative, "(src0 == src1) ? 1.0f : 0.0f") # Set
> on Equal
> +binop("sne", tfloat32, commutative, "(src0 != src1) ? 1.0f : 0.0f") # Set
> on Not Equal
>
>
> binop("ishl", tint, "", "src0 << src1")
> @@ -446,11 +450,11 @@ binop("ixor", tuint, commutative + associative,
> "src0 ^ src1")
> # These use (src != 0.0) for testing the truth of the input, and output
> 1.0
> # for true and 0.0 for false
>
> -binop("fand", tfloat, commutative,
> +binop("fand", tfloat32, commutative,
> "((src0 != 0.0f) && (src1 != 0.0f)) ? 1.0f : 0.0f")
> -binop("for", tfloat, commutative,
> +binop("for", tfloat32, commutative,
> "((src0 != 0.0f) || (src1 != 0.0f)) ? 1.0f : 0.0f")
> -binop("fxor", tfloat, commutative,
> +binop("fxor", tfloat32, commutative,
> "(src0 != 0.0f && src1 == 0.0f) || (src0 == 0.0f && src1 != 0.0f) ?
> 1.0f : 0.0f")
>
> binop_reduce("fdot", 1, tfloat, tfloat, "{src0} * {src1}", "{src0} +
> {src1}",
> @@ -472,7 +476,7 @@ binop("imax", tint, commutative + associative, "src1 >
> src0 ? src1 : src0")
> binop("umax", tuint, commutative + associative, "src1 > src0 ? src1 :
> src0")
>
> # Saturated vector add for 4 8bit ints.
> -binop("usadd_4x8", tint, commutative + associative, """
> +binop("usadd_4x8", tint32, commutative + associative, """
> dst = 0;
> for (int i = 0; i < 32; i += 8) {
> dst |= MIN2(((src0 >> i) & 0xff) + ((src1 >> i) & 0xff), 0xff) << i;
> @@ -480,7 +484,7 @@ for (int i = 0; i < 32; i += 8) {
> """)
>
> # Saturated vector subtract for 4 8bit ints.
> -binop("ussub_4x8", tint, "", """
> +binop("ussub_4x8", tint32, "", """
> dst = 0;
> for (int i = 0; i < 32; i += 8) {
> int src0_chan = (src0 >> i) & 0xff;
> @@ -491,7 +495,7 @@ for (int i = 0; i < 32; i += 8) {
> """)
>
> # vector min for 4 8bit ints.
> -binop("umin_4x8", tint, commutative + associative, """
> +binop("umin_4x8", tint32, commutative + associative, """
> dst = 0;
> for (int i = 0; i < 32; i += 8) {
> dst |= MIN2((src0 >> i) & 0xff, (src1 >> i) & 0xff) << i;
> @@ -499,7 +503,7 @@ for (int i = 0; i < 32; i += 8) {
> """)
>
> # vector max for 4 8bit ints.
> -binop("umax_4x8", tint, commutative + associative, """
> +binop("umax_4x8", tint32, commutative + associative, """
> dst = 0;
> for (int i = 0; i < 32; i += 8) {
> dst |= MAX2((src0 >> i) & 0xff, (src1 >> i) & 0xff) << i;
> @@ -507,7 +511,7 @@ for (int i = 0; i < 32; i += 8) {
> """)
>
> # unorm multiply: (a * b) / 255.
> -binop("umul_unorm_4x8", tint, commutative + associative, """
> +binop("umul_unorm_4x8", tint32, commutative + associative, """
> dst = 0;
> for (int i = 0; i < 32; i += 8) {
> int src0_chan = (src0 >> i) & 0xff;
> @@ -516,15 +520,15 @@ for (int i = 0; i < 32; i += 8) {
> }
> """)
>
> -binop("fpow", tfloat, "", "powf(src0, src1)")
> +binop("fpow", tfloat, "", "bit_size == 64 ? powf(src0, src1) : pow(src0,
> src1)")
>
> -binop_horiz("pack_half_2x16_split", 1, tuint, 1, tfloat, 1, tfloat,
> +binop_horiz("pack_half_2x16_split", 1, tuint32, 1, tfloat32, 1, tfloat32,
> "pack_half_1x16(src0.x) | (pack_half_1x16(src1.x) << 16)")
>
> # bfm implements the behavior of the first operation of the SM5 "bfi"
> assembly
> # and that of the "bfi1" i965 instruction. That is, it has undefined
> behavior
> # if either of its arguments are 32.
> -binop_convert("bfm", tuint, tint, "", """
> +binop_convert("bfm", tuint32, tint32, "", """
> int bits = src0, offset = src1;
> if (offset < 0 || bits < 0 || offset > 31 || bits > 31 || offset + bits >
> 32)
> dst = 0; /* undefined */
> @@ -532,8 +536,8 @@ else
> dst = ((1u << bits) - 1) << offset;
> """)
>
> -opcode("ldexp", 0, tfloat, [0, 0], [tfloat, tint], "", """
> -dst = ldexpf(src0, src1);
> +opcode("ldexp", 0, tfloat32, [0, 0], [tfloat32, tint32], "", """
> +dst = ldexp(src0, src1);
>
For some things like ldexp, they could easily have a double variant.
However, for the moment, it's probably best to lock them to 32-bit until we
have a need for it.
> /* flush denormals to zero. */
> if (!isnormal(dst))
> dst = copysignf(0.0f, src0);
> @@ -573,12 +577,12 @@ triop("flrp", tfloat, "src0 * (1 - src2) + src1 *
> src2")
> # bools (0.0 vs 1.0) and one for integer bools (0 vs ~0).
>
>
> -triop("fcsel", tfloat, "(src0 != 0.0f) ? src1 : src2")
> -opcode("bcsel", 0, tuint, [0, 0, 0],
> - [tbool, tuint, tuint], "", "src0 ? src1 : src2")
> +triop("fcsel", tfloat32, "(src0 != 0.0f) ? src1 : src2")
> +opcode("bcsel", 0, tfloat, [0, 0, 0],
> + [tbool, tfloat, tfloat], "", "src0 ? src1 : src2")
>
I don't think you intended to change bcsel to work in terms of floats. If
we do want that change, it should be a separate change with good
justification.
>
> # SM5 bfi assembly
> -triop("bfi", tuint, """
> +triop("bfi", tuint32, """
> unsigned mask = src0, insert = src1, base = src2;
> if (mask == 0) {
> dst = base;
> @@ -593,8 +597,8 @@ if (mask == 0) {
> """)
>
> # SM5 ubfe/ibfe assembly
> -opcode("ubfe", 0, tuint,
> - [0, 0, 0], [tuint, tint, tint], "", """
> +opcode("ubfe", 0, tuint32,
> + [0, 0, 0], [tuint32, tint32, tint32], "", """
> unsigned base = src0;
> int offset = src1, bits = src2;
> if (bits == 0) {
> @@ -607,8 +611,8 @@ if (bits == 0) {
> dst = base >> offset;
> }
> """)
> -opcode("ibfe", 0, tint,
> - [0, 0, 0], [tint, tint, tint], "", """
> +opcode("ibfe", 0, tint32,
> + [0, 0, 0], [tint32, tint32, tint32], "", """
> int base = src0;
> int offset = src1, bits = src2;
> if (bits == 0) {
> @@ -623,8 +627,8 @@ if (bits == 0) {
> """)
>
> # GLSL bitfieldExtract()
> -opcode("ubitfield_extract", 0, tuint,
> - [0, 0, 0], [tuint, tint, tint], "", """
> +opcode("ubitfield_extract", 0, tuint32,
> + [0, 0, 0], [tuint32, tint32, tint32], "", """
> unsigned base = src0;
> int offset = src1, bits = src2;
> if (bits == 0) {
> @@ -635,8 +639,8 @@ if (bits == 0) {
> dst = (base >> offset) & ((1ull << bits) - 1);
> }
> """)
> -opcode("ibitfield_extract", 0, tint,
> - [0, 0, 0], [tint, tint, tint], "", """
> +opcode("ibitfield_extract", 0, tint32,
> + [0, 0, 0], [tint32, tint32, tint32], "", """
> int base = src0;
> int offset = src1, bits = src2;
> if (bits == 0) {
> @@ -663,8 +667,8 @@ def quadop_horiz(name, output_size, src1_size,
> src2_size, src3_size,
> [tuint, tuint, tuint, tuint],
> "", const_expr)
>
> -opcode("bitfield_insert", 0, tuint, [0, 0, 0, 0],
> - [tuint, tuint, tint, tint], "", """
> +opcode("bitfield_insert", 0, tuint32, [0, 0, 0, 0],
> + [tuint32, tuint32, tint32, tint32], "", """
> unsigned base = src0, insert = src1;
> int offset = src2, bits = src3;
> if (bits == 0) {
> --
> 2.7.0
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
>
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
