From: Elie Tournier <tournier.e...@gmail.com>
Signed-off-by: Elie Tournier <elie.tourn...@collabora.com>
---
src/compiler/glsl/builtin_float64.h | 209 ++++++++++++++++++++++++++++++++
src/compiler/glsl/builtin_functions.cpp | 4 +
src/compiler/glsl/builtin_functions.h | 3 +
src/compiler/glsl/float64.glsl | 61 ++++++++++
src/compiler/glsl/glcpp/glcpp-parse.y | 1 +
5 files changed, 278 insertions(+)
diff --git a/src/compiler/glsl/builtin_float64.h
b/src/compiler/glsl/builtin_float64.h
index ca56d3b..2dcaba40 100644
--- a/src/compiler/glsl/builtin_float64.h
+++ b/src/compiler/glsl/builtin_float64.h
@@ -5074,3 +5074,212 @@ fmul64(void *mem_ctx, builtin_available_predicate avail)
sig->replace_parameters(&sig_parameters);
return sig;
}
+ir_function_signature *
+shift64Right(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::void_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r0818 = new(mem_ctx) ir_variable(glsl_type::uint_type,
"a0", ir_var_function_in);
+ sig_parameters.push_tail(r0818);
+ ir_variable *const r0819 = new(mem_ctx) ir_variable(glsl_type::uint_type,
"a1", ir_var_function_in);
+ sig_parameters.push_tail(r0819);
+ ir_variable *const r081A = new(mem_ctx) ir_variable(glsl_type::int_type,
"count", ir_var_function_in);
+ sig_parameters.push_tail(r081A);
+ ir_variable *const r081B = new(mem_ctx) ir_variable(glsl_type::uint_type,
"z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r081B);
+ ir_variable *const r081C = new(mem_ctx) ir_variable(glsl_type::uint_type,
"z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r081C);
+ ir_expression *const r081D = equal(r081A, body.constant(int(0)));
+ ir_expression *const r081E = less(r081A, body.constant(int(32)));
+ ir_expression *const r081F = neg(r081A);
+ ir_expression *const r0820 = bit_and(r081F, body.constant(int(31)));
+ ir_expression *const r0821 = lshift(r0818, r0820);
+ ir_expression *const r0822 = rshift(r0819, r081A);
+ ir_expression *const r0823 = bit_or(r0821, r0822);
+ ir_expression *const r0824 = less(r081A, body.constant(int(64)));
+ ir_expression *const r0825 = bit_and(r081A, body.constant(int(31)));
+ ir_expression *const r0826 = rshift(r0818, r0825);
+ ir_expression *const r0827 = expr(ir_triop_csel, r0824, r0826,
body.constant(0u));
+ ir_expression *const r0828 = expr(ir_triop_csel, r081E, r0823, r0827);
+ body.emit(assign(r081C, expr(ir_triop_csel, r081D, r0818, r0828), 0x01));
+
+ ir_expression *const r0829 = equal(r081A, body.constant(int(0)));
+ ir_expression *const r082A = less(r081A, body.constant(int(32)));
+ ir_expression *const r082B = rshift(r0818, r081A);
+ ir_expression *const r082C = expr(ir_triop_csel, r082A, r082B,
body.constant(0u));
+ body.emit(assign(r081B, expr(ir_triop_csel, r0829, r0818, r082C), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+fp64_to_uint(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uint_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r082D = new(mem_ctx) ir_variable(glsl_type::uvec2_type,
"a", ir_var_function_in);
+ sig_parameters.push_tail(r082D);
+ ir_variable *const r082E = body.make_temp(glsl_type::uint_type,
"return_value");
+ ir_variable *const r082F = new(mem_ctx) ir_variable(glsl_type::uint_type,
"aFracHi", ir_var_auto);
+ body.emit(r082F);
+ ir_variable *const r0830 = new(mem_ctx) ir_variable(glsl_type::uint_type,
"aFracLo", ir_var_auto);
+ body.emit(r0830);
+ body.emit(assign(r0830, swizzle_x(r082D), 0x01));
+
+ ir_variable *const r0831 = body.make_temp(glsl_type::uint_type,
"extractFloat64FracHi_retval");
+ body.emit(assign(r0831, bit_and(swizzle_y(r082D), body.constant(1048575u)),
0x01));
+
+ body.emit(assign(r082F, r0831, 0x01));
+
+ ir_variable *const r0832 = body.make_temp(glsl_type::int_type,
"extractFloat64Exp_retval");
+ ir_expression *const r0833 = rshift(swizzle_y(r082D),
body.constant(int(20)));
+ ir_expression *const r0834 = bit_and(r0833, body.constant(2047u));
+ body.emit(assign(r0832, expr(ir_unop_u2i, r0834), 0x01));
+
+ ir_variable *const r0835 = body.make_temp(glsl_type::uint_type,
"extractFloat64Sign_retval");
+ body.emit(assign(r0835, rshift(swizzle_y(r082D), body.constant(int(31))),
0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0837 = equal(r0832, body.constant(int(2047)));
+ ir_expression *const r0838 = bit_or(r0831, swizzle_x(r082D));
+ ir_expression *const r0839 = nequal(r0838, body.constant(0u));
+ ir_expression *const r083A = logic_and(r0837, r0839);
+ ir_if *f0836 = new(mem_ctx) ir_if(operand(r083A).val);
+ exec_list *const f0836_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0836->then_instructions;
+
+ body.emit(assign(r082E, body.constant(4294967295u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0836->else_instructions;
+
+ ir_expression *const r083B = nequal(r0832, body.constant(int(0)));
+ ir_expression *const r083C = expr(ir_triop_csel, r083B,
body.constant(1048576u), body.constant(0u));
+ body.emit(assign(r082F, bit_or(r0831, r083C), 0x01));
+
+ ir_variable *const r083D = body.make_temp(glsl_type::int_type,
"assignment_tmp");
+ body.emit(assign(r083D, sub(body.constant(int(1063)), r0832), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r083F = less(body.constant(int(0)), r083D);
+ ir_if *f083E = new(mem_ctx) ir_if(operand(r083F).val);
+ exec_list *const f083E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f083E->then_instructions;
+
+ ir_variable *const r0840 = new(mem_ctx)
ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0840);
+ ir_variable *const r0841 = body.make_temp(glsl_type::int_type,
"assignment_tmp");
+ ir_expression *const r0842 = neg(r083D);
+ body.emit(assign(r0841, bit_and(r0842, body.constant(int(31))),
0x01));
+
+ ir_expression *const r0843 = bit_or(r082F, swizzle_x(r082D));
+ ir_expression *const r0844 = nequal(r0843, body.constant(0u));
+ ir_expression *const r0845 = expr(ir_unop_b2i, r0844);
+ body.emit(assign(r0840, expr(ir_unop_i2u, r0845), 0x01));
+
+ ir_variable *const r0846 = body.make_temp(glsl_type::uint_type,
"mix_retval");
+ ir_expression *const r0847 = equal(r083D, body.constant(int(0)));
+ ir_expression *const r0848 = less(r083D, body.constant(int(32)));
+ ir_expression *const r0849 = lshift(r082F, r0841);
+ ir_expression *const r084A = rshift(swizzle_x(r082D), r083D);
+ ir_expression *const r084B = bit_or(r0849, r084A);
+ ir_expression *const r084C = lshift(swizzle_x(r082D), r0841);
+ ir_expression *const r084D = nequal(r084C, body.constant(0u));
+ ir_expression *const r084E = expr(ir_unop_b2i, r084D);
+ ir_expression *const r084F = expr(ir_unop_i2u, r084E);
+ ir_expression *const r0850 = bit_or(r084B, r084F);
+ ir_expression *const r0851 = equal(r083D, body.constant(int(32)));
+ ir_expression *const r0852 = nequal(swizzle_x(r082D),
body.constant(0u));
+ ir_expression *const r0853 = expr(ir_unop_b2i, r0852);
+ ir_expression *const r0854 = expr(ir_unop_i2u, r0853);
+ ir_expression *const r0855 = bit_or(r082F, r0854);
+ ir_expression *const r0856 = less(r083D, body.constant(int(64)));
+ ir_expression *const r0857 = bit_and(r083D, body.constant(int(31)));
+ ir_expression *const r0858 = rshift(r082F, r0857);
+ ir_expression *const r0859 = lshift(r082F, r0841);
+ ir_expression *const r085A = bit_or(r0859, swizzle_x(r082D));
+ ir_expression *const r085B = nequal(r085A, body.constant(0u));
+ ir_expression *const r085C = expr(ir_unop_b2i, r085B);
+ ir_expression *const r085D = expr(ir_unop_i2u, r085C);
+ ir_expression *const r085E = bit_or(r0858, r085D);
+ ir_expression *const r085F = expr(ir_triop_csel, r0856, r085E, r0840);
+ ir_expression *const r0860 = expr(ir_triop_csel, r0851, r0855, r085F);
+ ir_expression *const r0861 = expr(ir_triop_csel, r0848, r0850, r0860);
+ body.emit(assign(r0846, expr(ir_triop_csel, r0847, swizzle_x(r082D),
r0861), 0x01));
+
+ body.emit(assign(r0840, r0846, 0x01));
+
+ ir_expression *const r0862 = less(r083D, body.constant(int(32)));
+ ir_expression *const r0863 = rshift(r082F, r083D);
+ ir_expression *const r0864 = equal(r083D, body.constant(int(0)));
+ ir_expression *const r0865 = expr(ir_triop_csel, r0864, r082F,
body.constant(0u));
+ body.emit(assign(r082F, expr(ir_triop_csel, r0862, r0863, r0865),
0x01));
+
+ body.emit(assign(r0830, r0846, 0x01));
+
+
+ body.instructions = f083E_parent_instructions;
+ body.emit(f083E);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0867 = bit_and(r082F, body.constant(4294963200u));
+ ir_expression *const r0868 = nequal(r0867, body.constant(0u));
+ ir_if *f0866 = new(mem_ctx) ir_if(operand(r0868).val);
+ exec_list *const f0866_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0866->then_instructions;
+
+ ir_expression *const r0869 = nequal(r0835, body.constant(0u));
+ body.emit(assign(r082E, expr(ir_triop_csel, r0869, body.constant(0u),
body.constant(4294967295u)), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0866->else_instructions;
+
+ ir_variable *const r086A = body.make_temp(glsl_type::uint_type,
"z1Ptr");
+ ir_expression *const r086B = lshift(r082F, body.constant(int(20)));
+ ir_expression *const r086C = rshift(r0830, body.constant(int(12)));
+ body.emit(assign(r086A, bit_or(r086B, r086C), 0x01));
+
+ ir_expression *const r086D = nequal(r0835, body.constant(0u));
+ ir_expression *const r086E = nequal(r086A, body.constant(0u));
+ ir_expression *const r086F = logic_and(r086D, r086E);
+ ir_expression *const r0870 = nequal(r0835, body.constant(0u));
+ ir_expression *const r0871 = expr(ir_triop_csel, r0870,
body.constant(0u), body.constant(4294967295u));
+ body.emit(assign(r082E, expr(ir_triop_csel, r086F, r0871, r086A),
0x01));
+
+
+ body.instructions = f0866_parent_instructions;
+ body.emit(f0866);
+
+ /* END IF */
+
+
+ body.instructions = f0836_parent_instructions;
+ body.emit(f0836);
+
+ /* END IF */
+
+ body.emit(ret(r082E));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
diff --git a/src/compiler/glsl/builtin_functions.cpp
b/src/compiler/glsl/builtin_functions.cpp
index f72c77f..a0fc9bc 100644
--- a/src/compiler/glsl/builtin_functions.cpp
+++ b/src/compiler/glsl/builtin_functions.cpp
@@ -3370,6 +3370,10 @@ builtin_builder::create_builtins()
generate_ir::fmul64(mem_ctx, integer_functions_supported),
NULL);
+ add_function("__builtin_fp64_to_uint",
+ generate_ir::fp64_to_uint(mem_ctx,
integer_functions_supported),
+ NULL);
+
#undef F
#undef FI
#undef FIUD_VEC
diff --git a/src/compiler/glsl/builtin_functions.h
b/src/compiler/glsl/builtin_functions.h
index 6f0e8e5..f99e3b7 100644
--- a/src/compiler/glsl/builtin_functions.h
+++ b/src/compiler/glsl/builtin_functions.h
@@ -88,6 +88,9 @@ fadd64(void *mem_ctx, builtin_available_predicate avail);
ir_function_signature *
fmul64(void *mem_ctx, builtin_available_predicate avail);
+ir_function_signature *
+fp64_to_uint(void *mem_ctx, builtin_available_predicate avail);
+
}
#endif /* BULITIN_FUNCTIONS_H */
diff --git a/src/compiler/glsl/float64.glsl b/src/compiler/glsl/float64.glsl
index bd089f8..a738b60 100644
--- a/src/compiler/glsl/float64.glsl
+++ b/src/compiler/glsl/float64.glsl
@@ -729,3 +729,64 @@ fmul64(uvec2 a, uvec2 b)
}
return roundAndPackFloat64(zSign, zExp, zFrac0, zFrac1, zFrac2);
}
+
+/* Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
+ * number of bits given in `count'. Any bits shifted off are lost. The value
+ * of `count' can be arbitrarily large; in particular, if `count' is greater
+ * than 64, the result will be 0. The result is broken into two 32-bit pieces
+ * which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
+ */
+void
+shift64Right(uint a0, uint a1,
+ int count,
+ inout uint z0Ptr,
+ inout uint z1Ptr)
+{
+ uint z0;
+ uint z1;
+ int negCount = (-count) & 31;
+
+ z0 = 0u;
+ z0 = mix(z0, (a0 >> count), count < 32);
+ z0 = mix(z0, a0, count == 0);
+
+ z1 = mix(0u, (a0 >> (count & 31)), count < 64);
+ z1 = mix(z1, (a0<<negCount) | (a1>>count), count < 32);
+ z1 = mix(z1, a0, count == 0);
+
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Returns the result of converting the double-precision floating-point value
+ * `a' to the unsigned integer format. The conversion is performed according
+ * to the IEEE Standard for Floating-Point Arithmetic.
+ */
+uint
+fp64_to_uint(uvec2 a)
+{
+ uint aFracLo = extractFloat64FracLo(a);
+ uint aFracHi = extractFloat64FracHi(a);
+ int aExp = extractFloat64Exp(a);
+ uint aSign = extractFloat64Sign(a);
+
+ if ((aExp == 0x7FF) && ((aFracHi | aFracLo) != 0u))
+ return 0xFFFFFFFFu;
+
+ aFracHi |= mix(0u, 0x00100000u, aExp != 0);
+
+ int shiftDist = 0x427 - aExp;
+ if (0 < shiftDist)
+ shift64RightJamming(aFracHi, aFracLo, shiftDist, aFracHi, aFracLo);
+
+ if ((aFracHi & 0xFFFFF000u) != 0u)
+ return mix(~0u, 0u, (aSign != 0u));
+
+ uint z = 0u;
+ uint zero = 0u;
+ shift64Right(aFracHi, aFracLo, 12, zero, z);
+
+ uint expt = mix(~0u, 0u, (aSign != 0u));
+
+ return mix(z, expt, (aSign != 0u) && (z != 0u));
+}
diff --git a/src/compiler/glsl/glcpp/glcpp-parse.y
b/src/compiler/glsl/glcpp/glcpp-parse.y
index 21e90ba..37ab758 100644
--- a/src/compiler/glsl/glcpp/glcpp-parse.y
+++ b/src/compiler/glsl/glcpp/glcpp-parse.y
@@ -2375,6 +2375,7 @@ _glcpp_parser_handle_version_declaration(glcpp_parser_t
*parser, intmax_t versio
add_builtin_define(parser, "__have_builtin_builtin_flt64", 1);
add_builtin_define(parser, "__have_builtin_builtin_fadd64", 1);
add_builtin_define(parser, "__have_builtin_builtin_fmul64", 1);
+ add_builtin_define(parser, "__have_builtin_builtin_fp64_to_uint", 1);
}
}
--
2.9.5
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
