* want to recognize add(op0, neg(op1)) or the other way around to
* produce a subtract anyway.
*
- * DIV_TO_MUL_RCP and INT_DIV_TO_MUL_RCP:
- * --------------------------------------
+ * FDIV_TO_MUL_RCP, DDIV_TO_MUL_RCP, and INT_DIV_TO_MUL_RCP:
+ * ---------------------------------------------------------
* Breaks an ir_binop_div expression down to op0 * (rcp(op1)).
*
* Many GPUs don't have a divide instruction (945 and 965 included),
* reciprocal. By breaking the operation down, constant reciprocals
* can get constant folded.
*
- * DIV_TO_MUL_RCP only lowers floating point division; INT_DIV_TO_MUL_RCP
- * handles the integer case, converting to and from floating point so that
- * RCP is possible.
+ * FDIV_TO_MUL_RCP lowers single-precision and half-precision
+ * floating point division;
+ * DDIV_TO_MUL_RCP only lowers double-precision floating point division.
+ * DIV_TO_MUL_RCP is a convenience macro that sets both flags.
+ * INT_DIV_TO_MUL_RCP handles the integer case, converting to and from floating
+ * point so that RCP is possible.
*
* EXP_TO_EXP2 and LOG_TO_LOG2:
* ----------------------------
#include "ir.h"
#include "ir_builder.h"
#include "ir_optimization.h"
+#include "util/half_float.h"
using namespace ir_builder;
void dtrunc_to_dfrac(ir_expression *);
void dsign_to_csel(ir_expression *);
void bit_count_to_math(ir_expression *);
+ void extract_to_shifts(ir_expression *);
+ void insert_to_shifts(ir_expression *);
+ void reverse_to_shifts(ir_expression *ir);
+ void find_lsb_to_float_cast(ir_expression *ir);
+ void find_msb_to_float_cast(ir_expression *ir);
+ void imul_high_to_mul(ir_expression *ir);
+ void sqrt_to_abs_sqrt(ir_expression *ir);
+ void mul64_to_mul_and_mul_high(ir_expression *ir);
+
+ ir_expression *_carry(operand a, operand b);
+
+ static ir_constant *_imm_fp(void *mem_ctx,
+ const glsl_type *type,
+ double f,
+ unsigned vector_elements=1);
};
} /* anonymous namespace */
lower_instructions_visitor::sub_to_add_neg(ir_expression *ir)
{
ir->operation = ir_binop_add;
+ ir->init_num_operands();
ir->operands[1] = new(ir) ir_expression(ir_unop_neg, ir->operands[1]->type,
ir->operands[1], NULL);
this->progress = true;
void
lower_instructions_visitor::div_to_mul_rcp(ir_expression *ir)
{
- assert(ir->operands[1]->type->is_float() || ir->operands[1]->type->is_double());
+ assert(ir->operands[1]->type->is_float_16_32_64());
/* New expression for the 1.0 / op1 */
ir_rvalue *expr;
/* op0 / op1 -> op0 * (1.0 / op1) */
ir->operation = ir_binop_mul;
+ ir->init_num_operands();
ir->operands[1] = expr;
this->progress = true;
void
lower_instructions_visitor::int_div_to_mul_rcp(ir_expression *ir)
{
- assert(ir->operands[1]->type->is_integer());
+ assert(ir->operands[1]->type->is_integer_32());
/* Be careful with integer division -- we need to do it as a
* float and re-truncate, since rcp(n > 1) of an integer would
ir->operation = ir_unop_i2u;
ir->operands[0] = new(ir) ir_expression(ir_unop_f2i, op0);
}
+ ir->init_num_operands();
ir->operands[1] = NULL;
this->progress = true;
void
lower_instructions_visitor::exp_to_exp2(ir_expression *ir)
{
- ir_constant *log2_e = new(ir) ir_constant(float(M_LOG2E));
+ ir_constant *log2_e = _imm_fp(ir, ir->type, M_LOG2E);
ir->operation = ir_unop_exp2;
+ ir->init_num_operands();
ir->operands[0] = new(ir) ir_expression(ir_binop_mul, ir->operands[0]->type,
ir->operands[0], log2_e);
this->progress = true;
ir->operands[0]);
ir->operation = ir_unop_exp2;
+ ir->init_num_operands();
ir->operands[0] = new(ir) ir_expression(ir_binop_mul, ir->operands[1]->type,
ir->operands[1], log2_x);
ir->operands[1] = NULL;
lower_instructions_visitor::log_to_log2(ir_expression *ir)
{
ir->operation = ir_binop_mul;
+ ir->init_num_operands();
ir->operands[0] = new(ir) ir_expression(ir_unop_log2, ir->operands[0]->type,
ir->operands[0], NULL);
- ir->operands[1] = new(ir) ir_constant(float(1.0 / M_LOG2E));
+ ir->operands[1] = _imm_fp(ir, ir->operands[0]->type, 1.0 / M_LOG2E);
this->progress = true;
}
ir_assignment *const assign_x =
new(ir) ir_assignment(new(ir) ir_dereference_variable(x),
- ir->operands[0], NULL);
+ ir->operands[0]);
ir_assignment *const assign_y =
new(ir) ir_assignment(new(ir) ir_dereference_variable(y),
- ir->operands[1], NULL);
+ ir->operands[1]);
this->base_ir->insert_before(assign_x);
this->base_ir->insert_before(assign_y);
/* Don't generate new IR that would need to be lowered in an additional
* pass.
*/
- if (lowering(DIV_TO_MUL_RCP) && (ir->type->is_float() || ir->type->is_double()))
+ if ((lowering(FDIV_TO_MUL_RCP) && ir->type->is_float_16_32()) ||
+ (lowering(DDIV_TO_MUL_RCP) && ir->type->is_double()))
div_to_mul_rcp(div_expr);
ir_expression *const floor_expr =
floor_expr);
ir->operation = ir_binop_sub;
+ ir->init_num_operands();
ir->operands[0] = new(ir) ir_dereference_variable(x);
ir->operands[1] = mul_expr;
this->progress = true;
* into
*
* extracted_biased_exp = rshift(bitcast_f2i(abs(x)), exp_shift);
- * resulting_biased_exp = extracted_biased_exp + exp;
+ * resulting_biased_exp = min(extracted_biased_exp + exp, 255);
*
- * if (resulting_biased_exp < 1 || x == 0.0f) {
- * return copysign(0.0, x);
+ * if (extracted_biased_exp >= 255)
+ * return x; // +/-inf, NaN
+ *
+ * sign_mantissa = bitcast_f2u(x) & sign_mantissa_mask;
+ *
+ * if (min(resulting_biased_exp, extracted_biased_exp) < 1)
+ * resulting_biased_exp = 0;
+ * if (resulting_biased_exp >= 255 ||
+ * min(resulting_biased_exp, extracted_biased_exp) < 1) {
+ * sign_mantissa &= sign_mask;
* }
*
- * return bitcast_u2f((bitcast_f2u(x) & sign_mantissa_mask) |
+ * return bitcast_u2f(sign_mantissa |
* lshift(i2u(resulting_biased_exp), exp_shift));
*
* which we can't actually implement as such, since the GLSL IR doesn't
* using conditional-select:
*
* extracted_biased_exp = rshift(bitcast_f2i(abs(x)), exp_shift);
- * resulting_biased_exp = extracted_biased_exp + exp;
+ * resulting_biased_exp = min(extracted_biased_exp + exp, 255);
*
- * is_not_zero_or_underflow = logic_and(nequal(x, 0.0f),
- * gequal(resulting_biased_exp, 1);
- * x = csel(is_not_zero_or_underflow, x, copysign(0.0f, x));
- * resulting_biased_exp = csel(is_not_zero_or_underflow,
- * resulting_biased_exp, 0);
+ * sign_mantissa = bitcast_f2u(x) & sign_mantissa_mask;
*
- * return bitcast_u2f((bitcast_f2u(x) & sign_mantissa_mask) |
- * lshift(i2u(resulting_biased_exp), exp_shift));
+ * flush_to_zero = lequal(min(resulting_biased_exp, extracted_biased_exp), 0);
+ * resulting_biased_exp = csel(flush_to_zero, 0, resulting_biased_exp)
+ * zero_mantissa = logic_or(flush_to_zero,
+ * gequal(resulting_biased_exp, 255));
+ * sign_mantissa = csel(zero_mantissa, sign_mantissa & sign_mask, sign_mantissa);
+ *
+ * result = sign_mantissa |
+ * lshift(i2u(resulting_biased_exp), exp_shift));
+ *
+ * return csel(extracted_biased_exp >= 255, x, bitcast_u2f(result));
+ *
+ * The definition of ldexp in the GLSL spec says:
+ *
+ * "If this product is too large to be represented in the
+ * floating-point type, the result is undefined."
+ *
+ * However, the definition of ldexp in the GLSL ES spec does not contain
+ * this sentence, so we do need to handle overflow correctly.
+ *
+ * There is additional language limiting the defined range of exp, but this
+ * is merely to allow implementations that store 2^exp in a temporary
+ * variable.
*/
const unsigned vec_elem = ir->type->vector_elements;
/* Types */
const glsl_type *ivec = glsl_type::get_instance(GLSL_TYPE_INT, vec_elem, 1);
+ const glsl_type *uvec = glsl_type::get_instance(GLSL_TYPE_UINT, vec_elem, 1);
const glsl_type *bvec = glsl_type::get_instance(GLSL_TYPE_BOOL, vec_elem, 1);
- /* Constants */
- ir_constant *zeroi = ir_constant::zero(ir, ivec);
-
- ir_constant *sign_mask = new(ir) ir_constant(0x80000000u, vec_elem);
-
- ir_constant *exp_shift = new(ir) ir_constant(23, vec_elem);
- ir_constant *exp_width = new(ir) ir_constant(8, vec_elem);
-
/* Temporary variables */
ir_variable *x = new(ir) ir_variable(ir->type, "x", ir_var_temporary);
ir_variable *exp = new(ir) ir_variable(ivec, "exp", ir_var_temporary);
-
- ir_variable *zero_sign_x = new(ir) ir_variable(ir->type, "zero_sign_x",
- ir_var_temporary);
+ ir_variable *result = new(ir) ir_variable(uvec, "result", ir_var_temporary);
ir_variable *extracted_biased_exp =
new(ir) ir_variable(ivec, "extracted_biased_exp", ir_var_temporary);
ir_variable *resulting_biased_exp =
new(ir) ir_variable(ivec, "resulting_biased_exp", ir_var_temporary);
- ir_variable *is_not_zero_or_underflow =
- new(ir) ir_variable(bvec, "is_not_zero_or_underflow", ir_var_temporary);
+ ir_variable *sign_mantissa =
+ new(ir) ir_variable(uvec, "sign_mantissa", ir_var_temporary);
+
+ ir_variable *flush_to_zero =
+ new(ir) ir_variable(bvec, "flush_to_zero", ir_var_temporary);
+ ir_variable *zero_mantissa =
+ new(ir) ir_variable(bvec, "zero_mantissa", ir_var_temporary);
ir_instruction &i = *base_ir;
/* Extract the biased exponent from <x>. */
i.insert_before(extracted_biased_exp);
i.insert_before(assign(extracted_biased_exp,
- rshift(bitcast_f2i(abs(x)), exp_shift)));
+ rshift(bitcast_f2i(abs(x)),
+ new(ir) ir_constant(23, vec_elem))));
+ /* The definition of ldexp in the GLSL 4.60 spec says:
+ *
+ * "If exp is greater than +128 (single-precision) or +1024
+ * (double-precision), the value returned is undefined. If exp is less
+ * than -126 (single-precision) or -1022 (double-precision), the value
+ * returned may be flushed to zero."
+ *
+ * So we do not have to guard against the possibility of addition overflow,
+ * which could happen when exp is close to INT_MAX. Addition underflow
+ * cannot happen (the worst case is 0 + (-INT_MAX)).
+ */
i.insert_before(resulting_biased_exp);
i.insert_before(assign(resulting_biased_exp,
- add(extracted_biased_exp, exp)));
+ min2(add(extracted_biased_exp, exp),
+ new(ir) ir_constant(255, vec_elem))));
- /* Test if result is ±0.0, subnormal, or underflow by checking if the
- * resulting biased exponent would be less than 0x1. If so, the result is
- * 0.0 with the sign of x. (Actually, invert the conditions so that
- * immediate values are the second arguments, which is better for i965)
- */
- i.insert_before(zero_sign_x);
- i.insert_before(assign(zero_sign_x,
- bitcast_u2f(bit_and(bitcast_f2u(x), sign_mask))));
+ i.insert_before(sign_mantissa);
+ i.insert_before(assign(sign_mantissa,
+ bit_and(bitcast_f2u(x),
+ new(ir) ir_constant(0x807fffffu, vec_elem))));
- i.insert_before(is_not_zero_or_underflow);
- i.insert_before(assign(is_not_zero_or_underflow,
- logic_and(nequal(x, new(ir) ir_constant(0.0f, vec_elem)),
- gequal(resulting_biased_exp,
- new(ir) ir_constant(0x1, vec_elem)))));
- i.insert_before(assign(x, csel(is_not_zero_or_underflow,
- x, zero_sign_x)));
+ /* We flush to zero if the original or resulting biased exponent is 0,
+ * indicating a +/-0.0 or subnormal input or output.
+ *
+ * The mantissa is set to 0 if the resulting biased exponent is 255, since
+ * an overflow should produce a +/-inf result.
+ *
+ * Note that NaN inputs are handled separately.
+ */
+ i.insert_before(flush_to_zero);
+ i.insert_before(assign(flush_to_zero,
+ lequal(min2(resulting_biased_exp,
+ extracted_biased_exp),
+ ir_constant::zero(ir, ivec))));
i.insert_before(assign(resulting_biased_exp,
- csel(is_not_zero_or_underflow,
- resulting_biased_exp, zeroi)));
+ csel(flush_to_zero,
+ ir_constant::zero(ir, ivec),
+ resulting_biased_exp)));
+
+ i.insert_before(zero_mantissa);
+ i.insert_before(assign(zero_mantissa,
+ logic_or(flush_to_zero,
+ equal(resulting_biased_exp,
+ new(ir) ir_constant(255, vec_elem)))));
+ i.insert_before(assign(sign_mantissa,
+ csel(zero_mantissa,
+ bit_and(sign_mantissa,
+ new(ir) ir_constant(0x80000000u, vec_elem)),
+ sign_mantissa)));
- /* We could test for overflows by checking if the resulting biased exponent
- * would be greater than 0xFE. Turns out we don't need to because the GLSL
- * spec says:
- *
- * "If this product is too large to be represented in the
- * floating-point type, the result is undefined."
+ /* Don't generate new IR that would need to be lowered in an additional
+ * pass.
*/
+ i.insert_before(result);
+ if (!lowering(INSERT_TO_SHIFTS)) {
+ i.insert_before(assign(result,
+ bitfield_insert(sign_mantissa,
+ i2u(resulting_biased_exp),
+ new(ir) ir_constant(23u, vec_elem),
+ new(ir) ir_constant(8u, vec_elem))));
+ } else {
+ i.insert_before(assign(result,
+ bit_or(sign_mantissa,
+ lshift(i2u(resulting_biased_exp),
+ new(ir) ir_constant(23, vec_elem)))));
+ }
- ir_constant *exp_shift_clone = exp_shift->clone(ir, NULL);
- ir->operation = ir_unop_bitcast_i2f;
- ir->operands[0] = bitfield_insert(bitcast_f2i(x), resulting_biased_exp,
- exp_shift_clone, exp_width);
- ir->operands[1] = NULL;
+ ir->operation = ir_triop_csel;
+ ir->init_num_operands();
+ ir->operands[0] = gequal(extracted_biased_exp,
+ new(ir) ir_constant(255, vec_elem));
+ ir->operands[1] = new(ir) ir_dereference_variable(x);
+ ir->operands[2] = bitcast_u2f(result);
this->progress = true;
}
}
ir->operation = ir_quadop_vector;
+ ir->init_num_operands();
ir->operands[0] = results[0];
ir->operands[1] = results[1];
ir->operands[2] = results[2];
/* Put the dvec back together */
ir->operation = ir_quadop_vector;
+ ir->init_num_operands();
ir->operands[0] = results[0];
ir->operands[1] = results[1];
ir->operands[2] = results[2];
/* For non-zero inputs, shift the exponent down and apply bias. */
ir->operation = ir_triop_csel;
+ ir->init_num_operands();
ir->operands[0] = new(ir) ir_dereference_variable(is_not_zero);
ir->operands[1] = add(exponent_bias, u2i(rshift(high_words, exponent_shift)));
ir->operands[2] = izero;
ir_rvalue *x_clone = ir->operands[0]->clone(ir, NULL);
ir->operation = ir_unop_i2u;
+ ir->init_num_operands();
ir->operands[0] = b2i(less(add(ir->operands[0], ir->operands[1]), x_clone));
ir->operands[1] = NULL;
*/
ir->operation = ir_unop_i2u;
+ ir->init_num_operands();
ir->operands[0] = b2i(less(ir->operands[0], ir->operands[1]));
ir->operands[1] = NULL;
*/
ir->operation = ir_binop_min;
+ ir->init_num_operands();
+
+ ir_constant *zero = _imm_fp(ir, ir->operands[0]->type, 0.0);
ir->operands[0] = new(ir) ir_expression(ir_binop_max, ir->operands[0]->type,
- ir->operands[0],
- new(ir) ir_constant(0.0f));
- ir->operands[1] = new(ir) ir_constant(1.0f);
+ ir->operands[0], zero);
+ ir->operands[1] = _imm_fp(ir, ir->operands[0]->type, 1.0);
this->progress = true;
}
}
ir->operation = ir_triop_fma;
+ ir->init_num_operands();
ir->operands[0] = swizzle(ir->operands[0], 0, 1);
ir->operands[1] = swizzle(ir->operands[1], 0, 1);
ir->operands[2] = new(ir) ir_dereference_variable(temp);
}
ir->operation = ir_triop_fma;
+ ir->init_num_operands();
ir->operands[0] = swizzle(op2, swizval, op0->type->vector_elements);
ir->operands[2] = mul(sub(one, op2->clone(ir, NULL)), op0);
i.insert_before(assign(frtemp, fract(ir->operands[0])));
ir->operation = ir_binop_add;
+ ir->init_num_operands();
ir->operands[0] = sub(ir->operands[0]->clone(ir, NULL), frtemp);
ir->operands[1] = csel(nequal(frtemp, zero), one, zero->clone(ir, NULL));
* result = sub(x, frtemp);
*/
ir->operation = ir_binop_sub;
+ ir->init_num_operands();
ir->operands[1] = fract(ir->operands[0]->clone(ir, NULL));
this->progress = true;
i.insert_before(assign(t2, sub(temp, frtemp)));
ir->operation = ir_triop_csel;
+ ir->init_num_operands();
ir->operands[0] = equal(fract(ir->operands[0]->clone(ir, NULL)),
p5->clone(ir, NULL));
ir->operands[1] = csel(equal(fract(mul(t2, p5->clone(ir, NULL))),
i.insert_before(assign(temp, sub(arg->clone(ir, NULL), frtemp)));
ir->operation = ir_triop_csel;
+ ir->init_num_operands();
ir->operands[0] = gequal(arg->clone(ir, NULL), zero);
ir->operands[1] = new (ir) ir_dereference_variable(temp);
ir->operands[2] = add(temp,
ir_constant *neg_one = new(ir) ir_constant(-1.0, arg->type->vector_elements);
ir->operation = ir_triop_csel;
+ ir->init_num_operands();
ir->operands[0] = less(arg->clone(ir, NULL),
zero->clone(ir, NULL));
ir->operands[1] = neg_one;
/* int(((temp + (temp >> 4) & 0xF0F0F0Fu) * 0x1010101u) >> 24); */
ir->operation = ir_unop_u2i;
+ ir->init_num_operands();
ir->operands[0] = rshift(mul(bit_and(add(temp, rshift(temp, c4)), c0F0F0F0F),
c01010101),
c24);
this->progress = true;
}
+void
+lower_instructions_visitor::extract_to_shifts(ir_expression *ir)
+{
+ ir_variable *bits =
+ new(ir) ir_variable(ir->operands[0]->type, "bits", ir_var_temporary);
+
+ base_ir->insert_before(bits);
+ base_ir->insert_before(assign(bits, ir->operands[2]));
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
+ ir_constant *c1 =
+ new(ir) ir_constant(1u, ir->operands[0]->type->vector_elements);
+ ir_constant *c32 =
+ new(ir) ir_constant(32u, ir->operands[0]->type->vector_elements);
+ ir_constant *cFFFFFFFF =
+ new(ir) ir_constant(0xFFFFFFFFu, ir->operands[0]->type->vector_elements);
+
+ /* At least some hardware treats (x << y) as (x << (y%32)). This means
+ * we'd get a mask of 0 when bits is 32. Special case it.
+ *
+ * mask = bits == 32 ? 0xffffffff : (1u << bits) - 1u;
+ */
+ ir_expression *mask = csel(equal(bits, c32),
+ cFFFFFFFF,
+ sub(lshift(c1, bits), c1->clone(ir, NULL)));
+
+ /* Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
+ *
+ * If bits is zero, the result will be zero.
+ *
+ * Since (1 << 0) - 1 == 0, we don't need to bother with the conditional
+ * select as in the signed integer case.
+ *
+ * (value >> offset) & mask;
+ */
+ ir->operation = ir_binop_bit_and;
+ ir->init_num_operands();
+ ir->operands[0] = rshift(ir->operands[0], ir->operands[1]);
+ ir->operands[1] = mask;
+ ir->operands[2] = NULL;
+ } else {
+ ir_constant *c0 =
+ new(ir) ir_constant(int(0), ir->operands[0]->type->vector_elements);
+ ir_constant *c32 =
+ new(ir) ir_constant(int(32), ir->operands[0]->type->vector_elements);
+ ir_variable *temp =
+ new(ir) ir_variable(ir->operands[0]->type, "temp", ir_var_temporary);
+
+ /* temp = 32 - bits; */
+ base_ir->insert_before(temp);
+ base_ir->insert_before(assign(temp, sub(c32, bits)));
+
+ /* expr = value << (temp - offset)) >> temp; */
+ ir_expression *expr =
+ rshift(lshift(ir->operands[0], sub(temp, ir->operands[1])), temp);
+
+ /* Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
+ *
+ * If bits is zero, the result will be zero.
+ *
+ * Due to the (x << (y%32)) behavior mentioned before, the (value <<
+ * (32-0)) doesn't "erase" all of the data as we would like, so finish
+ * up with:
+ *
+ * (bits == 0) ? 0 : e;
+ */
+ ir->operation = ir_triop_csel;
+ ir->init_num_operands();
+ ir->operands[0] = equal(c0, bits);
+ ir->operands[1] = c0->clone(ir, NULL);
+ ir->operands[2] = expr;
+ }
+
+ this->progress = true;
+}
+
+void
+lower_instructions_visitor::insert_to_shifts(ir_expression *ir)
+{
+ ir_constant *c1;
+ ir_constant *c32;
+ ir_constant *cFFFFFFFF;
+ ir_variable *offset =
+ new(ir) ir_variable(ir->operands[0]->type, "offset", ir_var_temporary);
+ ir_variable *bits =
+ new(ir) ir_variable(ir->operands[0]->type, "bits", ir_var_temporary);
+ ir_variable *mask =
+ new(ir) ir_variable(ir->operands[0]->type, "mask", ir_var_temporary);
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_INT) {
+ c1 = new(ir) ir_constant(int(1), ir->operands[0]->type->vector_elements);
+ c32 = new(ir) ir_constant(int(32), ir->operands[0]->type->vector_elements);
+ cFFFFFFFF = new(ir) ir_constant(int(0xFFFFFFFF), ir->operands[0]->type->vector_elements);
+ } else {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
+
+ c1 = new(ir) ir_constant(1u, ir->operands[0]->type->vector_elements);
+ c32 = new(ir) ir_constant(32u, ir->operands[0]->type->vector_elements);
+ cFFFFFFFF = new(ir) ir_constant(0xFFFFFFFFu, ir->operands[0]->type->vector_elements);
+ }
+
+ base_ir->insert_before(offset);
+ base_ir->insert_before(assign(offset, ir->operands[2]));
+
+ base_ir->insert_before(bits);
+ base_ir->insert_before(assign(bits, ir->operands[3]));
+
+ /* At least some hardware treats (x << y) as (x << (y%32)). This means
+ * we'd get a mask of 0 when bits is 32. Special case it.
+ *
+ * mask = (bits == 32 ? 0xffffffff : (1u << bits) - 1u) << offset;
+ *
+ * Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
+ *
+ * The result will be undefined if offset or bits is negative, or if the
+ * sum of offset and bits is greater than the number of bits used to
+ * store the operand.
+ *
+ * Since it's undefined, there are a couple other ways this could be
+ * implemented. The other way that was considered was to put the csel
+ * around the whole thing:
+ *
+ * final_result = bits == 32 ? insert : ... ;
+ */
+ base_ir->insert_before(mask);
+
+ base_ir->insert_before(assign(mask, csel(equal(bits, c32),
+ cFFFFFFFF,
+ lshift(sub(lshift(c1, bits),
+ c1->clone(ir, NULL)),
+ offset))));
+
+ /* (base & ~mask) | ((insert << offset) & mask) */
+ ir->operation = ir_binop_bit_or;
+ ir->init_num_operands();
+ ir->operands[0] = bit_and(ir->operands[0], bit_not(mask));
+ ir->operands[1] = bit_and(lshift(ir->operands[1], offset), mask);
+ ir->operands[2] = NULL;
+ ir->operands[3] = NULL;
+
+ this->progress = true;
+}
+
+void
+lower_instructions_visitor::reverse_to_shifts(ir_expression *ir)
+{
+ /* For more details, see:
+ *
+ * http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
+ */
+ ir_constant *c1 =
+ new(ir) ir_constant(1u, ir->operands[0]->type->vector_elements);
+ ir_constant *c2 =
+ new(ir) ir_constant(2u, ir->operands[0]->type->vector_elements);
+ ir_constant *c4 =
+ new(ir) ir_constant(4u, ir->operands[0]->type->vector_elements);
+ ir_constant *c8 =
+ new(ir) ir_constant(8u, ir->operands[0]->type->vector_elements);
+ ir_constant *c16 =
+ new(ir) ir_constant(16u, ir->operands[0]->type->vector_elements);
+ ir_constant *c33333333 =
+ new(ir) ir_constant(0x33333333u, ir->operands[0]->type->vector_elements);
+ ir_constant *c55555555 =
+ new(ir) ir_constant(0x55555555u, ir->operands[0]->type->vector_elements);
+ ir_constant *c0F0F0F0F =
+ new(ir) ir_constant(0x0F0F0F0Fu, ir->operands[0]->type->vector_elements);
+ ir_constant *c00FF00FF =
+ new(ir) ir_constant(0x00FF00FFu, ir->operands[0]->type->vector_elements);
+ ir_variable *temp =
+ new(ir) ir_variable(glsl_type::uvec(ir->operands[0]->type->vector_elements),
+ "temp", ir_var_temporary);
+ ir_instruction &i = *base_ir;
+
+ i.insert_before(temp);
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
+ i.insert_before(assign(temp, ir->operands[0]));
+ } else {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
+ i.insert_before(assign(temp, i2u(ir->operands[0])));
+ }
+
+ /* Swap odd and even bits.
+ *
+ * temp = ((temp >> 1) & 0x55555555u) | ((temp & 0x55555555u) << 1);
+ */
+ i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c1), c55555555),
+ lshift(bit_and(temp, c55555555->clone(ir, NULL)),
+ c1->clone(ir, NULL)))));
+ /* Swap consecutive pairs.
+ *
+ * temp = ((temp >> 2) & 0x33333333u) | ((temp & 0x33333333u) << 2);
+ */
+ i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c2), c33333333),
+ lshift(bit_and(temp, c33333333->clone(ir, NULL)),
+ c2->clone(ir, NULL)))));
+
+ /* Swap nibbles.
+ *
+ * temp = ((temp >> 4) & 0x0F0F0F0Fu) | ((temp & 0x0F0F0F0Fu) << 4);
+ */
+ i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c4), c0F0F0F0F),
+ lshift(bit_and(temp, c0F0F0F0F->clone(ir, NULL)),
+ c4->clone(ir, NULL)))));
+
+ /* The last step is, basically, bswap. Swap the bytes, then swap the
+ * words. When this code is run through GCC on x86, it does generate a
+ * bswap instruction.
+ *
+ * temp = ((temp >> 8) & 0x00FF00FFu) | ((temp & 0x00FF00FFu) << 8);
+ * temp = ( temp >> 16 ) | ( temp << 16);
+ */
+ i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c8), c00FF00FF),
+ lshift(bit_and(temp, c00FF00FF->clone(ir, NULL)),
+ c8->clone(ir, NULL)))));
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
+ ir->operation = ir_binop_bit_or;
+ ir->init_num_operands();
+ ir->operands[0] = rshift(temp, c16);
+ ir->operands[1] = lshift(temp, c16->clone(ir, NULL));
+ } else {
+ ir->operation = ir_unop_u2i;
+ ir->init_num_operands();
+ ir->operands[0] = bit_or(rshift(temp, c16),
+ lshift(temp, c16->clone(ir, NULL)));
+ }
+
+ this->progress = true;
+}
+
+void
+lower_instructions_visitor::find_lsb_to_float_cast(ir_expression *ir)
+{
+ /* For more details, see:
+ *
+ * http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightFloatCast
+ */
+ const unsigned elements = ir->operands[0]->type->vector_elements;
+ ir_constant *c0 = new(ir) ir_constant(unsigned(0), elements);
+ ir_constant *cminus1 = new(ir) ir_constant(int(-1), elements);
+ ir_constant *c23 = new(ir) ir_constant(int(23), elements);
+ ir_constant *c7F = new(ir) ir_constant(int(0x7F), elements);
+ ir_variable *temp =
+ new(ir) ir_variable(glsl_type::ivec(elements), "temp", ir_var_temporary);
+ ir_variable *lsb_only =
+ new(ir) ir_variable(glsl_type::uvec(elements), "lsb_only", ir_var_temporary);
+ ir_variable *as_float =
+ new(ir) ir_variable(glsl_type::vec(elements), "as_float", ir_var_temporary);
+ ir_variable *lsb =
+ new(ir) ir_variable(glsl_type::ivec(elements), "lsb", ir_var_temporary);
+
+ ir_instruction &i = *base_ir;
+
+ i.insert_before(temp);
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_INT) {
+ i.insert_before(assign(temp, ir->operands[0]));
+ } else {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
+ i.insert_before(assign(temp, u2i(ir->operands[0])));
+ }
+
+ /* The int-to-float conversion is lossless because (value & -value) is
+ * either a power of two or zero. We don't use the result in the zero
+ * case. The uint() cast is necessary so that 0x80000000 does not
+ * generate a negative value.
+ *
+ * uint lsb_only = uint(value & -value);
+ * float as_float = float(lsb_only);
+ */
+ i.insert_before(lsb_only);
+ i.insert_before(assign(lsb_only, i2u(bit_and(temp, neg(temp)))));
+
+ i.insert_before(as_float);
+ i.insert_before(assign(as_float, u2f(lsb_only)));
+
+ /* This is basically an open-coded frexp. Implementations that have a
+ * native frexp instruction would be better served by that. This is
+ * optimized versus a full-featured open-coded implementation in two ways:
+ *
+ * - We don't care about a correct result from subnormal numbers (including
+ * 0.0), so the raw exponent can always be safely unbiased.
+ *
+ * - The value cannot be negative, so it does not need to be masked off to
+ * extract the exponent.
+ *
+ * int lsb = (floatBitsToInt(as_float) >> 23) - 0x7f;
+ */
+ i.insert_before(lsb);
+ i.insert_before(assign(lsb, sub(rshift(bitcast_f2i(as_float), c23), c7F)));
+
+ /* Use lsb_only in the comparison instead of temp so that the & (far above)
+ * can possibly generate the result without an explicit comparison.
+ *
+ * (lsb_only == 0) ? -1 : lsb;
+ *
+ * Since our input values are all integers, the unbiased exponent must not
+ * be negative. It will only be negative (-0x7f, in fact) if lsb_only is
+ * 0. Instead of using (lsb_only == 0), we could use (lsb >= 0). Which is
+ * better is likely GPU dependent. Either way, the difference should be
+ * small.
+ */
+ ir->operation = ir_triop_csel;
+ ir->init_num_operands();
+ ir->operands[0] = equal(lsb_only, c0);
+ ir->operands[1] = cminus1;
+ ir->operands[2] = new(ir) ir_dereference_variable(lsb);
+
+ this->progress = true;
+}
+
+void
+lower_instructions_visitor::find_msb_to_float_cast(ir_expression *ir)
+{
+ /* For more details, see:
+ *
+ * http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightFloatCast
+ */
+ const unsigned elements = ir->operands[0]->type->vector_elements;
+ ir_constant *c0 = new(ir) ir_constant(int(0), elements);
+ ir_constant *cminus1 = new(ir) ir_constant(int(-1), elements);
+ ir_constant *c23 = new(ir) ir_constant(int(23), elements);
+ ir_constant *c7F = new(ir) ir_constant(int(0x7F), elements);
+ ir_constant *c000000FF = new(ir) ir_constant(0x000000FFu, elements);
+ ir_constant *cFFFFFF00 = new(ir) ir_constant(0xFFFFFF00u, elements);
+ ir_variable *temp =
+ new(ir) ir_variable(glsl_type::uvec(elements), "temp", ir_var_temporary);
+ ir_variable *as_float =
+ new(ir) ir_variable(glsl_type::vec(elements), "as_float", ir_var_temporary);
+ ir_variable *msb =
+ new(ir) ir_variable(glsl_type::ivec(elements), "msb", ir_var_temporary);
+
+ ir_instruction &i = *base_ir;
+
+ i.insert_before(temp);
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
+ i.insert_before(assign(temp, ir->operands[0]));
+ } else {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
+
+ /* findMSB(uint(abs(some_int))) almost always does the right thing.
+ * There are two problem values:
+ *
+ * * 0x80000000. Since abs(0x80000000) == 0x80000000, findMSB returns
+ * 31. However, findMSB(int(0x80000000)) == 30.
+ *
+ * * 0xffffffff. Since abs(0xffffffff) == 1, findMSB returns
+ * 31. Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
+ *
+ * For a value of zero or negative one, -1 will be returned.
+ *
+ * For all negative number cases, including 0x80000000 and 0xffffffff,
+ * the correct value is obtained from findMSB if instead of negating the
+ * (already negative) value the logical-not is used. A conditonal
+ * logical-not can be achieved in two instructions.
+ */
+ ir_variable *as_int =
+ new(ir) ir_variable(glsl_type::ivec(elements), "as_int", ir_var_temporary);
+ ir_constant *c31 = new(ir) ir_constant(int(31), elements);
+
+ i.insert_before(as_int);
+ i.insert_before(assign(as_int, ir->operands[0]));
+ i.insert_before(assign(temp, i2u(expr(ir_binop_bit_xor,
+ as_int,
+ rshift(as_int, c31)))));
+ }
+
+ /* The int-to-float conversion is lossless because bits are conditionally
+ * masked off the bottom of temp to ensure the value has at most 24 bits of
+ * data or is zero. We don't use the result in the zero case. The uint()
+ * cast is necessary so that 0x80000000 does not generate a negative value.
+ *
+ * float as_float = float(temp > 255 ? temp & ~255 : temp);
+ */
+ i.insert_before(as_float);
+ i.insert_before(assign(as_float, u2f(csel(greater(temp, c000000FF),
+ bit_and(temp, cFFFFFF00),
+ temp))));
+
+ /* This is basically an open-coded frexp. Implementations that have a
+ * native frexp instruction would be better served by that. This is
+ * optimized versus a full-featured open-coded implementation in two ways:
+ *
+ * - We don't care about a correct result from subnormal numbers (including
+ * 0.0), so the raw exponent can always be safely unbiased.
+ *
+ * - The value cannot be negative, so it does not need to be masked off to
+ * extract the exponent.
+ *
+ * int msb = (floatBitsToInt(as_float) >> 23) - 0x7f;
+ */
+ i.insert_before(msb);
+ i.insert_before(assign(msb, sub(rshift(bitcast_f2i(as_float), c23), c7F)));
+
+ /* Use msb in the comparison instead of temp so that the subtract can
+ * possibly generate the result without an explicit comparison.
+ *
+ * (msb < 0) ? -1 : msb;
+ *
+ * Since our input values are all integers, the unbiased exponent must not
+ * be negative. It will only be negative (-0x7f, in fact) if temp is 0.
+ */
+ ir->operation = ir_triop_csel;
+ ir->init_num_operands();
+ ir->operands[0] = less(msb, c0);
+ ir->operands[1] = cminus1;
+ ir->operands[2] = new(ir) ir_dereference_variable(msb);
+
+ this->progress = true;
+}
+
+ir_expression *
+lower_instructions_visitor::_carry(operand a, operand b)
+{
+ if (lowering(CARRY_TO_ARITH))
+ return i2u(b2i(less(add(a, b),
+ a.val->clone(ralloc_parent(a.val), NULL))));
+ else
+ return carry(a, b);
+}
+
+ir_constant *
+lower_instructions_visitor::_imm_fp(void *mem_ctx,
+ const glsl_type *type,
+ double f,
+ unsigned vector_elements)
+{
+ switch (type->base_type) {
+ case GLSL_TYPE_FLOAT:
+ return new(mem_ctx) ir_constant((float) f, vector_elements);
+ case GLSL_TYPE_DOUBLE:
+ return new(mem_ctx) ir_constant((double) f, vector_elements);
+ case GLSL_TYPE_FLOAT16:
+ return new(mem_ctx) ir_constant(float16_t(f), vector_elements);
+ default:
+ assert(!"unknown float type for immediate");
+ return NULL;
+ }
+}
+
+void
+lower_instructions_visitor::imul_high_to_mul(ir_expression *ir)
+{
+ /* ABCD
+ * * EFGH
+ * ======
+ * (GH * CD) + (GH * AB) << 16 + (EF * CD) << 16 + (EF * AB) << 32
+ *
+ * In GLSL, (a * b) becomes
+ *
+ * uint m1 = (a & 0x0000ffffu) * (b & 0x0000ffffu);
+ * uint m2 = (a & 0x0000ffffu) * (b >> 16);
+ * uint m3 = (a >> 16) * (b & 0x0000ffffu);
+ * uint m4 = (a >> 16) * (b >> 16);
+ *
+ * uint c1;
+ * uint c2;
+ * uint lo_result;
+ * uint hi_result;
+ *
+ * lo_result = uaddCarry(m1, m2 << 16, c1);
+ * hi_result = m4 + c1;
+ * lo_result = uaddCarry(lo_result, m3 << 16, c2);
+ * hi_result = hi_result + c2;
+ * hi_result = hi_result + (m2 >> 16) + (m3 >> 16);
+ */
+ const unsigned elements = ir->operands[0]->type->vector_elements;
+ ir_variable *src1 =
+ new(ir) ir_variable(glsl_type::uvec(elements), "src1", ir_var_temporary);
+ ir_variable *src1h =
+ new(ir) ir_variable(glsl_type::uvec(elements), "src1h", ir_var_temporary);
+ ir_variable *src1l =
+ new(ir) ir_variable(glsl_type::uvec(elements), "src1l", ir_var_temporary);
+ ir_variable *src2 =
+ new(ir) ir_variable(glsl_type::uvec(elements), "src2", ir_var_temporary);
+ ir_variable *src2h =
+ new(ir) ir_variable(glsl_type::uvec(elements), "src2h", ir_var_temporary);
+ ir_variable *src2l =
+ new(ir) ir_variable(glsl_type::uvec(elements), "src2l", ir_var_temporary);
+ ir_variable *t1 =
+ new(ir) ir_variable(glsl_type::uvec(elements), "t1", ir_var_temporary);
+ ir_variable *t2 =
+ new(ir) ir_variable(glsl_type::uvec(elements), "t2", ir_var_temporary);
+ ir_variable *lo =
+ new(ir) ir_variable(glsl_type::uvec(elements), "lo", ir_var_temporary);
+ ir_variable *hi =
+ new(ir) ir_variable(glsl_type::uvec(elements), "hi", ir_var_temporary);
+ ir_variable *different_signs = NULL;
+ ir_constant *c0000FFFF = new(ir) ir_constant(0x0000FFFFu, elements);
+ ir_constant *c16 = new(ir) ir_constant(16u, elements);
+
+ ir_instruction &i = *base_ir;
+
+ i.insert_before(src1);
+ i.insert_before(src2);
+ i.insert_before(src1h);
+ i.insert_before(src2h);
+ i.insert_before(src1l);
+ i.insert_before(src2l);
+
+ if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
+ i.insert_before(assign(src1, ir->operands[0]));
+ i.insert_before(assign(src2, ir->operands[1]));
+ } else {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
+
+ ir_variable *itmp1 =
+ new(ir) ir_variable(glsl_type::ivec(elements), "itmp1", ir_var_temporary);
+ ir_variable *itmp2 =
+ new(ir) ir_variable(glsl_type::ivec(elements), "itmp2", ir_var_temporary);
+ ir_constant *c0 = new(ir) ir_constant(int(0), elements);
+
+ i.insert_before(itmp1);
+ i.insert_before(itmp2);
+ i.insert_before(assign(itmp1, ir->operands[0]));
+ i.insert_before(assign(itmp2, ir->operands[1]));
+
+ different_signs =
+ new(ir) ir_variable(glsl_type::bvec(elements), "different_signs",
+ ir_var_temporary);
+
+ i.insert_before(different_signs);
+ i.insert_before(assign(different_signs, expr(ir_binop_logic_xor,
+ less(itmp1, c0),
+ less(itmp2, c0->clone(ir, NULL)))));
+
+ i.insert_before(assign(src1, i2u(abs(itmp1))));
+ i.insert_before(assign(src2, i2u(abs(itmp2))));
+ }
+
+ i.insert_before(assign(src1l, bit_and(src1, c0000FFFF)));
+ i.insert_before(assign(src2l, bit_and(src2, c0000FFFF->clone(ir, NULL))));
+ i.insert_before(assign(src1h, rshift(src1, c16)));
+ i.insert_before(assign(src2h, rshift(src2, c16->clone(ir, NULL))));
+
+ i.insert_before(lo);
+ i.insert_before(hi);
+ i.insert_before(t1);
+ i.insert_before(t2);
+
+ i.insert_before(assign(lo, mul(src1l, src2l)));
+ i.insert_before(assign(t1, mul(src1l, src2h)));
+ i.insert_before(assign(t2, mul(src1h, src2l)));
+ i.insert_before(assign(hi, mul(src1h, src2h)));
+
+ i.insert_before(assign(hi, add(hi, _carry(lo, lshift(t1, c16->clone(ir, NULL))))));
+ i.insert_before(assign(lo, add(lo, lshift(t1, c16->clone(ir, NULL)))));
+
+ i.insert_before(assign(hi, add(hi, _carry(lo, lshift(t2, c16->clone(ir, NULL))))));
+ i.insert_before(assign(lo, add(lo, lshift(t2, c16->clone(ir, NULL)))));
+
+ if (different_signs == NULL) {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
+
+ ir->operation = ir_binop_add;
+ ir->init_num_operands();
+ ir->operands[0] = add(hi, rshift(t1, c16->clone(ir, NULL)));
+ ir->operands[1] = rshift(t2, c16->clone(ir, NULL));
+ } else {
+ assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
+
+ i.insert_before(assign(hi, add(add(hi, rshift(t1, c16->clone(ir, NULL))),
+ rshift(t2, c16->clone(ir, NULL)))));
+
+ /* For channels where different_signs is set we have to perform a 64-bit
+ * negation. This is *not* the same as just negating the high 32-bits.
+ * Consider -3 * 2. The high 32-bits is 0, but the desired result is
+ * -1, not -0! Recall -x == ~x + 1.
+ */
+ ir_variable *neg_hi =
+ new(ir) ir_variable(glsl_type::ivec(elements), "neg_hi", ir_var_temporary);
+ ir_constant *c1 = new(ir) ir_constant(1u, elements);
+
+ i.insert_before(neg_hi);
+ i.insert_before(assign(neg_hi, add(bit_not(u2i(hi)),
+ u2i(_carry(bit_not(lo), c1)))));
+
+ ir->operation = ir_triop_csel;
+ ir->init_num_operands();
+ ir->operands[0] = new(ir) ir_dereference_variable(different_signs);
+ ir->operands[1] = new(ir) ir_dereference_variable(neg_hi);
+ ir->operands[2] = u2i(hi);
+ }
+}
+
+void
+lower_instructions_visitor::sqrt_to_abs_sqrt(ir_expression *ir)
+{
+ ir->operands[0] = new(ir) ir_expression(ir_unop_abs, ir->operands[0]);
+ this->progress = true;
+}
+
+void
+lower_instructions_visitor::mul64_to_mul_and_mul_high(ir_expression *ir)
+{
+ /* Lower 32x32-> 64 to
+ * msb = imul_high(x_lo, y_lo)
+ * lsb = mul(x_lo, y_lo)
+ */
+ const unsigned elements = ir->operands[0]->type->vector_elements;
+
+ const ir_expression_operation operation =
+ ir->type->base_type == GLSL_TYPE_UINT64 ? ir_unop_pack_uint_2x32
+ : ir_unop_pack_int_2x32;
+
+ const glsl_type *var_type = ir->type->base_type == GLSL_TYPE_UINT64
+ ? glsl_type::uvec(elements)
+ : glsl_type::ivec(elements);
+
+ const glsl_type *ret_type = ir->type->base_type == GLSL_TYPE_UINT64
+ ? glsl_type::uvec2_type
+ : glsl_type::ivec2_type;
+
+ ir_instruction &i = *base_ir;
+
+ ir_variable *msb =
+ new(ir) ir_variable(var_type, "msb", ir_var_temporary);
+ ir_variable *lsb =
+ new(ir) ir_variable(var_type, "lsb", ir_var_temporary);
+ ir_variable *x =
+ new(ir) ir_variable(var_type, "x", ir_var_temporary);
+ ir_variable *y =
+ new(ir) ir_variable(var_type, "y", ir_var_temporary);
+
+ i.insert_before(x);
+ i.insert_before(assign(x, ir->operands[0]));
+ i.insert_before(y);
+ i.insert_before(assign(y, ir->operands[1]));
+ i.insert_before(msb);
+ i.insert_before(lsb);
+
+ i.insert_before(assign(msb, imul_high(x, y)));
+ i.insert_before(assign(lsb, mul(x, y)));
+
+ ir_rvalue *result[4] = {NULL};
+ for (unsigned elem = 0; elem < elements; elem++) {
+ ir_rvalue *val = new(ir) ir_expression(ir_quadop_vector, ret_type,
+ swizzle(lsb, elem, 1),
+ swizzle(msb, elem, 1), NULL, NULL);
+ result[elem] = expr(operation, val);
+ }
+
+ ir->operation = ir_quadop_vector;
+ ir->init_num_operands();
+ ir->operands[0] = result[0];
+ ir->operands[1] = result[1];
+ ir->operands[2] = result[2];
+ ir->operands[3] = result[3];
+
+ this->progress = true;
+}
+
ir_visitor_status
lower_instructions_visitor::visit_leave(ir_expression *ir)
{
break;
case ir_binop_div:
- if (ir->operands[1]->type->is_integer() && lowering(INT_DIV_TO_MUL_RCP))
+ if (ir->operands[1]->type->is_integer_32() && lowering(INT_DIV_TO_MUL_RCP))
int_div_to_mul_rcp(ir);
- else if ((ir->operands[1]->type->is_float() ||
- ir->operands[1]->type->is_double()) && lowering(DIV_TO_MUL_RCP))
+ else if ((ir->operands[1]->type->is_float_16_32() && lowering(FDIV_TO_MUL_RCP)) ||
+ (ir->operands[1]->type->is_double() && lowering(DDIV_TO_MUL_RCP)))
div_to_mul_rcp(ir);
break;
break;
case ir_binop_mod:
- if (lowering(MOD_TO_FLOOR) && (ir->type->is_float() || ir->type->is_double()))
+ if (lowering(MOD_TO_FLOOR) && ir->type->is_float_16_32_64())
mod_to_floor(ir);
break;
bit_count_to_math(ir);
break;
+ case ir_triop_bitfield_extract:
+ if (lowering(EXTRACT_TO_SHIFTS))
+ extract_to_shifts(ir);
+ break;
+
+ case ir_quadop_bitfield_insert:
+ if (lowering(INSERT_TO_SHIFTS))
+ insert_to_shifts(ir);
+ break;
+
+ case ir_unop_bitfield_reverse:
+ if (lowering(REVERSE_TO_SHIFTS))
+ reverse_to_shifts(ir);
+ break;
+
+ case ir_unop_find_lsb:
+ if (lowering(FIND_LSB_TO_FLOAT_CAST))
+ find_lsb_to_float_cast(ir);
+ break;
+
+ case ir_unop_find_msb:
+ if (lowering(FIND_MSB_TO_FLOAT_CAST))
+ find_msb_to_float_cast(ir);
+ break;
+
+ case ir_binop_imul_high:
+ if (lowering(IMUL_HIGH_TO_MUL))
+ imul_high_to_mul(ir);
+ break;
+
+ case ir_binop_mul:
+ if (lowering(MUL64_TO_MUL_AND_MUL_HIGH) &&
+ (ir->type->base_type == GLSL_TYPE_INT64 ||
+ ir->type->base_type == GLSL_TYPE_UINT64) &&
+ (ir->operands[0]->type->base_type == GLSL_TYPE_INT ||
+ ir->operands[1]->type->base_type == GLSL_TYPE_UINT))
+ mul64_to_mul_and_mul_high(ir);
+ break;
+
+ case ir_unop_rsq:
+ case ir_unop_sqrt:
+ if (lowering(SQRT_TO_ABS_SQRT))
+ sqrt_to_abs_sqrt(ir);
+ break;
+
default:
return visit_continue;
}
projects / mesa.git / blobdiff