src/compiler/glsl/lower_instructions.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file lower_instructions.cpp
  26  *
  27  * Many GPUs lack native instructions for certain expression operations, and
  28  * must replace them with some other expression tree.  This pass lowers some
  29  * of the most common cases, allowing the lowering code to be implemented once
  30  * rather than in each driver backend.
  31  *
  32  * Currently supported transformations:
  33  * - SUB_TO_ADD_NEG
  34  * - DIV_TO_MUL_RCP
  35  * - INT_DIV_TO_MUL_RCP
  36  * - EXP_TO_EXP2
  37  * - POW_TO_EXP2
  38  * - LOG_TO_LOG2
  39  * - MOD_TO_FLOOR
  40  * - LDEXP_TO_ARITH
  41  * - DFREXP_TO_ARITH
  42  * - CARRY_TO_ARITH
  43  * - BORROW_TO_ARITH
  44  * - SAT_TO_CLAMP
  45  * - DOPS_TO_DFRAC
  46  *
  47  * SUB_TO_ADD_NEG:
  48  * ---------------
  49  * Breaks an ir_binop_sub expression down to add(op0, neg(op1))
  50  *
  51  * This simplifies expression reassociation, and for many backends
  52  * there is no subtract operation separate from adding the negation.
  53  * For backends with native subtract operations, they will probably
  54  * want to recognize add(op0, neg(op1)) or the other way around to
  55  * produce a subtract anyway.
  56  *
  57  * FDIV_TO_MUL_RCP, DDIV_TO_MUL_RCP, and INT_DIV_TO_MUL_RCP:
  58  * ---------------------------------------------------------
  59  * Breaks an ir_binop_div expression down to op0 * (rcp(op1)).
  60  *
  61  * Many GPUs don't have a divide instruction (945 and 965 included),
  62  * but they do have an RCP instruction to compute an approximate
  63  * reciprocal.  By breaking the operation down, constant reciprocals
  64  * can get constant folded.
  65  *
  66  * FDIV_TO_MUL_RCP only lowers single-precision floating point division;
  67  * DDIV_TO_MUL_RCP only lowers double-precision floating point division.
  68  * DIV_TO_MUL_RCP is a convenience macro that sets both flags.
  69  * INT_DIV_TO_MUL_RCP handles the integer case, converting to and from floating
  70  * point so that RCP is possible.
  71  *
  72  * EXP_TO_EXP2 and LOG_TO_LOG2:
  73  * ----------------------------
  74  * Many GPUs don't have a base e log or exponent instruction, but they
  75  * do have base 2 versions, so this pass converts exp and log to exp2
  76  * and log2 operations.
  77  *
  78  * POW_TO_EXP2:
  79  * -----------
  80  * Many older GPUs don't have an x**y instruction.  For these GPUs, convert
  81  * x**y to 2**(y * log2(x)).
  82  *
  83  * MOD_TO_FLOOR:
  84  * -------------
  85  * Breaks an ir_binop_mod expression down to (op0 - op1 * floor(op0 / op1))
  86  *
  87  * Many GPUs don't have a MOD instruction (945 and 965 included), and
  88  * if we have to break it down like this anyway, it gives an
  89  * opportunity to do things like constant fold the (1.0 / op1) easily.
  90  *
  91  * Note: before we used to implement this as op1 * fract(op / op1) but this
  92  * implementation had significant precision errors.
  93  *
  94  * LDEXP_TO_ARITH:
  95  * -------------
  96  * Converts ir_binop_ldexp to arithmetic and bit operations for float sources.
  97  *
  98  * DFREXP_DLDEXP_TO_ARITH:
  99  * ---------------
 100  * Converts ir_binop_ldexp, ir_unop_frexp_sig, and ir_unop_frexp_exp to
 101  * arithmetic and bit ops for double arguments.
 102  *
 103  * CARRY_TO_ARITH:
 104  * ---------------
 105  * Converts ir_carry into (x + y) < x.
 106  *
 107  * BORROW_TO_ARITH:
 108  * ----------------
 109  * Converts ir_borrow into (x < y).
 110  *
 111  * SAT_TO_CLAMP:
 112  * -------------
 113  * Converts ir_unop_saturate into min(max(x, 0.0), 1.0)
 114  *
 115  * DOPS_TO_DFRAC:
 116  * --------------
 117  * Converts double trunc, ceil, floor, round to fract
 118  */
 119
 120 #include "c99_math.h"
 121 #include "program/prog_instruction.h" /* for swizzle */
 122 #include "compiler/glsl_types.h"
 123 #include "ir.h"
 124 #include "ir_builder.h"
 125 #include "ir_optimization.h"
 126
 127 using namespace ir_builder;
 128
 129 namespace {
 130
 131 class lower_instructions_visitor : public ir_hierarchical_visitor {
 132 public:
 133    lower_instructions_visitor(unsigned lower)
 134       : progress(false), lower(lower) { }
 135
 136    ir_visitor_status visit_leave(ir_expression *);
 137
 138    bool progress;
 139
 140 private:
 141    unsigned lower; /** Bitfield of which operations to lower */
 142
 143    void sub_to_add_neg(ir_expression *);
 144    void div_to_mul_rcp(ir_expression *);
 145    void int_div_to_mul_rcp(ir_expression *);
 146    void mod_to_floor(ir_expression *);
 147    void exp_to_exp2(ir_expression *);
 148    void pow_to_exp2(ir_expression *);
 149    void log_to_log2(ir_expression *);
 150    void ldexp_to_arith(ir_expression *);
 151    void dldexp_to_arith(ir_expression *);
 152    void dfrexp_sig_to_arith(ir_expression *);
 153    void dfrexp_exp_to_arith(ir_expression *);
 154    void carry_to_arith(ir_expression *);
 155    void borrow_to_arith(ir_expression *);
 156    void sat_to_clamp(ir_expression *);
 157    void double_dot_to_fma(ir_expression *);
 158    void double_lrp(ir_expression *);
 159    void dceil_to_dfrac(ir_expression *);
 160    void dfloor_to_dfrac(ir_expression *);
 161    void dround_even_to_dfrac(ir_expression *);
 162    void dtrunc_to_dfrac(ir_expression *);
 163    void dsign_to_csel(ir_expression *);
 164    void bit_count_to_math(ir_expression *);
 165    void extract_to_shifts(ir_expression *);
 166    void insert_to_shifts(ir_expression *);
 167    void reverse_to_shifts(ir_expression *ir);
 168    void find_lsb_to_float_cast(ir_expression *ir);
 169    void find_msb_to_float_cast(ir_expression *ir);
 170    void imul_high_to_mul(ir_expression *ir);
 171    void sqrt_to_abs_sqrt(ir_expression *ir);
 172
 173    ir_expression *_carry(operand a, operand b);
 174 };
 175
 176 } /* anonymous namespace */
 177
 178 /**
 179  * Determine if a particular type of lowering should occur
 180  */
 181 #define lowering(x) (this->lower & x)
 182
 183 bool
 184 lower_instructions(exec_list *instructions, unsigned what_to_lower)
 185 {
 186    lower_instructions_visitor v(what_to_lower);
 187
 188    visit_list_elements(&v, instructions);
 189    return v.progress;
 190 }
 191
 192 void
 193 lower_instructions_visitor::sub_to_add_neg(ir_expression *ir)
 194 {
 195    ir->operation = ir_binop_add;
 196    ir->init_num_operands();
 197    ir->operands[1] = new(ir) ir_expression(ir_unop_neg, ir->operands[1]->type,
 198                                            ir->operands[1], NULL);
 199    this->progress = true;
 200 }
 201
 202 void
 203 lower_instructions_visitor::div_to_mul_rcp(ir_expression *ir)
 204 {
 205    assert(ir->operands[1]->type->is_float() || ir->operands[1]->type->is_double());
 206
 207    /* New expression for the 1.0 / op1 */
 208    ir_rvalue *expr;
 209    expr = new(ir) ir_expression(ir_unop_rcp,
 210                                 ir->operands[1]->type,
 211                                 ir->operands[1]);
 212
 213    /* op0 / op1 -> op0 * (1.0 / op1) */
 214    ir->operation = ir_binop_mul;
 215    ir->init_num_operands();
 216    ir->operands[1] = expr;
 217
 218    this->progress = true;
 219 }
 220
 221 void
 222 lower_instructions_visitor::int_div_to_mul_rcp(ir_expression *ir)
 223 {
 224    assert(ir->operands[1]->type->is_integer());
 225
 226    /* Be careful with integer division -- we need to do it as a
 227     * float and re-truncate, since rcp(n > 1) of an integer would
 228     * just be 0.
 229     */
 230    ir_rvalue *op0, *op1;
 231    const struct glsl_type *vec_type;
 232
 233    vec_type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
 234                                       ir->operands[1]->type->vector_elements,
 235                                       ir->operands[1]->type->matrix_columns);
 236
 237    if (ir->operands[1]->type->base_type == GLSL_TYPE_INT)
 238       op1 = new(ir) ir_expression(ir_unop_i2f, vec_type, ir->operands[1], NULL);
 239    else
 240       op1 = new(ir) ir_expression(ir_unop_u2f, vec_type, ir->operands[1], NULL);
 241
 242    op1 = new(ir) ir_expression(ir_unop_rcp, op1->type, op1, NULL);
 243
 244    vec_type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
 245                                       ir->operands[0]->type->vector_elements,
 246                                       ir->operands[0]->type->matrix_columns);
 247
 248    if (ir->operands[0]->type->base_type == GLSL_TYPE_INT)
 249       op0 = new(ir) ir_expression(ir_unop_i2f, vec_type, ir->operands[0], NULL);
 250    else
 251       op0 = new(ir) ir_expression(ir_unop_u2f, vec_type, ir->operands[0], NULL);
 252
 253    vec_type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
 254                                       ir->type->vector_elements,
 255                                       ir->type->matrix_columns);
 256
 257    op0 = new(ir) ir_expression(ir_binop_mul, vec_type, op0, op1);
 258
 259    if (ir->operands[1]->type->base_type == GLSL_TYPE_INT) {
 260       ir->operation = ir_unop_f2i;
 261       ir->operands[0] = op0;
 262    } else {
 263       ir->operation = ir_unop_i2u;
 264       ir->operands[0] = new(ir) ir_expression(ir_unop_f2i, op0);
 265    }
 266    ir->init_num_operands();
 267    ir->operands[1] = NULL;
 268
 269    this->progress = true;
 270 }
 271
 272 void
 273 lower_instructions_visitor::exp_to_exp2(ir_expression *ir)
 274 {
 275    ir_constant *log2_e = new(ir) ir_constant(float(M_LOG2E));
 276
 277    ir->operation = ir_unop_exp2;
 278    ir->init_num_operands();
 279    ir->operands[0] = new(ir) ir_expression(ir_binop_mul, ir->operands[0]->type,
 280                                            ir->operands[0], log2_e);
 281    this->progress = true;
 282 }
 283
 284 void
 285 lower_instructions_visitor::pow_to_exp2(ir_expression *ir)
 286 {
 287    ir_expression *const log2_x =
 288       new(ir) ir_expression(ir_unop_log2, ir->operands[0]->type,
 289                             ir->operands[0]);
 290
 291    ir->operation = ir_unop_exp2;
 292    ir->init_num_operands();
 293    ir->operands[0] = new(ir) ir_expression(ir_binop_mul, ir->operands[1]->type,
 294                                            ir->operands[1], log2_x);
 295    ir->operands[1] = NULL;
 296    this->progress = true;
 297 }
 298
 299 void
 300 lower_instructions_visitor::log_to_log2(ir_expression *ir)
 301 {
 302    ir->operation = ir_binop_mul;
 303    ir->init_num_operands();
 304    ir->operands[0] = new(ir) ir_expression(ir_unop_log2, ir->operands[0]->type,
 305                                            ir->operands[0], NULL);
 306    ir->operands[1] = new(ir) ir_constant(float(1.0 / M_LOG2E));
 307    this->progress = true;
 308 }
 309
 310 void
 311 lower_instructions_visitor::mod_to_floor(ir_expression *ir)
 312 {
 313    ir_variable *x = new(ir) ir_variable(ir->operands[0]->type, "mod_x",
 314                                          ir_var_temporary);
 315    ir_variable *y = new(ir) ir_variable(ir->operands[1]->type, "mod_y",
 316                                          ir_var_temporary);
 317    this->base_ir->insert_before(x);
 318    this->base_ir->insert_before(y);
 319
 320    ir_assignment *const assign_x =
 321       new(ir) ir_assignment(new(ir) ir_dereference_variable(x),
 322                             ir->operands[0], NULL);
 323    ir_assignment *const assign_y =
 324       new(ir) ir_assignment(new(ir) ir_dereference_variable(y),
 325                             ir->operands[1], NULL);
 326
 327    this->base_ir->insert_before(assign_x);
 328    this->base_ir->insert_before(assign_y);
 329
 330    ir_expression *const div_expr =
 331       new(ir) ir_expression(ir_binop_div, x->type,
 332                             new(ir) ir_dereference_variable(x),
 333                             new(ir) ir_dereference_variable(y));
 334
 335    /* Don't generate new IR that would need to be lowered in an additional
 336     * pass.
 337     */
 338    if ((lowering(FDIV_TO_MUL_RCP) && ir->type->is_float()) ||
 339        (lowering(DDIV_TO_MUL_RCP) && ir->type->is_double()))
 340       div_to_mul_rcp(div_expr);
 341
 342    ir_expression *const floor_expr =
 343       new(ir) ir_expression(ir_unop_floor, x->type, div_expr);
 344
 345    if (lowering(DOPS_TO_DFRAC) && ir->type->is_double())
 346       dfloor_to_dfrac(floor_expr);
 347
 348    ir_expression *const mul_expr =
 349       new(ir) ir_expression(ir_binop_mul,
 350                             new(ir) ir_dereference_variable(y),
 351                             floor_expr);
 352
 353    ir->operation = ir_binop_sub;
 354    ir->init_num_operands();
 355    ir->operands[0] = new(ir) ir_dereference_variable(x);
 356    ir->operands[1] = mul_expr;
 357    this->progress = true;
 358 }
 359
 360 void
 361 lower_instructions_visitor::ldexp_to_arith(ir_expression *ir)
 362 {
 363    /* Translates
 364     *    ir_binop_ldexp x exp
 365     * into
 366     *
 367     *    extracted_biased_exp = rshift(bitcast_f2i(abs(x)), exp_shift);
 368     *    resulting_biased_exp = extracted_biased_exp + exp;
 369     *
 370     *    if (resulting_biased_exp < 1 || x == 0.0f) {
 371     *       return copysign(0.0, x);
 372     *    }
 373     *
 374     *    return bitcast_u2f((bitcast_f2u(x) & sign_mantissa_mask) |
 375     *                       lshift(i2u(resulting_biased_exp), exp_shift));
 376     *
 377     * which we can't actually implement as such, since the GLSL IR doesn't
 378     * have vectorized if-statements. We actually implement it without branches
 379     * using conditional-select:
 380     *
 381     *    extracted_biased_exp = rshift(bitcast_f2i(abs(x)), exp_shift);
 382     *    resulting_biased_exp = extracted_biased_exp + exp;
 383     *
 384     *    is_not_zero_or_underflow = logic_and(nequal(x, 0.0f),
 385     *                                         gequal(resulting_biased_exp, 1);
 386     *    x = csel(is_not_zero_or_underflow, x, copysign(0.0f, x));
 387     *    resulting_biased_exp = csel(is_not_zero_or_underflow,
 388     *                                resulting_biased_exp, 0);
 389     *
 390     *    return bitcast_u2f((bitcast_f2u(x) & sign_mantissa_mask) |
 391     *                       lshift(i2u(resulting_biased_exp), exp_shift));
 392     */
 393
 394    const unsigned vec_elem = ir->type->vector_elements;
 395
 396    /* Types */
 397    const glsl_type *ivec = glsl_type::get_instance(GLSL_TYPE_INT, vec_elem, 1);
 398    const glsl_type *bvec = glsl_type::get_instance(GLSL_TYPE_BOOL, vec_elem, 1);
 399
 400    /* Constants */
 401    ir_constant *zeroi = ir_constant::zero(ir, ivec);
 402
 403    ir_constant *sign_mask = new(ir) ir_constant(0x80000000u, vec_elem);
 404
 405    ir_constant *exp_shift = new(ir) ir_constant(23, vec_elem);
 406
 407    /* Temporary variables */
 408    ir_variable *x = new(ir) ir_variable(ir->type, "x", ir_var_temporary);
 409    ir_variable *exp = new(ir) ir_variable(ivec, "exp", ir_var_temporary);
 410
 411    ir_variable *zero_sign_x = new(ir) ir_variable(ir->type, "zero_sign_x",
 412                                                   ir_var_temporary);
 413
 414    ir_variable *extracted_biased_exp =
 415       new(ir) ir_variable(ivec, "extracted_biased_exp", ir_var_temporary);
 416    ir_variable *resulting_biased_exp =
 417       new(ir) ir_variable(ivec, "resulting_biased_exp", ir_var_temporary);
 418
 419    ir_variable *is_not_zero_or_underflow =
 420       new(ir) ir_variable(bvec, "is_not_zero_or_underflow", ir_var_temporary);
 421
 422    ir_instruction &i = *base_ir;
 423
 424    /* Copy <x> and <exp> arguments. */
 425    i.insert_before(x);
 426    i.insert_before(assign(x, ir->operands[0]));
 427    i.insert_before(exp);
 428    i.insert_before(assign(exp, ir->operands[1]));
 429
 430    /* Extract the biased exponent from <x>. */
 431    i.insert_before(extracted_biased_exp);
 432    i.insert_before(assign(extracted_biased_exp,
 433                           rshift(bitcast_f2i(abs(x)), exp_shift)));
 434
 435    i.insert_before(resulting_biased_exp);
 436    i.insert_before(assign(resulting_biased_exp,
 437                           add(extracted_biased_exp, exp)));
 438
 439    /* Test if result is ±0.0, subnormal, or underflow by checking if the
 440     * resulting biased exponent would be less than 0x1. If so, the result is
 441     * 0.0 with the sign of x. (Actually, invert the conditions so that
 442     * immediate values are the second arguments, which is better for i965)
 443     */
 444    i.insert_before(zero_sign_x);
 445    i.insert_before(assign(zero_sign_x,
 446                           bitcast_u2f(bit_and(bitcast_f2u(x), sign_mask))));
 447
 448    i.insert_before(is_not_zero_or_underflow);
 449    i.insert_before(assign(is_not_zero_or_underflow,
 450                           logic_and(nequal(x, new(ir) ir_constant(0.0f, vec_elem)),
 451                                     gequal(resulting_biased_exp,
 452                                            new(ir) ir_constant(0x1, vec_elem)))));
 453    i.insert_before(assign(x, csel(is_not_zero_or_underflow,
 454                                   x, zero_sign_x)));
 455    i.insert_before(assign(resulting_biased_exp,
 456                           csel(is_not_zero_or_underflow,
 457                                resulting_biased_exp, zeroi)));
 458
 459    /* We could test for overflows by checking if the resulting biased exponent
 460     * would be greater than 0xFE. Turns out we don't need to because the GLSL
 461     * spec says:
 462     *
 463     *    "If this product is too large to be represented in the
 464     *     floating-point type, the result is undefined."
 465     */
 466
 467    ir_constant *exp_shift_clone = exp_shift->clone(ir, NULL);
 468
 469    /* Don't generate new IR that would need to be lowered in an additional
 470     * pass.
 471     */
 472    if (!lowering(INSERT_TO_SHIFTS)) {
 473       ir_constant *exp_width = new(ir) ir_constant(8, vec_elem);
 474       ir->operation = ir_unop_bitcast_i2f;
 475       ir->init_num_operands();
 476       ir->operands[0] = bitfield_insert(bitcast_f2i(x), resulting_biased_exp,
 477                                         exp_shift_clone, exp_width);
 478       ir->operands[1] = NULL;
 479    } else {
 480       ir_constant *sign_mantissa_mask = new(ir) ir_constant(0x807fffffu, vec_elem);
 481       ir->operation = ir_unop_bitcast_u2f;
 482       ir->init_num_operands();
 483       ir->operands[0] = bit_or(bit_and(bitcast_f2u(x), sign_mantissa_mask),
 484                                lshift(i2u(resulting_biased_exp), exp_shift_clone));
 485    }
 486
 487    this->progress = true;
 488 }
 489
 490 void
 491 lower_instructions_visitor::dldexp_to_arith(ir_expression *ir)
 492 {
 493    /* See ldexp_to_arith for structure. Uses frexp_exp to extract the exponent
 494     * from the significand.
 495     */
 496
 497    const unsigned vec_elem = ir->type->vector_elements;
 498
 499    /* Types */
 500    const glsl_type *ivec = glsl_type::get_instance(GLSL_TYPE_INT, vec_elem, 1);
 501    const glsl_type *bvec = glsl_type::get_instance(GLSL_TYPE_BOOL, vec_elem, 1);
 502
 503    /* Constants */
 504    ir_constant *zeroi = ir_constant::zero(ir, ivec);
 505
 506    ir_constant *sign_mask = new(ir) ir_constant(0x80000000u);
 507
 508    ir_constant *exp_shift = new(ir) ir_constant(20u);
 509    ir_constant *exp_width = new(ir) ir_constant(11u);
 510    ir_constant *exp_bias = new(ir) ir_constant(1022, vec_elem);
 511
 512    /* Temporary variables */
 513    ir_variable *x = new(ir) ir_variable(ir->type, "x", ir_var_temporary);
 514    ir_variable *exp = new(ir) ir_variable(ivec, "exp", ir_var_temporary);
 515
 516    ir_variable *zero_sign_x = new(ir) ir_variable(ir->type, "zero_sign_x",
 517                                                   ir_var_temporary);
 518
 519    ir_variable *extracted_biased_exp =
 520       new(ir) ir_variable(ivec, "extracted_biased_exp", ir_var_temporary);
 521    ir_variable *resulting_biased_exp =
 522       new(ir) ir_variable(ivec, "resulting_biased_exp", ir_var_temporary);
 523
 524    ir_variable *is_not_zero_or_underflow =
 525       new(ir) ir_variable(bvec, "is_not_zero_or_underflow", ir_var_temporary);
 526
 527    ir_instruction &i = *base_ir;
 528
 529    /* Copy <x> and <exp> arguments. */
 530    i.insert_before(x);
 531    i.insert_before(assign(x, ir->operands[0]));
 532    i.insert_before(exp);
 533    i.insert_before(assign(exp, ir->operands[1]));
 534
 535    ir_expression *frexp_exp = expr(ir_unop_frexp_exp, x);
 536    if (lowering(DFREXP_DLDEXP_TO_ARITH))
 537       dfrexp_exp_to_arith(frexp_exp);
 538
 539    /* Extract the biased exponent from <x>. */
 540    i.insert_before(extracted_biased_exp);
 541    i.insert_before(assign(extracted_biased_exp, add(frexp_exp, exp_bias)));
 542
 543    i.insert_before(resulting_biased_exp);
 544    i.insert_before(assign(resulting_biased_exp,
 545                           add(extracted_biased_exp, exp)));
 546
 547    /* Test if result is ±0.0, subnormal, or underflow by checking if the
 548     * resulting biased exponent would be less than 0x1. If so, the result is
 549     * 0.0 with the sign of x. (Actually, invert the conditions so that
 550     * immediate values are the second arguments, which is better for i965)
 551     * TODO: Implement in a vector fashion.
 552     */
 553    i.insert_before(zero_sign_x);
 554    for (unsigned elem = 0; elem < vec_elem; elem++) {
 555       ir_variable *unpacked =
 556          new(ir) ir_variable(glsl_type::uvec2_type, "unpacked", ir_var_temporary);
 557       i.insert_before(unpacked);
 558       i.insert_before(
 559             assign(unpacked,
 560                    expr(ir_unop_unpack_double_2x32, swizzle(x, elem, 1))));
 561       i.insert_before(assign(unpacked, bit_and(swizzle_y(unpacked), sign_mask->clone(ir, NULL)),
 562                              WRITEMASK_Y));
 563       i.insert_before(assign(unpacked, ir_constant::zero(ir, glsl_type::uint_type), WRITEMASK_X));
 564       i.insert_before(assign(zero_sign_x,
 565                              expr(ir_unop_pack_double_2x32, unpacked),
 566                              1 << elem));
 567    }
 568    i.insert_before(is_not_zero_or_underflow);
 569    i.insert_before(assign(is_not_zero_or_underflow,
 570                           gequal(resulting_biased_exp,
 571                                   new(ir) ir_constant(0x1, vec_elem))));
 572    i.insert_before(assign(x, csel(is_not_zero_or_underflow,
 573                                   x, zero_sign_x)));
 574    i.insert_before(assign(resulting_biased_exp,
 575                           csel(is_not_zero_or_underflow,
 576                                resulting_biased_exp, zeroi)));
 577
 578    /* We could test for overflows by checking if the resulting biased exponent
 579     * would be greater than 0xFE. Turns out we don't need to because the GLSL
 580     * spec says:
 581     *
 582     *    "If this product is too large to be represented in the
 583     *     floating-point type, the result is undefined."
 584     */
 585
 586    ir_rvalue *results[4] = {NULL};
 587    for (unsigned elem = 0; elem < vec_elem; elem++) {
 588       ir_variable *unpacked =
 589          new(ir) ir_variable(glsl_type::uvec2_type, "unpacked", ir_var_temporary);
 590       i.insert_before(unpacked);
 591       i.insert_before(
 592             assign(unpacked,
 593                    expr(ir_unop_unpack_double_2x32, swizzle(x, elem, 1))));
 594
 595       ir_expression *bfi = bitfield_insert(
 596             swizzle_y(unpacked),
 597             i2u(swizzle(resulting_biased_exp, elem, 1)),
 598             exp_shift->clone(ir, NULL),
 599             exp_width->clone(ir, NULL));
 600
 601       i.insert_before(assign(unpacked, bfi, WRITEMASK_Y));
 602
 603       results[elem] = expr(ir_unop_pack_double_2x32, unpacked);
 604    }
 605
 606    ir->operation = ir_quadop_vector;
 607    ir->init_num_operands();
 608    ir->operands[0] = results[0];
 609    ir->operands[1] = results[1];
 610    ir->operands[2] = results[2];
 611    ir->operands[3] = results[3];
 612
 613    /* Don't generate new IR that would need to be lowered in an additional
 614     * pass.
 615     */
 616
 617    this->progress = true;
 618 }
 619
 620 void
 621 lower_instructions_visitor::dfrexp_sig_to_arith(ir_expression *ir)
 622 {
 623    const unsigned vec_elem = ir->type->vector_elements;
 624    const glsl_type *bvec = glsl_type::get_instance(GLSL_TYPE_BOOL, vec_elem, 1);
 625
 626    /* Double-precision floating-point values are stored as
 627     *   1 sign bit;
 628     *   11 exponent bits;
 629     *   52 mantissa bits.
 630     *
 631     * We're just extracting the significand here, so we only need to modify
 632     * the upper 32-bit uint. Unfortunately we must extract each double
 633     * independently as there is no vector version of unpackDouble.
 634     */
 635
 636    ir_instruction &i = *base_ir;
 637
 638    ir_variable *is_not_zero =
 639       new(ir) ir_variable(bvec, "is_not_zero", ir_var_temporary);
 640    ir_rvalue *results[4] = {NULL};
 641
 642    ir_constant *dzero = new(ir) ir_constant(0.0, vec_elem);
 643    i.insert_before(is_not_zero);
 644    i.insert_before(
 645          assign(is_not_zero,
 646                 nequal(abs(ir->operands[0]->clone(ir, NULL)), dzero)));
 647
 648    /* TODO: Remake this as more vector-friendly when int64 support is
 649     * available.
 650     */
 651    for (unsigned elem = 0; elem < vec_elem; elem++) {
 652       ir_constant *zero = new(ir) ir_constant(0u, 1);
 653       ir_constant *sign_mantissa_mask = new(ir) ir_constant(0x800fffffu, 1);
 654
 655       /* Exponent of double floating-point values in the range [0.5, 1.0). */
 656       ir_constant *exponent_value = new(ir) ir_constant(0x3fe00000u, 1);
 657
 658       ir_variable *bits =
 659          new(ir) ir_variable(glsl_type::uint_type, "bits", ir_var_temporary);
 660       ir_variable *unpacked =
 661          new(ir) ir_variable(glsl_type::uvec2_type, "unpacked", ir_var_temporary);
 662
 663       ir_rvalue *x = swizzle(ir->operands[0]->clone(ir, NULL), elem, 1);
 664
 665       i.insert_before(bits);
 666       i.insert_before(unpacked);
 667       i.insert_before(assign(unpacked, expr(ir_unop_unpack_double_2x32, x)));
 668
 669       /* Manipulate the high uint to remove the exponent and replace it with
 670        * either the default exponent or zero.
 671        */
 672       i.insert_before(assign(bits, swizzle_y(unpacked)));
 673       i.insert_before(assign(bits, bit_and(bits, sign_mantissa_mask)));
 674       i.insert_before(assign(bits, bit_or(bits,
 675                                           csel(swizzle(is_not_zero, elem, 1),
 676                                                exponent_value,
 677                                                zero))));
 678       i.insert_before(assign(unpacked, bits, WRITEMASK_Y));
 679       results[elem] = expr(ir_unop_pack_double_2x32, unpacked);
 680    }
 681
 682    /* Put the dvec back together */
 683    ir->operation = ir_quadop_vector;
 684    ir->init_num_operands();
 685    ir->operands[0] = results[0];
 686    ir->operands[1] = results[1];
 687    ir->operands[2] = results[2];
 688    ir->operands[3] = results[3];
 689
 690    this->progress = true;
 691 }
 692
 693 void
 694 lower_instructions_visitor::dfrexp_exp_to_arith(ir_expression *ir)
 695 {
 696    const unsigned vec_elem = ir->type->vector_elements;
 697    const glsl_type *bvec = glsl_type::get_instance(GLSL_TYPE_BOOL, vec_elem, 1);
 698    const glsl_type *uvec = glsl_type::get_instance(GLSL_TYPE_UINT, vec_elem, 1);
 699
 700    /* Double-precision floating-point values are stored as
 701     *   1 sign bit;
 702     *   11 exponent bits;
 703     *   52 mantissa bits.
 704     *
 705     * We're just extracting the exponent here, so we only care about the upper
 706     * 32-bit uint.
 707     */
 708
 709    ir_instruction &i = *base_ir;
 710
 711    ir_variable *is_not_zero =
 712       new(ir) ir_variable(bvec, "is_not_zero", ir_var_temporary);
 713    ir_variable *high_words =
 714       new(ir) ir_variable(uvec, "high_words", ir_var_temporary);
 715    ir_constant *dzero = new(ir) ir_constant(0.0, vec_elem);
 716    ir_constant *izero = new(ir) ir_constant(0, vec_elem);
 717
 718    ir_rvalue *absval = abs(ir->operands[0]);
 719
 720    i.insert_before(is_not_zero);
 721    i.insert_before(high_words);
 722    i.insert_before(assign(is_not_zero, nequal(absval->clone(ir, NULL), dzero)));
 723
 724    /* Extract all of the upper uints. */
 725    for (unsigned elem = 0; elem < vec_elem; elem++) {
 726       ir_rvalue *x = swizzle(absval->clone(ir, NULL), elem, 1);
 727
 728       i.insert_before(assign(high_words,
 729                              swizzle_y(expr(ir_unop_unpack_double_2x32, x)),
 730                              1 << elem));
 731
 732    }
 733    ir_constant *exponent_shift = new(ir) ir_constant(20, vec_elem);
 734    ir_constant *exponent_bias = new(ir) ir_constant(-1022, vec_elem);
 735
 736    /* For non-zero inputs, shift the exponent down and apply bias. */
 737    ir->operation = ir_triop_csel;
 738    ir->init_num_operands();
 739    ir->operands[0] = new(ir) ir_dereference_variable(is_not_zero);
 740    ir->operands[1] = add(exponent_bias, u2i(rshift(high_words, exponent_shift)));
 741    ir->operands[2] = izero;
 742
 743    this->progress = true;
 744 }
 745
 746 void
 747 lower_instructions_visitor::carry_to_arith(ir_expression *ir)
 748 {
 749    /* Translates
 750     *   ir_binop_carry x y
 751     * into
 752     *   sum = ir_binop_add x y
 753     *   bcarry = ir_binop_less sum x
 754     *   carry = ir_unop_b2i bcarry
 755     */
 756
 757    ir_rvalue *x_clone = ir->operands[0]->clone(ir, NULL);
 758    ir->operation = ir_unop_i2u;
 759    ir->init_num_operands();
 760    ir->operands[0] = b2i(less(add(ir->operands[0], ir->operands[1]), x_clone));
 761    ir->operands[1] = NULL;
 762
 763    this->progress = true;
 764 }
 765
 766 void
 767 lower_instructions_visitor::borrow_to_arith(ir_expression *ir)
 768 {
 769    /* Translates
 770     *   ir_binop_borrow x y
 771     * into
 772     *   bcarry = ir_binop_less x y
 773     *   carry = ir_unop_b2i bcarry
 774     */
 775
 776    ir->operation = ir_unop_i2u;
 777    ir->init_num_operands();
 778    ir->operands[0] = b2i(less(ir->operands[0], ir->operands[1]));
 779    ir->operands[1] = NULL;
 780
 781    this->progress = true;
 782 }
 783
 784 void
 785 lower_instructions_visitor::sat_to_clamp(ir_expression *ir)
 786 {
 787    /* Translates
 788     *   ir_unop_saturate x
 789     * into
 790     *   ir_binop_min (ir_binop_max(x, 0.0), 1.0)
 791     */
 792
 793    ir->operation = ir_binop_min;
 794    ir->init_num_operands();
 795    ir->operands[0] = new(ir) ir_expression(ir_binop_max, ir->operands[0]->type,
 796                                            ir->operands[0],
 797                                            new(ir) ir_constant(0.0f));
 798    ir->operands[1] = new(ir) ir_constant(1.0f);
 799
 800    this->progress = true;
 801 }
 802
 803 void
 804 lower_instructions_visitor::double_dot_to_fma(ir_expression *ir)
 805 {
 806    ir_variable *temp = new(ir) ir_variable(ir->operands[0]->type->get_base_type(), "dot_res",
 807                                            ir_var_temporary);
 808    this->base_ir->insert_before(temp);
 809
 810    int nc = ir->operands[0]->type->components();
 811    for (int i = nc - 1; i >= 1; i--) {
 812       ir_assignment *assig;
 813       if (i == (nc - 1)) {
 814          assig = assign(temp, mul(swizzle(ir->operands[0]->clone(ir, NULL), i, 1),
 815                                   swizzle(ir->operands[1]->clone(ir, NULL), i, 1)));
 816       } else {
 817          assig = assign(temp, fma(swizzle(ir->operands[0]->clone(ir, NULL), i, 1),
 818                                   swizzle(ir->operands[1]->clone(ir, NULL), i, 1),
 819                                   temp));
 820       }
 821       this->base_ir->insert_before(assig);
 822    }
 823
 824    ir->operation = ir_triop_fma;
 825    ir->init_num_operands();
 826    ir->operands[0] = swizzle(ir->operands[0], 0, 1);
 827    ir->operands[1] = swizzle(ir->operands[1], 0, 1);
 828    ir->operands[2] = new(ir) ir_dereference_variable(temp);
 829
 830    this->progress = true;
 831
 832 }
 833
 834 void
 835 lower_instructions_visitor::double_lrp(ir_expression *ir)
 836 {
 837    int swizval;
 838    ir_rvalue *op0 = ir->operands[0], *op2 = ir->operands[2];
 839    ir_constant *one = new(ir) ir_constant(1.0, op2->type->vector_elements);
 840
 841    switch (op2->type->vector_elements) {
 842    case 1:
 843       swizval = SWIZZLE_XXXX;
 844       break;
 845    default:
 846       assert(op0->type->vector_elements == op2->type->vector_elements);
 847       swizval = SWIZZLE_XYZW;
 848       break;
 849    }
 850
 851    ir->operation = ir_triop_fma;
 852    ir->init_num_operands();
 853    ir->operands[0] = swizzle(op2, swizval, op0->type->vector_elements);
 854    ir->operands[2] = mul(sub(one, op2->clone(ir, NULL)), op0);
 855
 856    this->progress = true;
 857 }
 858
 859 void
 860 lower_instructions_visitor::dceil_to_dfrac(ir_expression *ir)
 861 {
 862    /*
 863     * frtemp = frac(x);
 864     * temp = sub(x, frtemp);
 865     * result = temp + ((frtemp != 0.0) ? 1.0 : 0.0);
 866     */
 867    ir_instruction &i = *base_ir;
 868    ir_constant *zero = new(ir) ir_constant(0.0, ir->operands[0]->type->vector_elements);
 869    ir_constant *one = new(ir) ir_constant(1.0, ir->operands[0]->type->vector_elements);
 870    ir_variable *frtemp = new(ir) ir_variable(ir->operands[0]->type, "frtemp",
 871                                              ir_var_temporary);
 872
 873    i.insert_before(frtemp);
 874    i.insert_before(assign(frtemp, fract(ir->operands[0])));
 875
 876    ir->operation = ir_binop_add;
 877    ir->init_num_operands();
 878    ir->operands[0] = sub(ir->operands[0]->clone(ir, NULL), frtemp);
 879    ir->operands[1] = csel(nequal(frtemp, zero), one, zero->clone(ir, NULL));
 880
 881    this->progress = true;
 882 }
 883
 884 void
 885 lower_instructions_visitor::dfloor_to_dfrac(ir_expression *ir)
 886 {
 887    /*
 888     * frtemp = frac(x);
 889     * result = sub(x, frtemp);
 890     */
 891    ir->operation = ir_binop_sub;
 892    ir->init_num_operands();
 893    ir->operands[1] = fract(ir->operands[0]->clone(ir, NULL));
 894
 895    this->progress = true;
 896 }
 897 void
 898 lower_instructions_visitor::dround_even_to_dfrac(ir_expression *ir)
 899 {
 900    /*
 901     * insane but works
 902     * temp = x + 0.5;
 903     * frtemp = frac(temp);
 904     * t2 = sub(temp, frtemp);
 905     * if (frac(x) == 0.5)
 906     *     result = frac(t2 * 0.5) == 0 ? t2 : t2 - 1;
 907     *  else
 908     *     result = t2;
 909
 910     */
 911    ir_instruction &i = *base_ir;
 912    ir_variable *frtemp = new(ir) ir_variable(ir->operands[0]->type, "frtemp",
 913                                              ir_var_temporary);
 914    ir_variable *temp = new(ir) ir_variable(ir->operands[0]->type, "temp",
 915                                            ir_var_temporary);
 916    ir_variable *t2 = new(ir) ir_variable(ir->operands[0]->type, "t2",
 917                                            ir_var_temporary);
 918    ir_constant *p5 = new(ir) ir_constant(0.5, ir->operands[0]->type->vector_elements);
 919    ir_constant *one = new(ir) ir_constant(1.0, ir->operands[0]->type->vector_elements);
 920    ir_constant *zero = new(ir) ir_constant(0.0, ir->operands[0]->type->vector_elements);
 921
 922    i.insert_before(temp);
 923    i.insert_before(assign(temp, add(ir->operands[0], p5)));
 924
 925    i.insert_before(frtemp);
 926    i.insert_before(assign(frtemp, fract(temp)));
 927
 928    i.insert_before(t2);
 929    i.insert_before(assign(t2, sub(temp, frtemp)));
 930
 931    ir->operation = ir_triop_csel;
 932    ir->init_num_operands();
 933    ir->operands[0] = equal(fract(ir->operands[0]->clone(ir, NULL)),
 934                            p5->clone(ir, NULL));
 935    ir->operands[1] = csel(equal(fract(mul(t2, p5->clone(ir, NULL))),
 936                                 zero),
 937                           t2,
 938                           sub(t2, one));
 939    ir->operands[2] = new(ir) ir_dereference_variable(t2);
 940
 941    this->progress = true;
 942 }
 943
 944 void
 945 lower_instructions_visitor::dtrunc_to_dfrac(ir_expression *ir)
 946 {
 947    /*
 948     * frtemp = frac(x);
 949     * temp = sub(x, frtemp);
 950     * result = x >= 0 ? temp : temp + (frtemp == 0.0) ? 0 : 1;
 951     */
 952    ir_rvalue *arg = ir->operands[0];
 953    ir_instruction &i = *base_ir;
 954
 955    ir_constant *zero = new(ir) ir_constant(0.0, arg->type->vector_elements);
 956    ir_constant *one = new(ir) ir_constant(1.0, arg->type->vector_elements);
 957    ir_variable *frtemp = new(ir) ir_variable(arg->type, "frtemp",
 958                                              ir_var_temporary);
 959    ir_variable *temp = new(ir) ir_variable(ir->operands[0]->type, "temp",
 960                                            ir_var_temporary);
 961
 962    i.insert_before(frtemp);
 963    i.insert_before(assign(frtemp, fract(arg)));
 964    i.insert_before(temp);
 965    i.insert_before(assign(temp, sub(arg->clone(ir, NULL), frtemp)));
 966
 967    ir->operation = ir_triop_csel;
 968    ir->init_num_operands();
 969    ir->operands[0] = gequal(arg->clone(ir, NULL), zero);
 970    ir->operands[1] = new (ir) ir_dereference_variable(temp);
 971    ir->operands[2] = add(temp,
 972                          csel(equal(frtemp, zero->clone(ir, NULL)),
 973                               zero->clone(ir, NULL),
 974                               one));
 975
 976    this->progress = true;
 977 }
 978
 979 void
 980 lower_instructions_visitor::dsign_to_csel(ir_expression *ir)
 981 {
 982    /*
 983     * temp = x > 0.0 ? 1.0 : 0.0;
 984     * result = x < 0.0 ? -1.0 : temp;
 985     */
 986    ir_rvalue *arg = ir->operands[0];
 987    ir_constant *zero = new(ir) ir_constant(0.0, arg->type->vector_elements);
 988    ir_constant *one = new(ir) ir_constant(1.0, arg->type->vector_elements);
 989    ir_constant *neg_one = new(ir) ir_constant(-1.0, arg->type->vector_elements);
 990
 991    ir->operation = ir_triop_csel;
 992    ir->init_num_operands();
 993    ir->operands[0] = less(arg->clone(ir, NULL),
 994                           zero->clone(ir, NULL));
 995    ir->operands[1] = neg_one;
 996    ir->operands[2] = csel(greater(arg, zero),
 997                           one,
 998                           zero->clone(ir, NULL));
 999
1000    this->progress = true;
1001 }
1002
1003 void
1004 lower_instructions_visitor::bit_count_to_math(ir_expression *ir)
1005 {
1006    /* For more details, see:
1007     *
1008     * http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetPaallel
1009     */
1010    const unsigned elements = ir->operands[0]->type->vector_elements;
1011    ir_variable *temp = new(ir) ir_variable(glsl_type::uvec(elements), "temp",
1012                                            ir_var_temporary);
1013    ir_constant *c55555555 = new(ir) ir_constant(0x55555555u);
1014    ir_constant *c33333333 = new(ir) ir_constant(0x33333333u);
1015    ir_constant *c0F0F0F0F = new(ir) ir_constant(0x0F0F0F0Fu);
1016    ir_constant *c01010101 = new(ir) ir_constant(0x01010101u);
1017    ir_constant *c1 = new(ir) ir_constant(1u);
1018    ir_constant *c2 = new(ir) ir_constant(2u);
1019    ir_constant *c4 = new(ir) ir_constant(4u);
1020    ir_constant *c24 = new(ir) ir_constant(24u);
1021
1022    base_ir->insert_before(temp);
1023
1024    if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
1025       base_ir->insert_before(assign(temp, ir->operands[0]));
1026    } else {
1027       assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
1028       base_ir->insert_before(assign(temp, i2u(ir->operands[0])));
1029    }
1030
1031    /* temp = temp - ((temp >> 1) & 0x55555555u); */
1032    base_ir->insert_before(assign(temp, sub(temp, bit_and(rshift(temp, c1),
1033                                                          c55555555))));
1034
1035    /* temp = (temp & 0x33333333u) + ((temp >> 2) & 0x33333333u); */
1036    base_ir->insert_before(assign(temp, add(bit_and(temp, c33333333),
1037                                            bit_and(rshift(temp, c2),
1038                                                    c33333333->clone(ir, NULL)))));
1039
1040    /* int(((temp + (temp >> 4) & 0xF0F0F0Fu) * 0x1010101u) >> 24); */
1041    ir->operation = ir_unop_u2i;
1042    ir->init_num_operands();
1043    ir->operands[0] = rshift(mul(bit_and(add(temp, rshift(temp, c4)), c0F0F0F0F),
1044                                 c01010101),
1045                             c24);
1046
1047    this->progress = true;
1048 }
1049
1050 void
1051 lower_instructions_visitor::extract_to_shifts(ir_expression *ir)
1052 {
1053    ir_variable *bits =
1054       new(ir) ir_variable(ir->operands[0]->type, "bits", ir_var_temporary);
1055
1056    base_ir->insert_before(bits);
1057    base_ir->insert_before(assign(bits, ir->operands[2]));
1058
1059    if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
1060       ir_constant *c1 =
1061          new(ir) ir_constant(1u, ir->operands[0]->type->vector_elements);
1062       ir_constant *c32 =
1063          new(ir) ir_constant(32u, ir->operands[0]->type->vector_elements);
1064       ir_constant *cFFFFFFFF =
1065          new(ir) ir_constant(0xFFFFFFFFu, ir->operands[0]->type->vector_elements);
1066
1067       /* At least some hardware treats (x << y) as (x << (y%32)).  This means
1068        * we'd get a mask of 0 when bits is 32.  Special case it.
1069        *
1070        * mask = bits == 32 ? 0xffffffff : (1u << bits) - 1u;
1071        */
1072       ir_expression *mask = csel(equal(bits, c32),
1073                                  cFFFFFFFF,
1074                                  sub(lshift(c1, bits), c1->clone(ir, NULL)));
1075
1076       /* Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
1077        *
1078        *    If bits is zero, the result will be zero.
1079        *
1080        * Since (1 << 0) - 1 == 0, we don't need to bother with the conditional
1081        * select as in the signed integer case.
1082        *
1083        * (value >> offset) & mask;
1084        */
1085       ir->operation = ir_binop_bit_and;
1086       ir->init_num_operands();
1087       ir->operands[0] = rshift(ir->operands[0], ir->operands[1]);
1088       ir->operands[1] = mask;
1089       ir->operands[2] = NULL;
1090    } else {
1091       ir_constant *c0 =
1092          new(ir) ir_constant(int(0), ir->operands[0]->type->vector_elements);
1093       ir_constant *c32 =
1094          new(ir) ir_constant(int(32), ir->operands[0]->type->vector_elements);
1095       ir_variable *temp =
1096          new(ir) ir_variable(ir->operands[0]->type, "temp", ir_var_temporary);
1097
1098       /* temp = 32 - bits; */
1099       base_ir->insert_before(temp);
1100       base_ir->insert_before(assign(temp, sub(c32, bits)));
1101
1102       /* expr = value << (temp - offset)) >> temp; */
1103       ir_expression *expr =
1104          rshift(lshift(ir->operands[0], sub(temp, ir->operands[1])), temp);
1105
1106       /* Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
1107        *
1108        *    If bits is zero, the result will be zero.
1109        *
1110        * Due to the (x << (y%32)) behavior mentioned before, the (value <<
1111        * (32-0)) doesn't "erase" all of the data as we would like, so finish
1112        * up with:
1113        *
1114        * (bits == 0) ? 0 : e;
1115        */
1116       ir->operation = ir_triop_csel;
1117       ir->init_num_operands();
1118       ir->operands[0] = equal(c0, bits);
1119       ir->operands[1] = c0->clone(ir, NULL);
1120       ir->operands[2] = expr;
1121    }
1122
1123    this->progress = true;
1124 }
1125
1126 void
1127 lower_instructions_visitor::insert_to_shifts(ir_expression *ir)
1128 {
1129    ir_constant *c1;
1130    ir_constant *c32;
1131    ir_constant *cFFFFFFFF;
1132    ir_variable *offset =
1133       new(ir) ir_variable(ir->operands[0]->type, "offset", ir_var_temporary);
1134    ir_variable *bits =
1135       new(ir) ir_variable(ir->operands[0]->type, "bits", ir_var_temporary);
1136    ir_variable *mask =
1137       new(ir) ir_variable(ir->operands[0]->type, "mask", ir_var_temporary);
1138
1139    if (ir->operands[0]->type->base_type == GLSL_TYPE_INT) {
1140       c1 = new(ir) ir_constant(int(1), ir->operands[0]->type->vector_elements);
1141       c32 = new(ir) ir_constant(int(32), ir->operands[0]->type->vector_elements);
1142       cFFFFFFFF = new(ir) ir_constant(int(0xFFFFFFFF), ir->operands[0]->type->vector_elements);
1143    } else {
1144       assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
1145
1146       c1 = new(ir) ir_constant(1u, ir->operands[0]->type->vector_elements);
1147       c32 = new(ir) ir_constant(32u, ir->operands[0]->type->vector_elements);
1148       cFFFFFFFF = new(ir) ir_constant(0xFFFFFFFFu, ir->operands[0]->type->vector_elements);
1149    }
1150
1151    base_ir->insert_before(offset);
1152    base_ir->insert_before(assign(offset, ir->operands[2]));
1153
1154    base_ir->insert_before(bits);
1155    base_ir->insert_before(assign(bits, ir->operands[3]));
1156
1157    /* At least some hardware treats (x << y) as (x << (y%32)).  This means
1158     * we'd get a mask of 0 when bits is 32.  Special case it.
1159     *
1160     * mask = (bits == 32 ? 0xffffffff : (1u << bits) - 1u) << offset;
1161     *
1162     * Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
1163     *
1164     *    The result will be undefined if offset or bits is negative, or if the
1165     *    sum of offset and bits is greater than the number of bits used to
1166     *    store the operand.
1167     *
1168     * Since it's undefined, there are a couple other ways this could be
1169     * implemented.  The other way that was considered was to put the csel
1170     * around the whole thing:
1171     *
1172     *    final_result = bits == 32 ? insert : ... ;
1173     */
1174    base_ir->insert_before(mask);
1175
1176    base_ir->insert_before(assign(mask, csel(equal(bits, c32),
1177                                             cFFFFFFFF,
1178                                             lshift(sub(lshift(c1, bits),
1179                                                        c1->clone(ir, NULL)),
1180                                                    offset))));
1181
1182    /* (base & ~mask) | ((insert << offset) & mask) */
1183    ir->operation = ir_binop_bit_or;
1184    ir->init_num_operands();
1185    ir->operands[0] = bit_and(ir->operands[0], bit_not(mask));
1186    ir->operands[1] = bit_and(lshift(ir->operands[1], offset), mask);
1187    ir->operands[2] = NULL;
1188    ir->operands[3] = NULL;
1189
1190    this->progress = true;
1191 }
1192
1193 void
1194 lower_instructions_visitor::reverse_to_shifts(ir_expression *ir)
1195 {
1196    /* For more details, see:
1197     *
1198     * http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
1199     */
1200    ir_constant *c1 =
1201       new(ir) ir_constant(1u, ir->operands[0]->type->vector_elements);
1202    ir_constant *c2 =
1203       new(ir) ir_constant(2u, ir->operands[0]->type->vector_elements);
1204    ir_constant *c4 =
1205       new(ir) ir_constant(4u, ir->operands[0]->type->vector_elements);
1206    ir_constant *c8 =
1207       new(ir) ir_constant(8u, ir->operands[0]->type->vector_elements);
1208    ir_constant *c16 =
1209       new(ir) ir_constant(16u, ir->operands[0]->type->vector_elements);
1210    ir_constant *c33333333 =
1211       new(ir) ir_constant(0x33333333u, ir->operands[0]->type->vector_elements);
1212    ir_constant *c55555555 =
1213       new(ir) ir_constant(0x55555555u, ir->operands[0]->type->vector_elements);
1214    ir_constant *c0F0F0F0F =
1215       new(ir) ir_constant(0x0F0F0F0Fu, ir->operands[0]->type->vector_elements);
1216    ir_constant *c00FF00FF =
1217       new(ir) ir_constant(0x00FF00FFu, ir->operands[0]->type->vector_elements);
1218    ir_variable *temp =
1219       new(ir) ir_variable(glsl_type::uvec(ir->operands[0]->type->vector_elements),
1220                           "temp", ir_var_temporary);
1221    ir_instruction &i = *base_ir;
1222
1223    i.insert_before(temp);
1224
1225    if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
1226       i.insert_before(assign(temp, ir->operands[0]));
1227    } else {
1228       assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
1229       i.insert_before(assign(temp, i2u(ir->operands[0])));
1230    }
1231
1232    /* Swap odd and even bits.
1233     *
1234     * temp = ((temp >> 1) & 0x55555555u) | ((temp & 0x55555555u) << 1);
1235     */
1236    i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c1), c55555555),
1237                                        lshift(bit_and(temp, c55555555->clone(ir, NULL)),
1238                                               c1->clone(ir, NULL)))));
1239    /* Swap consecutive pairs.
1240     *
1241     * temp = ((temp >> 2) & 0x33333333u) | ((temp & 0x33333333u) << 2);
1242     */
1243    i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c2), c33333333),
1244                                        lshift(bit_and(temp, c33333333->clone(ir, NULL)),
1245                                               c2->clone(ir, NULL)))));
1246
1247    /* Swap nibbles.
1248     *
1249     * temp = ((temp >> 4) & 0x0F0F0F0Fu) | ((temp & 0x0F0F0F0Fu) << 4);
1250     */
1251    i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c4), c0F0F0F0F),
1252                                        lshift(bit_and(temp, c0F0F0F0F->clone(ir, NULL)),
1253                                               c4->clone(ir, NULL)))));
1254
1255    /* The last step is, basically, bswap.  Swap the bytes, then swap the
1256     * words.  When this code is run through GCC on x86, it does generate a
1257     * bswap instruction.
1258     *
1259     * temp = ((temp >> 8) & 0x00FF00FFu) | ((temp & 0x00FF00FFu) << 8);
1260     * temp = ( temp >> 16              ) | ( temp                << 16);
1261     */
1262    i.insert_before(assign(temp, bit_or(bit_and(rshift(temp, c8), c00FF00FF),
1263                                        lshift(bit_and(temp, c00FF00FF->clone(ir, NULL)),
1264                                               c8->clone(ir, NULL)))));
1265
1266    if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
1267       ir->operation = ir_binop_bit_or;
1268       ir->init_num_operands();
1269       ir->operands[0] = rshift(temp, c16);
1270       ir->operands[1] = lshift(temp, c16->clone(ir, NULL));
1271    } else {
1272       ir->operation = ir_unop_u2i;
1273       ir->init_num_operands();
1274       ir->operands[0] = bit_or(rshift(temp, c16),
1275                                lshift(temp, c16->clone(ir, NULL)));
1276    }
1277
1278    this->progress = true;
1279 }
1280
1281 void
1282 lower_instructions_visitor::find_lsb_to_float_cast(ir_expression *ir)
1283 {
1284    /* For more details, see:
1285     *
1286     * http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightFloatCast
1287     */
1288    const unsigned elements = ir->operands[0]->type->vector_elements;
1289    ir_constant *c0 = new(ir) ir_constant(unsigned(0), elements);
1290    ir_constant *cminus1 = new(ir) ir_constant(int(-1), elements);
1291    ir_constant *c23 = new(ir) ir_constant(int(23), elements);
1292    ir_constant *c7F = new(ir) ir_constant(int(0x7F), elements);
1293    ir_variable *temp =
1294       new(ir) ir_variable(glsl_type::ivec(elements), "temp", ir_var_temporary);
1295    ir_variable *lsb_only =
1296       new(ir) ir_variable(glsl_type::uvec(elements), "lsb_only", ir_var_temporary);
1297    ir_variable *as_float =
1298       new(ir) ir_variable(glsl_type::vec(elements), "as_float", ir_var_temporary);
1299    ir_variable *lsb =
1300       new(ir) ir_variable(glsl_type::ivec(elements), "lsb", ir_var_temporary);
1301
1302    ir_instruction &i = *base_ir;
1303
1304    i.insert_before(temp);
1305
1306    if (ir->operands[0]->type->base_type == GLSL_TYPE_INT) {
1307       i.insert_before(assign(temp, ir->operands[0]));
1308    } else {
1309       assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
1310       i.insert_before(assign(temp, u2i(ir->operands[0])));
1311    }
1312
1313    /* The int-to-float conversion is lossless because (value & -value) is
1314     * either a power of two or zero.  We don't use the result in the zero
1315     * case.  The uint() cast is necessary so that 0x80000000 does not
1316     * generate a negative value.
1317     *
1318     * uint lsb_only = uint(value & -value);
1319     * float as_float = float(lsb_only);
1320     */
1321    i.insert_before(lsb_only);
1322    i.insert_before(assign(lsb_only, i2u(bit_and(temp, neg(temp)))));
1323
1324    i.insert_before(as_float);
1325    i.insert_before(assign(as_float, u2f(lsb_only)));
1326
1327    /* This is basically an open-coded frexp.  Implementations that have a
1328     * native frexp instruction would be better served by that.  This is
1329     * optimized versus a full-featured open-coded implementation in two ways:
1330     *
1331     * - We don't care about a correct result from subnormal numbers (including
1332     *   0.0), so the raw exponent can always be safely unbiased.
1333     *
1334     * - The value cannot be negative, so it does not need to be masked off to
1335     *   extract the exponent.
1336     *
1337     * int lsb = (floatBitsToInt(as_float) >> 23) - 0x7f;
1338     */
1339    i.insert_before(lsb);
1340    i.insert_before(assign(lsb, sub(rshift(bitcast_f2i(as_float), c23), c7F)));
1341
1342    /* Use lsb_only in the comparison instead of temp so that the & (far above)
1343     * can possibly generate the result without an explicit comparison.
1344     *
1345     * (lsb_only == 0) ? -1 : lsb;
1346     *
1347     * Since our input values are all integers, the unbiased exponent must not
1348     * be negative.  It will only be negative (-0x7f, in fact) if lsb_only is
1349     * 0.  Instead of using (lsb_only == 0), we could use (lsb >= 0).  Which is
1350     * better is likely GPU dependent.  Either way, the difference should be
1351     * small.
1352     */
1353    ir->operation = ir_triop_csel;
1354    ir->init_num_operands();
1355    ir->operands[0] = equal(lsb_only, c0);
1356    ir->operands[1] = cminus1;
1357    ir->operands[2] = new(ir) ir_dereference_variable(lsb);
1358
1359    this->progress = true;
1360 }
1361
1362 void
1363 lower_instructions_visitor::find_msb_to_float_cast(ir_expression *ir)
1364 {
1365    /* For more details, see:
1366     *
1367     * http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightFloatCast
1368     */
1369    const unsigned elements = ir->operands[0]->type->vector_elements;
1370    ir_constant *c0 = new(ir) ir_constant(int(0), elements);
1371    ir_constant *cminus1 = new(ir) ir_constant(int(-1), elements);
1372    ir_constant *c23 = new(ir) ir_constant(int(23), elements);
1373    ir_constant *c7F = new(ir) ir_constant(int(0x7F), elements);
1374    ir_constant *c000000FF = new(ir) ir_constant(0x000000FFu, elements);
1375    ir_constant *cFFFFFF00 = new(ir) ir_constant(0xFFFFFF00u, elements);
1376    ir_variable *temp =
1377       new(ir) ir_variable(glsl_type::uvec(elements), "temp", ir_var_temporary);
1378    ir_variable *as_float =
1379       new(ir) ir_variable(glsl_type::vec(elements), "as_float", ir_var_temporary);
1380    ir_variable *msb =
1381       new(ir) ir_variable(glsl_type::ivec(elements), "msb", ir_var_temporary);
1382
1383    ir_instruction &i = *base_ir;
1384
1385    i.insert_before(temp);
1386
1387    if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
1388       i.insert_before(assign(temp, ir->operands[0]));
1389    } else {
1390       assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
1391
1392       /* findMSB(uint(abs(some_int))) almost always does the right thing.
1393        * There are two problem values:
1394        *
1395        * * 0x80000000.  Since abs(0x80000000) == 0x80000000, findMSB returns
1396        *   31.  However, findMSB(int(0x80000000)) == 30.
1397        *
1398        * * 0xffffffff.  Since abs(0xffffffff) == 1, findMSB returns
1399        *   31.  Section 8.8 (Integer Functions) of the GLSL 4.50 spec says:
1400        *
1401        *    For a value of zero or negative one, -1 will be returned.
1402        *
1403        * For all negative number cases, including 0x80000000 and 0xffffffff,
1404        * the correct value is obtained from findMSB if instead of negating the
1405        * (already negative) value the logical-not is used.  A conditonal
1406        * logical-not can be achieved in two instructions.
1407        */
1408       ir_variable *as_int =
1409          new(ir) ir_variable(glsl_type::ivec(elements), "as_int", ir_var_temporary);
1410       ir_constant *c31 = new(ir) ir_constant(int(31), elements);
1411
1412       i.insert_before(as_int);
1413       i.insert_before(assign(as_int, ir->operands[0]));
1414       i.insert_before(assign(temp, i2u(expr(ir_binop_bit_xor,
1415                                             as_int,
1416                                             rshift(as_int, c31)))));
1417    }
1418
1419    /* The int-to-float conversion is lossless because bits are conditionally
1420     * masked off the bottom of temp to ensure the value has at most 24 bits of
1421     * data or is zero.  We don't use the result in the zero case.  The uint()
1422     * cast is necessary so that 0x80000000 does not generate a negative value.
1423     *
1424     * float as_float = float(temp > 255 ? temp & ~255 : temp);
1425     */
1426    i.insert_before(as_float);
1427    i.insert_before(assign(as_float, u2f(csel(greater(temp, c000000FF),
1428                                              bit_and(temp, cFFFFFF00),
1429                                              temp))));
1430
1431    /* This is basically an open-coded frexp.  Implementations that have a
1432     * native frexp instruction would be better served by that.  This is
1433     * optimized versus a full-featured open-coded implementation in two ways:
1434     *
1435     * - We don't care about a correct result from subnormal numbers (including
1436     *   0.0), so the raw exponent can always be safely unbiased.
1437     *
1438     * - The value cannot be negative, so it does not need to be masked off to
1439     *   extract the exponent.
1440     *
1441     * int msb = (floatBitsToInt(as_float) >> 23) - 0x7f;
1442     */
1443    i.insert_before(msb);
1444    i.insert_before(assign(msb, sub(rshift(bitcast_f2i(as_float), c23), c7F)));
1445
1446    /* Use msb in the comparison instead of temp so that the subtract can
1447     * possibly generate the result without an explicit comparison.
1448     *
1449     * (msb < 0) ? -1 : msb;
1450     *
1451     * Since our input values are all integers, the unbiased exponent must not
1452     * be negative.  It will only be negative (-0x7f, in fact) if temp is 0.
1453     */
1454    ir->operation = ir_triop_csel;
1455    ir->init_num_operands();
1456    ir->operands[0] = less(msb, c0);
1457    ir->operands[1] = cminus1;
1458    ir->operands[2] = new(ir) ir_dereference_variable(msb);
1459
1460    this->progress = true;
1461 }
1462
1463 ir_expression *
1464 lower_instructions_visitor::_carry(operand a, operand b)
1465 {
1466    if (lowering(CARRY_TO_ARITH))
1467       return i2u(b2i(less(add(a, b),
1468                           a.val->clone(ralloc_parent(a.val), NULL))));
1469    else
1470       return carry(a, b);
1471 }
1472
1473 void
1474 lower_instructions_visitor::imul_high_to_mul(ir_expression *ir)
1475 {
1476    /*   ABCD
1477     * * EFGH
1478     * ======
1479     * (GH * CD) + (GH * AB) << 16 + (EF * CD) << 16 + (EF * AB) << 32
1480     *
1481     * In GLSL, (a * b) becomes
1482     *
1483     * uint m1 = (a & 0x0000ffffu) * (b & 0x0000ffffu);
1484     * uint m2 = (a & 0x0000ffffu) * (b >> 16);
1485     * uint m3 = (a >> 16)         * (b & 0x0000ffffu);
1486     * uint m4 = (a >> 16)         * (b >> 16);
1487     *
1488     * uint c1;
1489     * uint c2;
1490     * uint lo_result;
1491     * uint hi_result;
1492     *
1493     * lo_result = uaddCarry(m1, m2 << 16, c1);
1494     * hi_result = m4 + c1;
1495     * lo_result = uaddCarry(lo_result, m3 << 16, c2);
1496     * hi_result = hi_result + c2;
1497     * hi_result = hi_result + (m2 >> 16) + (m3 >> 16);
1498     */
1499    const unsigned elements = ir->operands[0]->type->vector_elements;
1500    ir_variable *src1 =
1501       new(ir) ir_variable(glsl_type::uvec(elements), "src1", ir_var_temporary);
1502    ir_variable *src1h =
1503       new(ir) ir_variable(glsl_type::uvec(elements), "src1h", ir_var_temporary);
1504    ir_variable *src1l =
1505       new(ir) ir_variable(glsl_type::uvec(elements), "src1l", ir_var_temporary);
1506    ir_variable *src2 =
1507       new(ir) ir_variable(glsl_type::uvec(elements), "src2", ir_var_temporary);
1508    ir_variable *src2h =
1509       new(ir) ir_variable(glsl_type::uvec(elements), "src2h", ir_var_temporary);
1510    ir_variable *src2l =
1511       new(ir) ir_variable(glsl_type::uvec(elements), "src2l", ir_var_temporary);
1512    ir_variable *t1 =
1513       new(ir) ir_variable(glsl_type::uvec(elements), "t1", ir_var_temporary);
1514    ir_variable *t2 =
1515       new(ir) ir_variable(glsl_type::uvec(elements), "t2", ir_var_temporary);
1516    ir_variable *lo =
1517       new(ir) ir_variable(glsl_type::uvec(elements), "lo", ir_var_temporary);
1518    ir_variable *hi =
1519       new(ir) ir_variable(glsl_type::uvec(elements), "hi", ir_var_temporary);
1520    ir_variable *different_signs = NULL;
1521    ir_constant *c0000FFFF = new(ir) ir_constant(0x0000FFFFu, elements);
1522    ir_constant *c16 = new(ir) ir_constant(16u, elements);
1523
1524    ir_instruction &i = *base_ir;
1525
1526    i.insert_before(src1);
1527    i.insert_before(src2);
1528    i.insert_before(src1h);
1529    i.insert_before(src2h);
1530    i.insert_before(src1l);
1531    i.insert_before(src2l);
1532
1533    if (ir->operands[0]->type->base_type == GLSL_TYPE_UINT) {
1534       i.insert_before(assign(src1, ir->operands[0]));
1535       i.insert_before(assign(src2, ir->operands[1]));
1536    } else {
1537       assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
1538
1539       ir_variable *itmp1 =
1540          new(ir) ir_variable(glsl_type::ivec(elements), "itmp1", ir_var_temporary);
1541       ir_variable *itmp2 =
1542          new(ir) ir_variable(glsl_type::ivec(elements), "itmp2", ir_var_temporary);
1543       ir_constant *c0 = new(ir) ir_constant(int(0), elements);
1544
1545       i.insert_before(itmp1);
1546       i.insert_before(itmp2);
1547       i.insert_before(assign(itmp1, ir->operands[0]));
1548       i.insert_before(assign(itmp2, ir->operands[1]));
1549
1550       different_signs =
1551          new(ir) ir_variable(glsl_type::bvec(elements), "different_signs",
1552                              ir_var_temporary);
1553
1554       i.insert_before(different_signs);
1555       i.insert_before(assign(different_signs, expr(ir_binop_logic_xor,
1556                                                    less(itmp1, c0),
1557                                                    less(itmp2, c0->clone(ir, NULL)))));
1558
1559       i.insert_before(assign(src1, i2u(abs(itmp1))));
1560       i.insert_before(assign(src2, i2u(abs(itmp2))));
1561    }
1562
1563    i.insert_before(assign(src1l, bit_and(src1, c0000FFFF)));
1564    i.insert_before(assign(src2l, bit_and(src2, c0000FFFF->clone(ir, NULL))));
1565    i.insert_before(assign(src1h, rshift(src1, c16)));
1566    i.insert_before(assign(src2h, rshift(src2, c16->clone(ir, NULL))));
1567
1568    i.insert_before(lo);
1569    i.insert_before(hi);
1570    i.insert_before(t1);
1571    i.insert_before(t2);
1572
1573    i.insert_before(assign(lo, mul(src1l, src2l)));
1574    i.insert_before(assign(t1, mul(src1l, src2h)));
1575    i.insert_before(assign(t2, mul(src1h, src2l)));
1576    i.insert_before(assign(hi, mul(src1h, src2h)));
1577
1578    i.insert_before(assign(hi, add(hi, _carry(lo, lshift(t1, c16->clone(ir, NULL))))));
1579    i.insert_before(assign(lo,            add(lo, lshift(t1, c16->clone(ir, NULL)))));
1580
1581    i.insert_before(assign(hi, add(hi, _carry(lo, lshift(t2, c16->clone(ir, NULL))))));
1582    i.insert_before(assign(lo,            add(lo, lshift(t2, c16->clone(ir, NULL)))));
1583
1584    if (different_signs == NULL) {
1585       assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
1586
1587       ir->operation = ir_binop_add;
1588       ir->init_num_operands();
1589       ir->operands[0] = add(hi, rshift(t1, c16->clone(ir, NULL)));
1590       ir->operands[1] = rshift(t2, c16->clone(ir, NULL));
1591    } else {
1592       assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
1593
1594       i.insert_before(assign(hi, add(add(hi, rshift(t1, c16->clone(ir, NULL))),
1595                                      rshift(t2, c16->clone(ir, NULL)))));
1596
1597       /* For channels where different_signs is set we have to perform a 64-bit
1598        * negation.  This is *not* the same as just negating the high 32-bits.
1599        * Consider -3 * 2.  The high 32-bits is 0, but the desired result is
1600        * -1, not -0!  Recall -x == ~x + 1.
1601        */
1602       ir_variable *neg_hi =
1603          new(ir) ir_variable(glsl_type::ivec(elements), "neg_hi", ir_var_temporary);
1604       ir_constant *c1 = new(ir) ir_constant(1u, elements);
1605
1606       i.insert_before(neg_hi);
1607       i.insert_before(assign(neg_hi, add(bit_not(u2i(hi)),
1608                                          u2i(_carry(bit_not(lo), c1)))));
1609
1610       ir->operation = ir_triop_csel;
1611       ir->init_num_operands();
1612       ir->operands[0] = new(ir) ir_dereference_variable(different_signs);
1613       ir->operands[1] = new(ir) ir_dereference_variable(neg_hi);
1614       ir->operands[2] = u2i(hi);
1615    }
1616 }
1617
1618 void
1619 lower_instructions_visitor::sqrt_to_abs_sqrt(ir_expression *ir)
1620 {
1621    ir->operands[0] = new(ir) ir_expression(ir_unop_abs, ir->operands[0]);
1622    this->progress = true;
1623 }
1624
1625 ir_visitor_status
1626 lower_instructions_visitor::visit_leave(ir_expression *ir)
1627 {
1628    switch (ir->operation) {
1629    case ir_binop_dot:
1630       if (ir->operands[0]->type->is_double())
1631          double_dot_to_fma(ir);
1632       break;
1633    case ir_triop_lrp:
1634       if (ir->operands[0]->type->is_double())
1635          double_lrp(ir);
1636       break;
1637    case ir_binop_sub:
1638       if (lowering(SUB_TO_ADD_NEG))
1639          sub_to_add_neg(ir);
1640       break;
1641
1642    case ir_binop_div:
1643       if (ir->operands[1]->type->is_integer() && lowering(INT_DIV_TO_MUL_RCP))
1644          int_div_to_mul_rcp(ir);
1645       else if ((ir->operands[1]->type->is_float() && lowering(FDIV_TO_MUL_RCP)) ||
1646                (ir->operands[1]->type->is_double() && lowering(DDIV_TO_MUL_RCP)))
1647          div_to_mul_rcp(ir);
1648       break;
1649
1650    case ir_unop_exp:
1651       if (lowering(EXP_TO_EXP2))
1652          exp_to_exp2(ir);
1653       break;
1654
1655    case ir_unop_log:
1656       if (lowering(LOG_TO_LOG2))
1657          log_to_log2(ir);
1658       break;
1659
1660    case ir_binop_mod:
1661       if (lowering(MOD_TO_FLOOR) && (ir->type->is_float() || ir->type->is_double()))
1662          mod_to_floor(ir);
1663       break;
1664
1665    case ir_binop_pow:
1666       if (lowering(POW_TO_EXP2))
1667          pow_to_exp2(ir);
1668       break;
1669
1670    case ir_binop_ldexp:
1671       if (lowering(LDEXP_TO_ARITH) && ir->type->is_float())
1672          ldexp_to_arith(ir);
1673       if (lowering(DFREXP_DLDEXP_TO_ARITH) && ir->type->is_double())
1674          dldexp_to_arith(ir);
1675       break;
1676
1677    case ir_unop_frexp_exp:
1678       if (lowering(DFREXP_DLDEXP_TO_ARITH) && ir->operands[0]->type->is_double())
1679          dfrexp_exp_to_arith(ir);
1680       break;
1681
1682    case ir_unop_frexp_sig:
1683       if (lowering(DFREXP_DLDEXP_TO_ARITH) && ir->operands[0]->type->is_double())
1684          dfrexp_sig_to_arith(ir);
1685       break;
1686
1687    case ir_binop_carry:
1688       if (lowering(CARRY_TO_ARITH))
1689          carry_to_arith(ir);
1690       break;
1691
1692    case ir_binop_borrow:
1693       if (lowering(BORROW_TO_ARITH))
1694          borrow_to_arith(ir);
1695       break;
1696
1697    case ir_unop_saturate:
1698       if (lowering(SAT_TO_CLAMP))
1699          sat_to_clamp(ir);
1700       break;
1701
1702    case ir_unop_trunc:
1703       if (lowering(DOPS_TO_DFRAC) && ir->type->is_double())
1704          dtrunc_to_dfrac(ir);
1705       break;
1706
1707    case ir_unop_ceil:
1708       if (lowering(DOPS_TO_DFRAC) && ir->type->is_double())
1709          dceil_to_dfrac(ir);
1710       break;
1711
1712    case ir_unop_floor:
1713       if (lowering(DOPS_TO_DFRAC) && ir->type->is_double())
1714          dfloor_to_dfrac(ir);
1715       break;
1716
1717    case ir_unop_round_even:
1718       if (lowering(DOPS_TO_DFRAC) && ir->type->is_double())
1719          dround_even_to_dfrac(ir);
1720       break;
1721
1722    case ir_unop_sign:
1723       if (lowering(DOPS_TO_DFRAC) && ir->type->is_double())
1724          dsign_to_csel(ir);
1725       break;
1726
1727    case ir_unop_bit_count:
1728       if (lowering(BIT_COUNT_TO_MATH))
1729          bit_count_to_math(ir);
1730       break;
1731
1732    case ir_triop_bitfield_extract:
1733       if (lowering(EXTRACT_TO_SHIFTS))
1734          extract_to_shifts(ir);
1735       break;
1736
1737    case ir_quadop_bitfield_insert:
1738       if (lowering(INSERT_TO_SHIFTS))
1739          insert_to_shifts(ir);
1740       break;
1741
1742    case ir_unop_bitfield_reverse:
1743       if (lowering(REVERSE_TO_SHIFTS))
1744          reverse_to_shifts(ir);
1745       break;
1746
1747    case ir_unop_find_lsb:
1748       if (lowering(FIND_LSB_TO_FLOAT_CAST))
1749          find_lsb_to_float_cast(ir);
1750       break;
1751
1752    case ir_unop_find_msb:
1753       if (lowering(FIND_MSB_TO_FLOAT_CAST))
1754          find_msb_to_float_cast(ir);
1755       break;
1756
1757    case ir_binop_imul_high:
1758       if (lowering(IMUL_HIGH_TO_MUL))
1759          imul_high_to_mul(ir);
1760       break;
1761
1762    case ir_unop_rsq:
1763    case ir_unop_sqrt:
1764       if (lowering(SQRT_TO_ABS_SQRT))
1765          sqrt_to_abs_sqrt(ir);
1766       break;
1767
1768    default:
1769       return visit_continue;
1770    }
1771
1772    return visit_continue;
1773 }