ir_expression_operation = [
operation("bit_not", 1, printable_name="~", source_types=integer_types, c_expression="~ {src0}"),
operation("logic_not", 1, printable_name="!", source_types=(bool_type,), c_expression="!{src0}"),
- operation("neg", 1, source_types=numeric_types, c_expression={'u': "-((int) {src0})", 'default': "-{src0}"}),
+ operation("neg", 1, source_types=numeric_types, c_expression={'u': "-((int) {src0})", 'u64': "-((int64_t) {src0})", 'default': "-{src0}"}),
operation("abs", 1, source_types=signed_numeric_types, c_expression={'i': "{src0} < 0 ? -{src0} : {src0}", 'f': "fabsf({src0})", 'd': "fabs({src0})", 'i64': "{src0} < 0 ? -{src0} : {src0}"}),
operation("sign", 1, source_types=signed_numeric_types, c_expression={'i': "({src0} > 0) - ({src0} < 0)", 'f': "float(({src0} > 0.0F) - ({src0} < 0.0F))", 'd': "double(({src0} > 0.0) - ({src0} < 0.0))", 'i64': "({src0} > 0) - ({src0} < 0)"}),
operation("rcp", 1, source_types=real_types, c_expression={'f': "1.0F / {src0}", 'd': "1.0 / {src0}"}),
operation("f2b", 1, source_types=(float_type,), dest_type=bool_type, c_expression="{src0} != 0.0F ? true : false"),
# Boolean-to-float conversion
operation("b2f", 1, source_types=(bool_type,), dest_type=float_type, c_expression="{src0} ? 1.0F : 0.0F"),
+ # Boolean-to-float16 conversion
+ operation("b2f16", 1, source_types=(bool_type,), dest_type=float_type, c_expression="{src0} ? 1.0F : 0.0F"),
# int-to-boolean conversion
operation("i2b", 1, source_types=(uint_type, int_type), dest_type=bool_type, c_expression="{src0} ? true : false"),
# Boolean-to-int conversion
operation("d2f", 1, source_types=(double_type,), dest_type=float_type, c_expression="{src0}"),
# Float-to-double conversion.
operation("f2d", 1, source_types=(float_type,), dest_type=double_type, c_expression="{src0}"),
+ # Half-float conversions. These all operate on and return float types,
+ # since the framework expands half to full float before calling in. We
+ # still have to handle them here so that we can constant propagate through
+ # them, but they are no-ops.
+ operation("f2f16", 1, source_types=(float_type,), dest_type=float_type, c_expression="{src0}"),
+ operation("f2fmp", 1, source_types=(float_type,), dest_type=float_type, c_expression="{src0}"),
+ operation("f162f", 1, source_types=(float_type,), dest_type=float_type, c_expression="{src0}"),
+ # int16<->int32 conversion.
+ operation("i2i", 1, source_types=(int_type,), dest_type=int_type, c_expression="{src0}"),
+ operation("i2imp", 1, source_types=(int_type,), dest_type=int_type, c_expression="{src0}"),
+ operation("u2u", 1, source_types=(uint_type,), dest_type=uint_type, c_expression="{src0}"),
+ operation("u2ump", 1, source_types=(uint_type,), dest_type=uint_type, c_expression="{src0}"),
# Double-to-integer conversion.
operation("d2i", 1, source_types=(double_type,), dest_type=int_type, c_expression="{src0}"),
# Integer-to-double conversion.
operation("u2d", 1, source_types=(uint_type,), dest_type=double_type, c_expression="{src0}"),
# Double-to-boolean conversion.
operation("d2b", 1, source_types=(double_type,), dest_type=bool_type, c_expression="{src0} != 0.0"),
+ # Float16-to-boolean conversion.
+ operation("f162b", 1, source_types=(float_type,), dest_type=bool_type, c_expression="{src0} != 0.0"),
# 'Bit-identical int-to-float "conversion"
operation("bitcast_i2f", 1, source_types=(int_type,), dest_type=float_type, c_expression="bitcast_u2f({src0})"),
# 'Bit-identical float-to-int "conversion"
# Trigonometric operations.
operation("sin", 1, source_types=(float_type,), c_expression="sinf({src0})"),
operation("cos", 1, source_types=(float_type,), c_expression="cosf({src0})"),
+ operation("atan", 1, source_types=(float_type,), c_expression="atan({src0})"),
# Partial derivatives.
operation("dFdx", 1, source_types=(float_type,), c_expression="0.0f"),
# Bit operations, part of ARB_gpu_shader5.
operation("bitfield_reverse", 1, source_types=(uint_type, int_type), c_expression="bitfield_reverse({src0})"),
- operation("bit_count", 1, source_types=(uint_type, int_type), dest_type=int_type, c_expression="_mesa_bitcount({src0})"),
+ operation("bit_count", 1, source_types=(uint_type, int_type), dest_type=int_type, c_expression="util_bitcount({src0})"),
operation("find_msb", 1, source_types=(uint_type, int_type), dest_type=int_type, c_expression={'u': "find_msb_uint({src0})", 'i': "find_msb_int({src0})"}),
operation("find_lsb", 1, source_types=(uint_type, int_type), dest_type=int_type, c_expression="find_msb_uint({src0} & -{src0})"),
+ operation("clz", 1, source_types=(uint_type,), dest_type=uint_type, c_expression="(unsigned)(31 - find_msb_uint({src0}))"),
operation("saturate", 1, printable_name="sat", source_types=(float_type,), c_expression="CLAMP({src0}, 0.0f, 1.0f)"),
operation("frexp_sig", 1),
operation("frexp_exp", 1),
- operation("noise", 1),
-
operation("subroutine_to_int", 1),
# Interpolate fs input at centroid
operation("add", 2, printable_name="+", source_types=numeric_types, c_expression="{src0} + {src1}", flags=vector_scalar_operation),
operation("sub", 2, printable_name="-", source_types=numeric_types, c_expression="{src0} - {src1}", flags=vector_scalar_operation),
+ operation("add_sat", 2, printable_name="add_sat", source_types=integer_types, c_expression={
+ 'u': "({src0} + {src1}) < {src0} ? UINT32_MAX : ({src0} + {src1})",
+ 'i': "iadd_saturate({src0}, {src1})",
+ 'u64': "({src0} + {src1}) < {src0} ? UINT64_MAX : ({src0} + {src1})",
+ 'i64': "iadd64_saturate({src0}, {src1})"
+ }),
+ operation("sub_sat", 2, printable_name="sub_sat", source_types=integer_types, c_expression={
+ 'u': "({src1} > {src0}) ? 0 : {src0} - {src1}",
+ 'i': "isub_saturate({src0}, {src1})",
+ 'u64': "({src1} > {src0}) ? 0 : {src0} - {src1}",
+ 'i64': "isub64_saturate({src0}, {src1})"
+ }),
+ operation("abs_sub", 2, printable_name="abs_sub", source_types=integer_types, c_expression={
+ 'u': "({src1} > {src0}) ? {src1} - {src0} : {src0} - {src1}",
+ 'i': "({src1} > {src0}) ? (unsigned){src1} - (unsigned){src0} : (unsigned){src0} - (unsigned){src1}",
+ 'u64': "({src1} > {src0}) ? {src1} - {src0} : {src0} - {src1}",
+ 'i64': "({src1} > {src0}) ? (uint64_t){src1} - (uint64_t){src0} : (uint64_t){src0} - (uint64_t){src1}",
+ }),
+ operation("avg", 2, printable_name="average", source_types=integer_types, c_expression="({src0} >> 1) + ({src1} >> 1) + (({src0} & {src1}) & 1)"),
+ operation("avg_round", 2, printable_name="average_rounded", source_types=integer_types, c_expression="({src0} >> 1) + ({src1} >> 1) + (({src0} | {src1}) & 1)"),
+
# "Floating-point or low 32-bit integer multiply."
operation("mul", 2, printable_name="*", source_types=numeric_types, c_expression="{src0} * {src1}"),
+ operation("mul_32x16", 2, printable_name="*", source_types=(uint_type, int_type), c_expression={
+ 'u': "{src0} * (uint16_t){src1}",
+ 'i': "{src0} * (int16_t){src0}"
+ }),
operation("imul_high", 2), # Calculates the high 32-bits of a 64-bit multiply.
operation("div", 2, printable_name="/", source_types=numeric_types, c_expression={'u': "{src1} == 0 ? 0 : {src0} / {src1}", 'i': "{src1} == 0 ? 0 : {src0} / {src1}", 'u64': "{src1} == 0 ? 0 : {src0} / {src1}", 'i64': "{src1} == 0 ? 0 : {src0} / {src1}", 'default': "{src0} / {src1}"}, flags=vector_scalar_operation),
# operand1 is the sample ID
operation("interpolate_at_sample", 2),
+ operation("atan2", 2, source_types=(float_type,), c_expression="atan2({src0}, {src1})"),
+
# Fused floating-point multiply-add, part of ARB_gpu_shader5.
operation("fma", 3, source_types=real_types, c_expression="{src0} * {src1} + {src2}"),
projects / mesa.git / blobdiff